@alanszp/business-days-date-fns 12.0.1 → 12.0.3

package/node_modules/@babel/types/lib/builders/generated/uppercase.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_index","require"],"sources":["../../../src/builders/generated/uppercase.js"],"sourcesContent":["/*\n * This file is auto-generated! Do not modify it directly.\n * To re-generate run 'make build'\n */\n\n/**\n * This file is written in JavaScript and not TypeScript because uppercase builders\n * conflict with AST types. TypeScript reads the uppercase.d.ts file instead.\n */\n\nexport {\n  arrayExpression as ArrayExpression,\n  assignmentExpression as AssignmentExpression,\n  binaryExpression as BinaryExpression,\n  interpreterDirective as InterpreterDirective,\n  directive as Directive,\n  directiveLiteral as DirectiveLiteral,\n  blockStatement as BlockStatement,\n  breakStatement as BreakStatement,\n  callExpression as CallExpression,\n  catchClause as CatchClause,\n  conditionalExpression as ConditionalExpression,\n  continueStatement as ContinueStatement,\n  debuggerStatement as DebuggerStatement,\n  doWhileStatement as DoWhileStatement,\n  emptyStatement as EmptyStatement,\n  expressionStatement as ExpressionStatement,\n  file as File,\n  forInStatement as ForInStatement,\n  forStatement as ForStatement,\n  functionDeclaration as FunctionDeclaration,\n  functionExpression as FunctionExpression,\n  identifier as Identifier,\n  ifStatement as IfStatement,\n  labeledStatement as LabeledStatement,\n  stringLiteral as StringLiteral,\n  numericLiteral as NumericLiteral,\n  nullLiteral as NullLiteral,\n  booleanLiteral as BooleanLiteral,\n  regExpLiteral as RegExpLiteral,\n  logicalExpression as LogicalExpression,\n  memberExpression as MemberExpression,\n  newExpression as NewExpression,\n  program as Program,\n  objectExpression as ObjectExpression,\n  objectMethod as ObjectMethod,\n  objectProperty as ObjectProperty,\n  restElement as RestElement,\n  returnStatement as ReturnStatement,\n  sequenceExpression as SequenceExpression,\n  parenthesizedExpression as ParenthesizedExpression,\n  switchCase as SwitchCase,\n  switchStatement as SwitchStatement,\n  thisExpression as ThisExpression,\n  throwStatement as ThrowStatement,\n  tryStatement as TryStatement,\n  unaryExpression as UnaryExpression,\n  updateExpression as UpdateExpression,\n  variableDeclaration as VariableDeclaration,\n  variableDeclarator as VariableDeclarator,\n  whileStatement as WhileStatement,\n  withStatement as WithStatement,\n  assignmentPattern as AssignmentPattern,\n  arrayPattern as ArrayPattern,\n  arrowFunctionExpression as ArrowFunctionExpression,\n  classBody as ClassBody,\n  classExpression as ClassExpression,\n  classDeclaration as ClassDeclaration,\n  exportAllDeclaration as ExportAllDeclaration,\n  exportDefaultDeclaration as ExportDefaultDeclaration,\n  exportNamedDeclaration as ExportNamedDeclaration,\n  exportSpecifier as ExportSpecifier,\n  forOfStatement as ForOfStatement,\n  importDeclaration as ImportDeclaration,\n  importDefaultSpecifier as ImportDefaultSpecifier,\n  importNamespaceSpecifier as ImportNamespaceSpecifier,\n  importSpecifier as ImportSpecifier,\n  importExpression as ImportExpression,\n  metaProperty as MetaProperty,\n  classMethod as ClassMethod,\n  objectPattern as ObjectPattern,\n  spreadElement as SpreadElement,\n  super as Super,\n  taggedTemplateExpression as TaggedTemplateExpression,\n  templateElement as TemplateElement,\n  templateLiteral as TemplateLiteral,\n  yieldExpression as YieldExpression,\n  awaitExpression as AwaitExpression,\n  import as Import,\n  bigIntLiteral as BigIntLiteral,\n  exportNamespaceSpecifier as ExportNamespaceSpecifier,\n  optionalMemberExpression as OptionalMemberExpression,\n  optionalCallExpression as OptionalCallExpression,\n  classProperty as ClassProperty,\n  classAccessorProperty as ClassAccessorProperty,\n  classPrivateProperty as ClassPrivateProperty,\n  classPrivateMethod as ClassPrivateMethod,\n  privateName as PrivateName,\n  staticBlock as StaticBlock,\n  anyTypeAnnotation as AnyTypeAnnotation,\n  arrayTypeAnnotation as ArrayTypeAnnotation,\n  booleanTypeAnnotation as BooleanTypeAnnotation,\n  booleanLiteralTypeAnnotation as BooleanLiteralTypeAnnotation,\n  nullLiteralTypeAnnotation as NullLiteralTypeAnnotation,\n  classImplements as ClassImplements,\n  declareClass as DeclareClass,\n  declareFunction as DeclareFunction,\n  declareInterface as DeclareInterface,\n  declareModule as DeclareModule,\n  declareModuleExports as DeclareModuleExports,\n  declareTypeAlias as DeclareTypeAlias,\n  declareOpaqueType as DeclareOpaqueType,\n  declareVariable as DeclareVariable,\n  declareExportDeclaration as DeclareExportDeclaration,\n  declareExportAllDeclaration as DeclareExportAllDeclaration,\n  declaredPredicate as DeclaredPredicate,\n  existsTypeAnnotation as ExistsTypeAnnotation,\n  functionTypeAnnotation as FunctionTypeAnnotation,\n  functionTypeParam as FunctionTypeParam,\n  genericTypeAnnotation as GenericTypeAnnotation,\n  inferredPredicate as InferredPredicate,\n  interfaceExtends as InterfaceExtends,\n  interfaceDeclaration as InterfaceDeclaration,\n  interfaceTypeAnnotation as InterfaceTypeAnnotation,\n  intersectionTypeAnnotation as IntersectionTypeAnnotation,\n  mixedTypeAnnotation as MixedTypeAnnotation,\n  emptyTypeAnnotation as EmptyTypeAnnotation,\n  nullableTypeAnnotation as NullableTypeAnnotation,\n  numberLiteralTypeAnnotation as NumberLiteralTypeAnnotation,\n  numberTypeAnnotation as NumberTypeAnnotation,\n  objectTypeAnnotation as ObjectTypeAnnotation,\n  objectTypeInternalSlot as ObjectTypeInternalSlot,\n  objectTypeCallProperty as ObjectTypeCallProperty,\n  objectTypeIndexer as ObjectTypeIndexer,\n  objectTypeProperty as ObjectTypeProperty,\n  objectTypeSpreadProperty as ObjectTypeSpreadProperty,\n  opaqueType as OpaqueType,\n  qualifiedTypeIdentifier as QualifiedTypeIdentifier,\n  stringLiteralTypeAnnotation as StringLiteralTypeAnnotation,\n  stringTypeAnnotation as StringTypeAnnotation,\n  symbolTypeAnnotation as SymbolTypeAnnotation,\n  thisTypeAnnotation as ThisTypeAnnotation,\n  tupleTypeAnnotation as TupleTypeAnnotation,\n  typeofTypeAnnotation as TypeofTypeAnnotation,\n  typeAlias as TypeAlias,\n  typeAnnotation as TypeAnnotation,\n  typeCastExpression as TypeCastExpression,\n  typeParameter as TypeParameter,\n  typeParameterDeclaration as TypeParameterDeclaration,\n  typeParameterInstantiation as TypeParameterInstantiation,\n  unionTypeAnnotation as UnionTypeAnnotation,\n  variance as Variance,\n  voidTypeAnnotation as VoidTypeAnnotation,\n  enumDeclaration as EnumDeclaration,\n  enumBooleanBody as EnumBooleanBody,\n  enumNumberBody as EnumNumberBody,\n  enumStringBody as EnumStringBody,\n  enumSymbolBody as EnumSymbolBody,\n  enumBooleanMember as EnumBooleanMember,\n  enumNumberMember as EnumNumberMember,\n  enumStringMember as EnumStringMember,\n  enumDefaultedMember as EnumDefaultedMember,\n  indexedAccessType as IndexedAccessType,\n  optionalIndexedAccessType as OptionalIndexedAccessType,\n  jsxAttribute as JSXAttribute,\n  jsxClosingElement as JSXClosingElement,\n  jsxElement as JSXElement,\n  jsxEmptyExpression as JSXEmptyExpression,\n  jsxExpressionContainer as JSXExpressionContainer,\n  jsxSpreadChild as JSXSpreadChild,\n  jsxIdentifier as JSXIdentifier,\n  jsxMemberExpression as JSXMemberExpression,\n  jsxNamespacedName as JSXNamespacedName,\n  jsxOpeningElement as JSXOpeningElement,\n  jsxSpreadAttribute as JSXSpreadAttribute,\n  jsxText as JSXText,\n  jsxFragment as JSXFragment,\n  jsxOpeningFragment as JSXOpeningFragment,\n  jsxClosingFragment as JSXClosingFragment,\n  noop as Noop,\n  placeholder as Placeholder,\n  v8IntrinsicIdentifier as V8IntrinsicIdentifier,\n  argumentPlaceholder as ArgumentPlaceholder,\n  bindExpression as BindExpression,\n  importAttribute as ImportAttribute,\n  decorator as Decorator,\n  doExpression as DoExpression,\n  exportDefaultSpecifier as ExportDefaultSpecifier,\n  recordExpression as RecordExpression,\n  tupleExpression as TupleExpression,\n  decimalLiteral as DecimalLiteral,\n  moduleExpression as ModuleExpression,\n  topicReference as TopicReference,\n  pipelineTopicExpression as PipelineTopicExpression,\n  pipelineBareFunction as PipelineBareFunction,\n  pipelinePrimaryTopicReference as PipelinePrimaryTopicReference,\n  tsParameterProperty as TSParameterProperty,\n  tsDeclareFunction as TSDeclareFunction,\n  tsDeclareMethod as TSDeclareMethod,\n  tsQualifiedName as TSQualifiedName,\n  tsCallSignatureDeclaration as TSCallSignatureDeclaration,\n  tsConstructSignatureDeclaration as TSConstructSignatureDeclaration,\n  tsPropertySignature as TSPropertySignature,\n  tsMethodSignature as TSMethodSignature,\n  tsIndexSignature as TSIndexSignature,\n  tsAnyKeyword as TSAnyKeyword,\n  tsBooleanKeyword as TSBooleanKeyword,\n  tsBigIntKeyword as TSBigIntKeyword,\n  tsIntrinsicKeyword as TSIntrinsicKeyword,\n  tsNeverKeyword as TSNeverKeyword,\n  tsNullKeyword as TSNullKeyword,\n  tsNumberKeyword as TSNumberKeyword,\n  tsObjectKeyword as TSObjectKeyword,\n  tsStringKeyword as TSStringKeyword,\n  tsSymbolKeyword as TSSymbolKeyword,\n  tsUndefinedKeyword as TSUndefinedKeyword,\n  tsUnknownKeyword as TSUnknownKeyword,\n  tsVoidKeyword as TSVoidKeyword,\n  tsThisType as TSThisType,\n  tsFunctionType as TSFunctionType,\n  tsConstructorType as TSConstructorType,\n  tsTypeReference as TSTypeReference,\n  tsTypePredicate as TSTypePredicate,\n  tsTypeQuery as TSTypeQuery,\n  tsTypeLiteral as TSTypeLiteral,\n  tsArrayType as TSArrayType,\n  tsTupleType as TSTupleType,\n  tsOptionalType as TSOptionalType,\n  tsRestType as TSRestType,\n  tsNamedTupleMember as TSNamedTupleMember,\n  tsUnionType as TSUnionType,\n  tsIntersectionType as TSIntersectionType,\n  tsConditionalType as TSConditionalType,\n  tsInferType as TSInferType,\n  tsParenthesizedType as TSParenthesizedType,\n  tsTypeOperator as TSTypeOperator,\n  tsIndexedAccessType as TSIndexedAccessType,\n  tsMappedType as TSMappedType,\n  tsLiteralType as TSLiteralType,\n  tsExpressionWithTypeArguments as TSExpressionWithTypeArguments,\n  tsInterfaceDeclaration as TSInterfaceDeclaration,\n  tsInterfaceBody as TSInterfaceBody,\n  tsTypeAliasDeclaration as TSTypeAliasDeclaration,\n  tsInstantiationExpression as TSInstantiationExpression,\n  tsAsExpression as TSAsExpression,\n  tsSatisfiesExpression as TSSatisfiesExpression,\n  tsTypeAssertion as TSTypeAssertion,\n  tsEnumDeclaration as TSEnumDeclaration,\n  tsEnumMember as TSEnumMember,\n  tsModuleDeclaration as TSModuleDeclaration,\n  tsModuleBlock as TSModuleBlock,\n  tsImportType as TSImportType,\n  tsImportEqualsDeclaration as TSImportEqualsDeclaration,\n  tsExternalModuleReference as TSExternalModuleReference,\n  tsNonNullExpression as TSNonNullExpression,\n  tsExportAssignment as TSExportAssignment,\n  tsNamespaceExportDeclaration as TSNamespaceExportDeclaration,\n  tsTypeAnnotation as TSTypeAnnotation,\n  tsTypeParameterInstantiation as TSTypeParameterInstantiation,\n  tsTypeParameterDeclaration as TSTypeParameterDeclaration,\n  tsTypeParameter as TSTypeParameter,\n  numberLiteral as NumberLiteral,\n  regexLiteral as RegexLiteral,\n  restProperty as RestProperty,\n  spreadProperty as SpreadProperty,\n} from \"./index.ts\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUA,IAAAA,MAAA,GAAAC,OAAA"}

package/node_modules/@babel/types/lib/builders/productions.js

@@ -1,12 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.buildUndefinedNode = buildUndefinedNode;
-var _index = require("./generated/index.js");
-function buildUndefinedNode() {
-  return (0, _index.unaryExpression)("void", (0, _index.numericLiteral)(0), true);
-}
-
-//# sourceMappingURL=productions.js.map

package/node_modules/@babel/types/lib/builders/productions.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_index","require","buildUndefinedNode","unaryExpression","numericLiteral"],"sources":["../../src/builders/productions.ts"],"sourcesContent":["import { numericLiteral, unaryExpression } from \"./generated/index.ts\";\n\nexport function buildUndefinedNode() {\n  return unaryExpression(\"void\", numericLiteral(0), true);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEO,SAASC,kBAAkBA,CAAA,EAAG;EACnC,OAAO,IAAAC,sBAAe,EAAC,MAAM,EAAE,IAAAC,qBAAc,EAAC,CAAC,CAAC,EAAE,IAAI,CAAC;AACzD"}

package/node_modules/@babel/types/lib/builders/react/buildChildren.js

@@ -1,24 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = buildChildren;
-var _index = require("../../validators/generated/index.js");
-var _cleanJSXElementLiteralChild = require("../../utils/react/cleanJSXElementLiteralChild.js");
-function buildChildren(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;
-}
-
-//# sourceMappingURL=buildChildren.js.map

package/node_modules/@babel/types/lib/builders/react/buildChildren.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_index","require","_cleanJSXElementLiteralChild","buildChildren","node","elements","i","children","length","child","isJSXText","cleanJSXElementLiteralChild","isJSXExpressionContainer","expression","isJSXEmptyExpression","push"],"sources":["../../../src/builders/react/buildChildren.ts"],"sourcesContent":["import {\n  isJSXText,\n  isJSXExpressionContainer,\n  isJSXEmptyExpression,\n} from \"../../validators/generated/index.ts\";\nimport cleanJSXElementLiteralChild from \"../../utils/react/cleanJSXElementLiteralChild.ts\";\nimport type * as t from \"../../index.ts\";\n\ntype ReturnedChild =\n  | t.JSXSpreadChild\n  | t.JSXElement\n  | t.JSXFragment\n  | t.Expression;\n\nexport default function buildChildren(\n  node: t.JSXElement | t.JSXFragment,\n): ReturnedChild[] {\n  const elements = [];\n\n  for (let i = 0; i < node.children.length; i++) {\n    let child: any = node.children[i];\n\n    if (isJSXText(child)) {\n      cleanJSXElementLiteralChild(child, elements);\n      continue;\n    }\n\n    if (isJSXExpressionContainer(child)) child = child.expression;\n    if (isJSXEmptyExpression(child)) continue;\n\n    elements.push(child);\n  }\n\n  return elements;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAKA,IAAAC,4BAAA,GAAAD,OAAA;AASe,SAASE,aAAaA,CACnCC,IAAkC,EACjB;EACjB,MAAMC,QAAQ,GAAG,EAAE;EAEnB,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,IAAI,CAACG,QAAQ,CAACC,MAAM,EAAEF,CAAC,EAAE,EAAE;IAC7C,IAAIG,KAAU,GAAGL,IAAI,CAACG,QAAQ,CAACD,CAAC,CAAC;IAEjC,IAAI,IAAAI,gBAAS,EAACD,KAAK,CAAC,EAAE;MACpB,IAAAE,oCAA2B,EAACF,KAAK,EAAEJ,QAAQ,CAAC;MAC5C;IACF;IAEA,IAAI,IAAAO,+BAAwB,EAACH,KAAK,CAAC,EAAEA,KAAK,GAAGA,KAAK,CAACI,UAAU;IAC7D,IAAI,IAAAC,2BAAoB,EAACL,KAAK,CAAC,EAAE;IAEjCJ,QAAQ,CAACU,IAAI,CAACN,KAAK,CAAC;EACtB;EAEA,OAAOJ,QAAQ;AACjB"}

package/node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js

@@ -1,22 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = createTSUnionType;
-var _index = require("../generated/index.js");
-var _removeTypeDuplicates = require("../../modifications/typescript/removeTypeDuplicates.js");
-var _index2 = require("../../validators/generated/index.js");
-function createTSUnionType(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);
-  }
-}
-
-//# sourceMappingURL=createTSUnionType.js.map

package/node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_index","require","_removeTypeDuplicates","_index2","createTSUnionType","typeAnnotations","types","map","type","isTSTypeAnnotation","typeAnnotation","flattened","removeTypeDuplicates","length","tsUnionType"],"sources":["../../../src/builders/typescript/createTSUnionType.ts"],"sourcesContent":["import { tsUnionType } from \"../generated/index.ts\";\nimport removeTypeDuplicates from \"../../modifications/typescript/removeTypeDuplicates.ts\";\nimport { isTSTypeAnnotation } from \"../../validators/generated/index.ts\";\nimport type * as t from \"../../index.ts\";\n\n/**\n * Takes an array of `types` and flattens them, removing duplicates and\n * returns a `UnionTypeAnnotation` node containing them.\n */\nexport default function createTSUnionType(\n  typeAnnotations: Array<t.TSTypeAnnotation | t.TSType>,\n): t.TSType {\n  const types = typeAnnotations.map(type => {\n    return isTSTypeAnnotation(type) ? type.typeAnnotation : type;\n  });\n  const flattened = removeTypeDuplicates(types);\n\n  if (flattened.length === 1) {\n    return flattened[0];\n  } else {\n    return tsUnionType(flattened);\n  }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,qBAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AAOe,SAASG,iBAAiBA,CACvCC,eAAqD,EAC3C;EACV,MAAMC,KAAK,GAAGD,eAAe,CAACE,GAAG,CAACC,IAAI,IAAI;IACxC,OAAO,IAAAC,0BAAkB,EAACD,IAAI,CAAC,GAAGA,IAAI,CAACE,cAAc,GAAGF,IAAI;EAC9D,CAAC,CAAC;EACF,MAAMG,SAAS,GAAG,IAAAC,6BAAoB,EAACN,KAAK,CAAC;EAE7C,IAAIK,SAAS,CAACE,MAAM,KAAK,CAAC,EAAE;IAC1B,OAAOF,SAAS,CAAC,CAAC,CAAC;EACrB,CAAC,MAAM;IACL,OAAO,IAAAG,kBAAW,EAACH,SAAS,CAAC;EAC/B;AACF"}

package/node_modules/@babel/types/lib/builders/validateNode.js

@@ -1,17 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = validateNode;
-var _validate = require("../validators/validate.js");
-var _index = require("../index.js");
-function validateNode(node) {
-  const keys = _index.BUILDER_KEYS[node.type];
-  for (const key of keys) {
-    (0, _validate.default)(node, key, node[key]);
-  }
-  return node;
-}
-
-//# sourceMappingURL=validateNode.js.map

package/node_modules/@babel/types/lib/builders/validateNode.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_validate","require","_index","validateNode","node","keys","BUILDER_KEYS","type","key","validate"],"sources":["../../src/builders/validateNode.ts"],"sourcesContent":["import validate from \"../validators/validate.ts\";\nimport type * as t from \"../index.ts\";\nimport { BUILDER_KEYS } from \"../index.ts\";\n\nexport default function validateNode<N extends t.Node>(node: N) {\n  // todo: because keys not in BUILDER_KEYS are not validated - this actually allows invalid nodes in some cases\n  const keys = BUILDER_KEYS[node.type] as (keyof N & string)[];\n  for (const key of keys) {\n    validate(node, key, node[key]);\n  }\n  return node;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,SAAA,GAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAD,OAAA;AAEe,SAASE,YAAYA,CAAmBC,IAAO,EAAE;EAE9D,MAAMC,IAAI,GAAGC,mBAAY,CAACF,IAAI,CAACG,IAAI,CAAyB;EAC5D,KAAK,MAAMC,GAAG,IAAIH,IAAI,EAAE;IACtB,IAAAI,iBAAQ,EAACL,IAAI,EAAEI,GAAG,EAAEJ,IAAI,CAACI,GAAG,CAAC,CAAC;EAChC;EACA,OAAOJ,IAAI;AACb"}

package/node_modules/@babel/types/lib/clone/clone.js

@@ -1,12 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = clone;
-var _cloneNode = require("./cloneNode.js");
-function clone(node) {
-  return (0, _cloneNode.default)(node, false);
-}
-
-//# sourceMappingURL=clone.js.map

package/node_modules/@babel/types/lib/clone/clone.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_cloneNode","require","clone","node","cloneNode"],"sources":["../../src/clone/clone.ts"],"sourcesContent":["import cloneNode from \"./cloneNode.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Create a shallow clone of a `node`, including only\n * properties belonging to the node.\n * @deprecated Use t.cloneNode instead.\n */\nexport default function clone<T extends t.Node>(node: T): T {\n  return cloneNode(node, /* deep */ false);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAQe,SAASC,KAAKA,CAAmBC,IAAO,EAAK;EAC1D,OAAO,IAAAC,kBAAS,EAACD,IAAI,EAAa,KAAK,CAAC;AAC1C"}

package/node_modules/@babel/types/lib/clone/cloneDeep.js

@@ -1,12 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = cloneDeep;
-var _cloneNode = require("./cloneNode.js");
-function cloneDeep(node) {
-  return (0, _cloneNode.default)(node);
-}
-
-//# sourceMappingURL=cloneDeep.js.map

package/node_modules/@babel/types/lib/clone/cloneDeep.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_cloneNode","require","cloneDeep","node","cloneNode"],"sources":["../../src/clone/cloneDeep.ts"],"sourcesContent":["import cloneNode from \"./cloneNode.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Create a deep clone of a `node` and all of it's child nodes\n * including only properties belonging to the node.\n * @deprecated Use t.cloneNode instead.\n */\nexport default function cloneDeep<T extends t.Node>(node: T): T {\n  return cloneNode(node);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAQe,SAASC,SAASA,CAAmBC,IAAO,EAAK;EAC9D,OAAO,IAAAC,kBAAS,EAACD,IAAI,CAAC;AACxB"}

package/node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js

@@ -1,12 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = cloneDeepWithoutLoc;
-var _cloneNode = require("./cloneNode.js");
-function cloneDeepWithoutLoc(node) {
-  return (0, _cloneNode.default)(node, true, true);
-}
-
-//# sourceMappingURL=cloneDeepWithoutLoc.js.map

package/node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_cloneNode","require","cloneDeepWithoutLoc","node","cloneNode"],"sources":["../../src/clone/cloneDeepWithoutLoc.ts"],"sourcesContent":["import cloneNode from \"./cloneNode.ts\";\nimport type * as t from \"../index.ts\";\n/**\n * Create a deep clone of a `node` and all of it's child nodes\n * including only properties belonging to the node.\n * excluding `_private` and location properties.\n */\nexport default function cloneDeepWithoutLoc<T extends t.Node>(node: T): T {\n  return cloneNode(node, /* deep */ true, /* withoutLoc */ true);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAOe,SAASC,mBAAmBA,CAAmBC,IAAO,EAAK;EACxE,OAAO,IAAAC,kBAAS,EAACD,IAAI,EAAa,IAAI,EAAmB,IAAI,CAAC;AAChE"}

package/node_modules/@babel/types/lib/clone/cloneNode.js

@@ -1,100 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = cloneNode;
-var _index = require("../definitions/index.js");
-var _index2 = require("../validators/generated/index.js");
-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(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;
-  });
-}
-
-//# sourceMappingURL=cloneNode.js.map

package/node_modules/@babel/types/lib/clone/cloneNode.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_index","require","_index2","has","Function","call","bind","Object","prototype","hasOwnProperty","cloneIfNode","obj","deep","withoutLoc","commentsCache","type","cloneNodeInternal","cloneIfNodeOrArray","Array","isArray","map","node","cloneNode","Map","newNode","isIdentifier","name","optional","typeAnnotation","NODE_FIELDS","Error","field","keys","isFile","maybeCloneComments","comments","loc","leadingComments","innerComments","trailingComments","extra","assign","comment","cache","get","value","ret","set"],"sources":["../../src/clone/cloneNode.ts"],"sourcesContent":["import { NODE_FIELDS } from \"../definitions/index.ts\";\nimport type * as t from \"../index.ts\";\nimport { isFile, isIdentifier } from \"../validators/generated/index.ts\";\n\nconst has = Function.call.bind(Object.prototype.hasOwnProperty);\n\ntype CommentCache = Map<t.Comment, t.Comment>;\n\n// This function will never be called for comments, only for real nodes.\nfunction cloneIfNode(\n  obj: t.Node | undefined | null,\n  deep: boolean,\n  withoutLoc: boolean,\n  commentsCache: CommentCache,\n) {\n  if (obj && typeof obj.type === \"string\") {\n    return cloneNodeInternal(obj, deep, withoutLoc, commentsCache);\n  }\n\n  return obj;\n}\n\nfunction cloneIfNodeOrArray(\n  obj: t.Node | undefined | null | (t.Node | undefined | null)[],\n  deep: boolean,\n  withoutLoc: boolean,\n  commentsCache: CommentCache,\n) {\n  if (Array.isArray(obj)) {\n    return obj.map(node => cloneIfNode(node, deep, withoutLoc, commentsCache));\n  }\n  return cloneIfNode(obj, deep, withoutLoc, commentsCache);\n}\n\n/**\n * Create a clone of a `node` including only properties belonging to the node.\n * If the second parameter is `false`, cloneNode performs a shallow clone.\n * If the third parameter is true, the cloned nodes exclude location properties.\n */\nexport default function cloneNode<T extends t.Node>(\n  node: T,\n  deep: boolean = true,\n  withoutLoc: boolean = false,\n): T {\n  return cloneNodeInternal(node, deep, withoutLoc, new Map());\n}\n\nfunction cloneNodeInternal<T extends t.Node>(\n  node: T,\n  deep: boolean = true,\n  withoutLoc: boolean = false,\n  commentsCache: CommentCache,\n): T {\n  if (!node) return node;\n\n  const { type } = node;\n  const newNode: any = { type: node.type };\n\n  // Special-case identifiers since they are the most cloned nodes.\n  if (isIdentifier(node)) {\n    newNode.name = node.name;\n\n    if (has(node, \"optional\") && typeof node.optional === \"boolean\") {\n      newNode.optional = node.optional;\n    }\n\n    if (has(node, \"typeAnnotation\")) {\n      newNode.typeAnnotation = deep\n        ? cloneIfNodeOrArray(\n            node.typeAnnotation,\n            true,\n            withoutLoc,\n            commentsCache,\n          )\n        : node.typeAnnotation;\n    }\n  } else if (!has(NODE_FIELDS, type)) {\n    throw new Error(`Unknown node type: \"${type}\"`);\n  } else {\n    for (const field of Object.keys(NODE_FIELDS[type])) {\n      if (has(node, field)) {\n        if (deep) {\n          newNode[field] =\n            isFile(node) && field === \"comments\"\n              ? maybeCloneComments(\n                  node.comments,\n                  deep,\n                  withoutLoc,\n                  commentsCache,\n                )\n              : cloneIfNodeOrArray(\n                  // @ts-expect-error node[field] has been guarded by has check\n                  node[field],\n                  true,\n                  withoutLoc,\n                  commentsCache,\n                );\n        } else {\n          newNode[field] =\n            // @ts-expect-error node[field] has been guarded by has check\n            node[field];\n        }\n      }\n    }\n  }\n\n  if (has(node, \"loc\")) {\n    if (withoutLoc) {\n      newNode.loc = null;\n    } else {\n      newNode.loc = node.loc;\n    }\n  }\n  if (has(node, \"leadingComments\")) {\n    newNode.leadingComments = maybeCloneComments(\n      node.leadingComments,\n      deep,\n      withoutLoc,\n      commentsCache,\n    );\n  }\n  if (has(node, \"innerComments\")) {\n    newNode.innerComments = maybeCloneComments(\n      node.innerComments,\n      deep,\n      withoutLoc,\n      commentsCache,\n    );\n  }\n  if (has(node, \"trailingComments\")) {\n    newNode.trailingComments = maybeCloneComments(\n      node.trailingComments,\n      deep,\n      withoutLoc,\n      commentsCache,\n    );\n  }\n  if (has(node, \"extra\")) {\n    newNode.extra = {\n      ...node.extra,\n    };\n  }\n\n  return newNode;\n}\n\nfunction maybeCloneComments<T extends t.Comment>(\n  comments: ReadonlyArray<T> | null,\n  deep: boolean,\n  withoutLoc: boolean,\n  commentsCache: Map<T, T>,\n): ReadonlyArray<T> | null {\n  if (!comments || !deep) {\n    return comments;\n  }\n  return comments.map(comment => {\n    const cache = commentsCache.get(comment);\n    if (cache) return cache;\n\n    const { type, value, loc } = comment;\n\n    const ret = { type, value, loc } as T;\n    if (withoutLoc) {\n      ret.loc = null;\n    }\n\n    commentsCache.set(comment, ret);\n\n    return ret;\n  });\n}\n"],"mappings":"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"}

package/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js

@@ -1,12 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = cloneWithoutLoc;
-var _cloneNode = require("./cloneNode.js");
-function cloneWithoutLoc(node) {
-  return (0, _cloneNode.default)(node, false, true);
-}
-
-//# sourceMappingURL=cloneWithoutLoc.js.map

package/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_cloneNode","require","cloneWithoutLoc","node","cloneNode"],"sources":["../../src/clone/cloneWithoutLoc.ts"],"sourcesContent":["import cloneNode from \"./cloneNode.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Create a shallow clone of a `node` excluding `_private` and location properties.\n */\nexport default function cloneWithoutLoc<T extends t.Node>(node: T): T {\n  return cloneNode(node, /* deep */ false, /* withoutLoc */ true);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAMe,SAASC,eAAeA,CAAmBC,IAAO,EAAK;EACpE,OAAO,IAAAC,kBAAS,EAACD,IAAI,EAAa,KAAK,EAAmB,IAAI,CAAC;AACjE"}

package/node_modules/@babel/types/lib/comments/addComment.js

@@ -1,15 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = addComment;
-var _addComments = require("./addComments.js");
-function addComment(node, type, content, line) {
-  return (0, _addComments.default)(node, type, [{
-    type: line ? "CommentLine" : "CommentBlock",
-    value: content
-  }]);
-}
-
-//# sourceMappingURL=addComment.js.map

package/node_modules/@babel/types/lib/comments/addComment.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_addComments","require","addComment","node","type","content","line","addComments","value"],"sources":["../../src/comments/addComment.ts"],"sourcesContent":["import addComments from \"./addComments.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Add comment of certain type to a node.\n */\nexport default function addComment<T extends t.Node>(\n  node: T,\n  type: t.CommentTypeShorthand,\n  content: string,\n  line?: boolean,\n): T {\n  return addComments(node, type, [\n    {\n      type: line ? \"CommentLine\" : \"CommentBlock\",\n      value: content,\n    } as t.Comment,\n  ]);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAMe,SAASC,UAAUA,CAChCC,IAAO,EACPC,IAA4B,EAC5BC,OAAe,EACfC,IAAc,EACX;EACH,OAAO,IAAAC,oBAAW,EAACJ,IAAI,EAAEC,IAAI,EAAE,CAC7B;IACEA,IAAI,EAAEE,IAAI,GAAG,aAAa,GAAG,cAAc;IAC3CE,KAAK,EAAEH;EACT,CAAC,CACF,CAAC;AACJ"}

package/node_modules/@babel/types/lib/comments/addComments.js

@@ -1,22 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = addComments;
-function addComments(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;
-}
-
-//# sourceMappingURL=addComments.js.map

package/node_modules/@babel/types/lib/comments/addComments.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["addComments","node","type","comments","key","concat","push"],"sources":["../../src/comments/addComments.ts"],"sourcesContent":["import type * as t from \"../index.ts\";\n\n/**\n * Add comments of certain type to a node.\n */\nexport default function addComments<T extends t.Node>(\n  node: T,\n  type: t.CommentTypeShorthand,\n  comments: Array<t.Comment>,\n): T {\n  if (!comments || !node) return node;\n\n  const key = `${type}Comments` as const;\n\n  if (node[key]) {\n    if (type === \"leading\") {\n      node[key] = comments.concat(node[key]);\n    } else {\n      node[key].push(...comments);\n    }\n  } else {\n    node[key] = comments;\n  }\n\n  return node;\n}\n"],"mappings":";;;;;;AAKe,SAASA,WAAWA,CACjCC,IAAO,EACPC,IAA4B,EAC5BC,QAA0B,EACvB;EACH,IAAI,CAACA,QAAQ,IAAI,CAACF,IAAI,EAAE,OAAOA,IAAI;EAEnC,MAAMG,GAAG,GAAI,GAAEF,IAAK,UAAkB;EAEtC,IAAID,IAAI,CAACG,GAAG,CAAC,EAAE;IACb,IAAIF,IAAI,KAAK,SAAS,EAAE;MACtBD,IAAI,CAACG,GAAG,CAAC,GAAGD,QAAQ,CAACE,MAAM,CAACJ,IAAI,CAACG,GAAG,CAAC,CAAC;IACxC,CAAC,MAAM;MACLH,IAAI,CAACG,GAAG,CAAC,CAACE,IAAI,CAAC,GAAGH,QAAQ,CAAC;IAC7B;EACF,CAAC,MAAM;IACLF,IAAI,CAACG,GAAG,CAAC,GAAGD,QAAQ;EACtB;EAEA,OAAOF,IAAI;AACb"}

package/node_modules/@babel/types/lib/comments/inheritInnerComments.js

@@ -1,12 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = inheritInnerComments;
-var _inherit = require("../utils/inherit.js");
-function inheritInnerComments(child, parent) {
-  (0, _inherit.default)("innerComments", child, parent);
-}
-
-//# sourceMappingURL=inheritInnerComments.js.map

package/node_modules/@babel/types/lib/comments/inheritInnerComments.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_inherit","require","inheritInnerComments","child","parent","inherit"],"sources":["../../src/comments/inheritInnerComments.ts"],"sourcesContent":["import inherit from \"../utils/inherit.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function inheritInnerComments(\n  child: t.Node,\n  parent: t.Node,\n): void {\n  inherit(\"innerComments\", child, parent);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,QAAA,GAAAC,OAAA;AAGe,SAASC,oBAAoBA,CAC1CC,KAAa,EACbC,MAAc,EACR;EACN,IAAAC,gBAAO,EAAC,eAAe,EAAEF,KAAK,EAAEC,MAAM,CAAC;AACzC"}

package/node_modules/@babel/types/lib/comments/inheritLeadingComments.js

@@ -1,12 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = inheritLeadingComments;
-var _inherit = require("../utils/inherit.js");
-function inheritLeadingComments(child, parent) {
-  (0, _inherit.default)("leadingComments", child, parent);
-}
-
-//# sourceMappingURL=inheritLeadingComments.js.map

package/node_modules/@babel/types/lib/comments/inheritLeadingComments.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_inherit","require","inheritLeadingComments","child","parent","inherit"],"sources":["../../src/comments/inheritLeadingComments.ts"],"sourcesContent":["import inherit from \"../utils/inherit.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function inheritLeadingComments(\n  child: t.Node,\n  parent: t.Node,\n): void {\n  inherit(\"leadingComments\", child, parent);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,QAAA,GAAAC,OAAA;AAGe,SAASC,sBAAsBA,CAC5CC,KAAa,EACbC,MAAc,EACR;EACN,IAAAC,gBAAO,EAAC,iBAAiB,EAAEF,KAAK,EAAEC,MAAM,CAAC;AAC3C"}

package/node_modules/@babel/types/lib/comments/inheritTrailingComments.js

@@ -1,12 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = inheritTrailingComments;
-var _inherit = require("../utils/inherit.js");
-function inheritTrailingComments(child, parent) {
-  (0, _inherit.default)("trailingComments", child, parent);
-}
-
-//# sourceMappingURL=inheritTrailingComments.js.map

package/node_modules/@babel/types/lib/comments/inheritTrailingComments.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_inherit","require","inheritTrailingComments","child","parent","inherit"],"sources":["../../src/comments/inheritTrailingComments.ts"],"sourcesContent":["import inherit from \"../utils/inherit.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function inheritTrailingComments(\n  child: t.Node,\n  parent: t.Node,\n): void {\n  inherit(\"trailingComments\", child, parent);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,QAAA,GAAAC,OAAA;AAGe,SAASC,uBAAuBA,CAC7CC,KAAa,EACbC,MAAc,EACR;EACN,IAAAC,gBAAO,EAAC,kBAAkB,EAAEF,KAAK,EAAEC,MAAM,CAAC;AAC5C"}

package/node_modules/@babel/types/lib/comments/inheritsComments.js

@@ -1,17 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = inheritsComments;
-var _inheritTrailingComments = require("./inheritTrailingComments.js");
-var _inheritLeadingComments = require("./inheritLeadingComments.js");
-var _inheritInnerComments = require("./inheritInnerComments.js");
-function inheritsComments(child, parent) {
-  (0, _inheritTrailingComments.default)(child, parent);
-  (0, _inheritLeadingComments.default)(child, parent);
-  (0, _inheritInnerComments.default)(child, parent);
-  return child;
-}
-
-//# sourceMappingURL=inheritsComments.js.map

package/node_modules/@babel/types/lib/comments/inheritsComments.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_inheritTrailingComments","require","_inheritLeadingComments","_inheritInnerComments","inheritsComments","child","parent","inheritTrailingComments","inheritLeadingComments","inheritInnerComments"],"sources":["../../src/comments/inheritsComments.ts"],"sourcesContent":["import inheritTrailingComments from \"./inheritTrailingComments.ts\";\nimport inheritLeadingComments from \"./inheritLeadingComments.ts\";\nimport inheritInnerComments from \"./inheritInnerComments.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Inherit all unique comments from `parent` node to `child` node.\n */\nexport default function inheritsComments<T extends t.Node>(\n  child: T,\n  parent: t.Node,\n): T {\n  inheritTrailingComments(child, parent);\n  inheritLeadingComments(child, parent);\n  inheritInnerComments(child, parent);\n\n  return child;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AACA,IAAAC,uBAAA,GAAAD,OAAA;AACA,IAAAE,qBAAA,GAAAF,OAAA;AAMe,SAASG,gBAAgBA,CACtCC,KAAQ,EACRC,MAAc,EACX;EACH,IAAAC,gCAAuB,EAACF,KAAK,EAAEC,MAAM,CAAC;EACtC,IAAAE,+BAAsB,EAACH,KAAK,EAAEC,MAAM,CAAC;EACrC,IAAAG,6BAAoB,EAACJ,KAAK,EAAEC,MAAM,CAAC;EAEnC,OAAOD,KAAK;AACd"}

package/node_modules/@babel/types/lib/comments/removeComments.js

@@ -1,15 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = removeComments;
-var _index = require("../constants/index.js");
-function removeComments(node) {
-  _index.COMMENT_KEYS.forEach(key => {
-    node[key] = null;
-  });
-  return node;
-}
-
-//# sourceMappingURL=removeComments.js.map

package/node_modules/@babel/types/lib/comments/removeComments.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_index","require","removeComments","node","COMMENT_KEYS","forEach","key"],"sources":["../../src/comments/removeComments.ts"],"sourcesContent":["import { COMMENT_KEYS } from \"../constants/index.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Remove comment properties from a node.\n */\nexport default function removeComments<T extends t.Node>(node: T): T {\n  COMMENT_KEYS.forEach(key => {\n    node[key] = null;\n  });\n\n  return node;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAMe,SAASC,cAAcA,CAAmBC,IAAO,EAAK;EACnEC,mBAAY,CAACC,OAAO,CAACC,GAAG,IAAI;IAC1BH,IAAI,CAACG,GAAG,CAAC,GAAG,IAAI;EAClB,CAAC,CAAC;EAEF,OAAOH,IAAI;AACb"}

package/node_modules/@babel/types/lib/constants/generated/index.js

@@ -1,59 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.WHILE_TYPES = exports.USERWHITESPACABLE_TYPES = exports.UNARYLIKE_TYPES = exports.TYPESCRIPT_TYPES = exports.TSTYPE_TYPES = exports.TSTYPEELEMENT_TYPES = exports.TSENTITYNAME_TYPES = exports.TSBASETYPE_TYPES = exports.TERMINATORLESS_TYPES = exports.STATEMENT_TYPES = exports.STANDARDIZED_TYPES = exports.SCOPABLE_TYPES = exports.PUREISH_TYPES = exports.PROPERTY_TYPES = exports.PRIVATE_TYPES = exports.PATTERN_TYPES = exports.PATTERNLIKE_TYPES = exports.OBJECTMEMBER_TYPES = exports.MODULESPECIFIER_TYPES = exports.MODULEDECLARATION_TYPES = exports.MISCELLANEOUS_TYPES = exports.METHOD_TYPES = exports.LVAL_TYPES = exports.LOOP_TYPES = exports.LITERAL_TYPES = exports.JSX_TYPES = exports.IMPORTOREXPORTDECLARATION_TYPES = exports.IMMUTABLE_TYPES = exports.FUNCTION_TYPES = exports.FUNCTIONPARENT_TYPES = exports.FOR_TYPES = exports.FORXSTATEMENT_TYPES = exports.FLOW_TYPES = exports.FLOWTYPE_TYPES = exports.FLOWPREDICATE_TYPES = exports.FLOWDECLARATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = exports.EXPRESSION_TYPES = exports.EXPRESSIONWRAPPER_TYPES = exports.EXPORTDECLARATION_TYPES = exports.ENUMMEMBER_TYPES = exports.ENUMBODY_TYPES = exports.DECLARATION_TYPES = exports.CONDITIONAL_TYPES = exports.COMPLETIONSTATEMENT_TYPES = exports.CLASS_TYPES = exports.BLOCK_TYPES = exports.BLOCKPARENT_TYPES = exports.BINARY_TYPES = exports.ACCESSOR_TYPES = void 0;
-var _index = require("../../definitions/index.js");
-const STANDARDIZED_TYPES = exports.STANDARDIZED_TYPES = _index.FLIPPED_ALIAS_KEYS["Standardized"];
-const EXPRESSION_TYPES = exports.EXPRESSION_TYPES = _index.FLIPPED_ALIAS_KEYS["Expression"];
-const BINARY_TYPES = exports.BINARY_TYPES = _index.FLIPPED_ALIAS_KEYS["Binary"];
-const SCOPABLE_TYPES = exports.SCOPABLE_TYPES = _index.FLIPPED_ALIAS_KEYS["Scopable"];
-const BLOCKPARENT_TYPES = exports.BLOCKPARENT_TYPES = _index.FLIPPED_ALIAS_KEYS["BlockParent"];
-const BLOCK_TYPES = exports.BLOCK_TYPES = _index.FLIPPED_ALIAS_KEYS["Block"];
-const STATEMENT_TYPES = exports.STATEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS["Statement"];
-const TERMINATORLESS_TYPES = exports.TERMINATORLESS_TYPES = _index.FLIPPED_ALIAS_KEYS["Terminatorless"];
-const COMPLETIONSTATEMENT_TYPES = exports.COMPLETIONSTATEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS["CompletionStatement"];
-const CONDITIONAL_TYPES = exports.CONDITIONAL_TYPES = _index.FLIPPED_ALIAS_KEYS["Conditional"];
-const LOOP_TYPES = exports.LOOP_TYPES = _index.FLIPPED_ALIAS_KEYS["Loop"];
-const WHILE_TYPES = exports.WHILE_TYPES = _index.FLIPPED_ALIAS_KEYS["While"];
-const EXPRESSIONWRAPPER_TYPES = exports.EXPRESSIONWRAPPER_TYPES = _index.FLIPPED_ALIAS_KEYS["ExpressionWrapper"];
-const FOR_TYPES = exports.FOR_TYPES = _index.FLIPPED_ALIAS_KEYS["For"];
-const FORXSTATEMENT_TYPES = exports.FORXSTATEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS["ForXStatement"];
-const FUNCTION_TYPES = exports.FUNCTION_TYPES = _index.FLIPPED_ALIAS_KEYS["Function"];
-const FUNCTIONPARENT_TYPES = exports.FUNCTIONPARENT_TYPES = _index.FLIPPED_ALIAS_KEYS["FunctionParent"];
-const PUREISH_TYPES = exports.PUREISH_TYPES = _index.FLIPPED_ALIAS_KEYS["Pureish"];
-const DECLARATION_TYPES = exports.DECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS["Declaration"];
-const PATTERNLIKE_TYPES = exports.PATTERNLIKE_TYPES = _index.FLIPPED_ALIAS_KEYS["PatternLike"];
-const LVAL_TYPES = exports.LVAL_TYPES = _index.FLIPPED_ALIAS_KEYS["LVal"];
-const TSENTITYNAME_TYPES = exports.TSENTITYNAME_TYPES = _index.FLIPPED_ALIAS_KEYS["TSEntityName"];
-const LITERAL_TYPES = exports.LITERAL_TYPES = _index.FLIPPED_ALIAS_KEYS["Literal"];
-const IMMUTABLE_TYPES = exports.IMMUTABLE_TYPES = _index.FLIPPED_ALIAS_KEYS["Immutable"];
-const USERWHITESPACABLE_TYPES = exports.USERWHITESPACABLE_TYPES = _index.FLIPPED_ALIAS_KEYS["UserWhitespacable"];
-const METHOD_TYPES = exports.METHOD_TYPES = _index.FLIPPED_ALIAS_KEYS["Method"];
-const OBJECTMEMBER_TYPES = exports.OBJECTMEMBER_TYPES = _index.FLIPPED_ALIAS_KEYS["ObjectMember"];
-const PROPERTY_TYPES = exports.PROPERTY_TYPES = _index.FLIPPED_ALIAS_KEYS["Property"];
-const UNARYLIKE_TYPES = exports.UNARYLIKE_TYPES = _index.FLIPPED_ALIAS_KEYS["UnaryLike"];
-const PATTERN_TYPES = exports.PATTERN_TYPES = _index.FLIPPED_ALIAS_KEYS["Pattern"];
-const CLASS_TYPES = exports.CLASS_TYPES = _index.FLIPPED_ALIAS_KEYS["Class"];
-const IMPORTOREXPORTDECLARATION_TYPES = exports.IMPORTOREXPORTDECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS["ImportOrExportDeclaration"];
-const EXPORTDECLARATION_TYPES = exports.EXPORTDECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS["ExportDeclaration"];
-const MODULESPECIFIER_TYPES = exports.MODULESPECIFIER_TYPES = _index.FLIPPED_ALIAS_KEYS["ModuleSpecifier"];
-const ACCESSOR_TYPES = exports.ACCESSOR_TYPES = _index.FLIPPED_ALIAS_KEYS["Accessor"];
-const PRIVATE_TYPES = exports.PRIVATE_TYPES = _index.FLIPPED_ALIAS_KEYS["Private"];
-const FLOW_TYPES = exports.FLOW_TYPES = _index.FLIPPED_ALIAS_KEYS["Flow"];
-const FLOWTYPE_TYPES = exports.FLOWTYPE_TYPES = _index.FLIPPED_ALIAS_KEYS["FlowType"];
-const FLOWBASEANNOTATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = _index.FLIPPED_ALIAS_KEYS["FlowBaseAnnotation"];
-const FLOWDECLARATION_TYPES = exports.FLOWDECLARATION_TYPES = _index.FLIPPED_ALIAS_KEYS["FlowDeclaration"];
-const FLOWPREDICATE_TYPES = exports.FLOWPREDICATE_TYPES = _index.FLIPPED_ALIAS_KEYS["FlowPredicate"];
-const ENUMBODY_TYPES = exports.ENUMBODY_TYPES = _index.FLIPPED_ALIAS_KEYS["EnumBody"];
-const ENUMMEMBER_TYPES = exports.ENUMMEMBER_TYPES = _index.FLIPPED_ALIAS_KEYS["EnumMember"];
-const JSX_TYPES = exports.JSX_TYPES = _index.FLIPPED_ALIAS_KEYS["JSX"];
-const MISCELLANEOUS_TYPES = exports.MISCELLANEOUS_TYPES = _index.FLIPPED_ALIAS_KEYS["Miscellaneous"];
-const TYPESCRIPT_TYPES = exports.TYPESCRIPT_TYPES = _index.FLIPPED_ALIAS_KEYS["TypeScript"];
-const TSTYPEELEMENT_TYPES = exports.TSTYPEELEMENT_TYPES = _index.FLIPPED_ALIAS_KEYS["TSTypeElement"];
-const TSTYPE_TYPES = exports.TSTYPE_TYPES = _index.FLIPPED_ALIAS_KEYS["TSType"];
-const TSBASETYPE_TYPES = exports.TSBASETYPE_TYPES = _index.FLIPPED_ALIAS_KEYS["TSBaseType"];
-const MODULEDECLARATION_TYPES = exports.MODULEDECLARATION_TYPES = IMPORTOREXPORTDECLARATION_TYPES;
-
-//# sourceMappingURL=index.js.map

package/node_modules/@babel/types/lib/constants/generated/index.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_index","require","STANDARDIZED_TYPES","exports","FLIPPED_ALIAS_KEYS","EXPRESSION_TYPES","BINARY_TYPES","SCOPABLE_TYPES","BLOCKPARENT_TYPES","BLOCK_TYPES","STATEMENT_TYPES","TERMINATORLESS_TYPES","COMPLETIONSTATEMENT_TYPES","CONDITIONAL_TYPES","LOOP_TYPES","WHILE_TYPES","EXPRESSIONWRAPPER_TYPES","FOR_TYPES","FORXSTATEMENT_TYPES","FUNCTION_TYPES","FUNCTIONPARENT_TYPES","PUREISH_TYPES","DECLARATION_TYPES","PATTERNLIKE_TYPES","LVAL_TYPES","TSENTITYNAME_TYPES","LITERAL_TYPES","IMMUTABLE_TYPES","USERWHITESPACABLE_TYPES","METHOD_TYPES","OBJECTMEMBER_TYPES","PROPERTY_TYPES","UNARYLIKE_TYPES","PATTERN_TYPES","CLASS_TYPES","IMPORTOREXPORTDECLARATION_TYPES","EXPORTDECLARATION_TYPES","MODULESPECIFIER_TYPES","ACCESSOR_TYPES","PRIVATE_TYPES","FLOW_TYPES","FLOWTYPE_TYPES","FLOWBASEANNOTATION_TYPES","FLOWDECLARATION_TYPES","FLOWPREDICATE_TYPES","ENUMBODY_TYPES","ENUMMEMBER_TYPES","JSX_TYPES","MISCELLANEOUS_TYPES","TYPESCRIPT_TYPES","TSTYPEELEMENT_TYPES","TSTYPE_TYPES","TSBASETYPE_TYPES","MODULEDECLARATION_TYPES"],"sources":["../../../src/constants/generated/index.ts"],"sourcesContent":["/*\n * This file is auto-generated! Do not modify it directly.\n * To re-generate run 'make build'\n */\nimport { FLIPPED_ALIAS_KEYS } from \"../../definitions/index.ts\";\n\nexport const STANDARDIZED_TYPES = FLIPPED_ALIAS_KEYS[\"Standardized\"];\nexport const EXPRESSION_TYPES = FLIPPED_ALIAS_KEYS[\"Expression\"];\nexport const BINARY_TYPES = FLIPPED_ALIAS_KEYS[\"Binary\"];\nexport const SCOPABLE_TYPES = FLIPPED_ALIAS_KEYS[\"Scopable\"];\nexport const BLOCKPARENT_TYPES = FLIPPED_ALIAS_KEYS[\"BlockParent\"];\nexport const BLOCK_TYPES = FLIPPED_ALIAS_KEYS[\"Block\"];\nexport const STATEMENT_TYPES = FLIPPED_ALIAS_KEYS[\"Statement\"];\nexport const TERMINATORLESS_TYPES = FLIPPED_ALIAS_KEYS[\"Terminatorless\"];\nexport const COMPLETIONSTATEMENT_TYPES =\n  FLIPPED_ALIAS_KEYS[\"CompletionStatement\"];\nexport const CONDITIONAL_TYPES = FLIPPED_ALIAS_KEYS[\"Conditional\"];\nexport const LOOP_TYPES = FLIPPED_ALIAS_KEYS[\"Loop\"];\nexport const WHILE_TYPES = FLIPPED_ALIAS_KEYS[\"While\"];\nexport const EXPRESSIONWRAPPER_TYPES = FLIPPED_ALIAS_KEYS[\"ExpressionWrapper\"];\nexport const FOR_TYPES = FLIPPED_ALIAS_KEYS[\"For\"];\nexport const FORXSTATEMENT_TYPES = FLIPPED_ALIAS_KEYS[\"ForXStatement\"];\nexport const FUNCTION_TYPES = FLIPPED_ALIAS_KEYS[\"Function\"];\nexport const FUNCTIONPARENT_TYPES = FLIPPED_ALIAS_KEYS[\"FunctionParent\"];\nexport const PUREISH_TYPES = FLIPPED_ALIAS_KEYS[\"Pureish\"];\nexport const DECLARATION_TYPES = FLIPPED_ALIAS_KEYS[\"Declaration\"];\nexport const PATTERNLIKE_TYPES = FLIPPED_ALIAS_KEYS[\"PatternLike\"];\nexport const LVAL_TYPES = FLIPPED_ALIAS_KEYS[\"LVal\"];\nexport const TSENTITYNAME_TYPES = FLIPPED_ALIAS_KEYS[\"TSEntityName\"];\nexport const LITERAL_TYPES = FLIPPED_ALIAS_KEYS[\"Literal\"];\nexport const IMMUTABLE_TYPES = FLIPPED_ALIAS_KEYS[\"Immutable\"];\nexport const USERWHITESPACABLE_TYPES = FLIPPED_ALIAS_KEYS[\"UserWhitespacable\"];\nexport const METHOD_TYPES = FLIPPED_ALIAS_KEYS[\"Method\"];\nexport const OBJECTMEMBER_TYPES = FLIPPED_ALIAS_KEYS[\"ObjectMember\"];\nexport const PROPERTY_TYPES = FLIPPED_ALIAS_KEYS[\"Property\"];\nexport const UNARYLIKE_TYPES = FLIPPED_ALIAS_KEYS[\"UnaryLike\"];\nexport const PATTERN_TYPES = FLIPPED_ALIAS_KEYS[\"Pattern\"];\nexport const CLASS_TYPES = FLIPPED_ALIAS_KEYS[\"Class\"];\nexport const IMPORTOREXPORTDECLARATION_TYPES =\n  FLIPPED_ALIAS_KEYS[\"ImportOrExportDeclaration\"];\nexport const EXPORTDECLARATION_TYPES = FLIPPED_ALIAS_KEYS[\"ExportDeclaration\"];\nexport const MODULESPECIFIER_TYPES = FLIPPED_ALIAS_KEYS[\"ModuleSpecifier\"];\nexport const ACCESSOR_TYPES = FLIPPED_ALIAS_KEYS[\"Accessor\"];\nexport const PRIVATE_TYPES = FLIPPED_ALIAS_KEYS[\"Private\"];\nexport const FLOW_TYPES = FLIPPED_ALIAS_KEYS[\"Flow\"];\nexport const FLOWTYPE_TYPES = FLIPPED_ALIAS_KEYS[\"FlowType\"];\nexport const FLOWBASEANNOTATION_TYPES =\n  FLIPPED_ALIAS_KEYS[\"FlowBaseAnnotation\"];\nexport const FLOWDECLARATION_TYPES = FLIPPED_ALIAS_KEYS[\"FlowDeclaration\"];\nexport const FLOWPREDICATE_TYPES = FLIPPED_ALIAS_KEYS[\"FlowPredicate\"];\nexport const ENUMBODY_TYPES = FLIPPED_ALIAS_KEYS[\"EnumBody\"];\nexport const ENUMMEMBER_TYPES = FLIPPED_ALIAS_KEYS[\"EnumMember\"];\nexport const JSX_TYPES = FLIPPED_ALIAS_KEYS[\"JSX\"];\nexport const MISCELLANEOUS_TYPES = FLIPPED_ALIAS_KEYS[\"Miscellaneous\"];\nexport const TYPESCRIPT_TYPES = FLIPPED_ALIAS_KEYS[\"TypeScript\"];\nexport const TSTYPEELEMENT_TYPES = FLIPPED_ALIAS_KEYS[\"TSTypeElement\"];\nexport const TSTYPE_TYPES = FLIPPED_ALIAS_KEYS[\"TSType\"];\nexport const TSBASETYPE_TYPES = FLIPPED_ALIAS_KEYS[\"TSBaseType\"];\n/**\n * @deprecated migrate to IMPORTOREXPORTDECLARATION_TYPES.\n */\nexport const MODULEDECLARATION_TYPES = IMPORTOREXPORTDECLARATION_TYPES;\n"],"mappings":"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"}

package/node_modules/@babel/types/lib/constants/index.js

@@ -1,31 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.UPDATE_OPERATORS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.STATEMENT_OR_BLOCK_KEYS = exports.NUMBER_UNARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.NOT_LOCAL_BINDING = exports.LOGICAL_OPERATORS = exports.INHERIT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.EQUALITY_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.COMMENT_KEYS = exports.BOOLEAN_UNARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.BLOCK_SCOPED_SYMBOL = exports.BINARY_OPERATORS = exports.ASSIGNMENT_OPERATORS = void 0;
-const STATEMENT_OR_BLOCK_KEYS = exports.STATEMENT_OR_BLOCK_KEYS = ["consequent", "body", "alternate"];
-const FLATTENABLE_KEYS = exports.FLATTENABLE_KEYS = ["body", "expressions"];
-const FOR_INIT_KEYS = exports.FOR_INIT_KEYS = ["left", "init"];
-const COMMENT_KEYS = exports.COMMENT_KEYS = ["leadingComments", "trailingComments", "innerComments"];
-const LOGICAL_OPERATORS = exports.LOGICAL_OPERATORS = ["||", "&&", "??"];
-const UPDATE_OPERATORS = exports.UPDATE_OPERATORS = ["++", "--"];
-const BOOLEAN_NUMBER_BINARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = [">", "<", ">=", "<="];
-const EQUALITY_BINARY_OPERATORS = exports.EQUALITY_BINARY_OPERATORS = ["==", "===", "!=", "!=="];
-const COMPARISON_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = [...EQUALITY_BINARY_OPERATORS, "in", "instanceof"];
-const BOOLEAN_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = [...COMPARISON_BINARY_OPERATORS, ...BOOLEAN_NUMBER_BINARY_OPERATORS];
-const NUMBER_BINARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
-const BINARY_OPERATORS = exports.BINARY_OPERATORS = ["+", ...NUMBER_BINARY_OPERATORS, ...BOOLEAN_BINARY_OPERATORS, "|>"];
-const ASSIGNMENT_OPERATORS = exports.ASSIGNMENT_OPERATORS = ["=", "+=", ...NUMBER_BINARY_OPERATORS.map(op => op + "="), ...LOGICAL_OPERATORS.map(op => op + "=")];
-const BOOLEAN_UNARY_OPERATORS = exports.BOOLEAN_UNARY_OPERATORS = ["delete", "!"];
-const NUMBER_UNARY_OPERATORS = exports.NUMBER_UNARY_OPERATORS = ["+", "-", "~"];
-const STRING_UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = ["typeof"];
-const UNARY_OPERATORS = exports.UNARY_OPERATORS = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS, ...NUMBER_UNARY_OPERATORS, ...STRING_UNARY_OPERATORS];
-const INHERIT_KEYS = exports.INHERIT_KEYS = {
-  optional: ["typeAnnotation", "typeParameters", "returnType"],
-  force: ["start", "loc", "end"]
-};
-const BLOCK_SCOPED_SYMBOL = exports.BLOCK_SCOPED_SYMBOL = Symbol.for("var used to be block scoped");
-const NOT_LOCAL_BINDING = exports.NOT_LOCAL_BINDING = Symbol.for("should not be considered a local binding");
-
-//# sourceMappingURL=index.js.map

package/node_modules/@babel/types/lib/constants/index.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["STATEMENT_OR_BLOCK_KEYS","exports","FLATTENABLE_KEYS","FOR_INIT_KEYS","COMMENT_KEYS","LOGICAL_OPERATORS","UPDATE_OPERATORS","BOOLEAN_NUMBER_BINARY_OPERATORS","EQUALITY_BINARY_OPERATORS","COMPARISON_BINARY_OPERATORS","BOOLEAN_BINARY_OPERATORS","NUMBER_BINARY_OPERATORS","BINARY_OPERATORS","ASSIGNMENT_OPERATORS","map","op","BOOLEAN_UNARY_OPERATORS","NUMBER_UNARY_OPERATORS","STRING_UNARY_OPERATORS","UNARY_OPERATORS","INHERIT_KEYS","optional","force","BLOCK_SCOPED_SYMBOL","Symbol","for","NOT_LOCAL_BINDING"],"sources":["../../src/constants/index.ts"],"sourcesContent":["export const STATEMENT_OR_BLOCK_KEYS = [\"consequent\", \"body\", \"alternate\"];\nexport const FLATTENABLE_KEYS = [\"body\", \"expressions\"];\nexport const FOR_INIT_KEYS = [\"left\", \"init\"];\nexport const COMMENT_KEYS = [\n  \"leadingComments\",\n  \"trailingComments\",\n  \"innerComments\",\n] as const;\n\nexport const LOGICAL_OPERATORS = [\"||\", \"&&\", \"??\"];\nexport const UPDATE_OPERATORS = [\"++\", \"--\"];\n\nexport const BOOLEAN_NUMBER_BINARY_OPERATORS = [\">\", \"<\", \">=\", \"<=\"];\nexport const EQUALITY_BINARY_OPERATORS = [\"==\", \"===\", \"!=\", \"!==\"];\nexport const COMPARISON_BINARY_OPERATORS = [\n  ...EQUALITY_BINARY_OPERATORS,\n  \"in\",\n  \"instanceof\",\n];\nexport const BOOLEAN_BINARY_OPERATORS = [\n  ...COMPARISON_BINARY_OPERATORS,\n  ...BOOLEAN_NUMBER_BINARY_OPERATORS,\n];\nexport const NUMBER_BINARY_OPERATORS = [\n  \"-\",\n  \"/\",\n  \"%\",\n  \"*\",\n  \"**\",\n  \"&\",\n  \"|\",\n  \">>\",\n  \">>>\",\n  \"<<\",\n  \"^\",\n];\nexport const BINARY_OPERATORS = [\n  \"+\",\n  ...NUMBER_BINARY_OPERATORS,\n  ...BOOLEAN_BINARY_OPERATORS,\n  \"|>\",\n];\n\nexport const ASSIGNMENT_OPERATORS = [\n  \"=\",\n  \"+=\",\n  ...NUMBER_BINARY_OPERATORS.map(op => op + \"=\"),\n  ...LOGICAL_OPERATORS.map(op => op + \"=\"),\n];\n\nexport const BOOLEAN_UNARY_OPERATORS = [\"delete\", \"!\"];\nexport const NUMBER_UNARY_OPERATORS = [\"+\", \"-\", \"~\"];\nexport const STRING_UNARY_OPERATORS = [\"typeof\"];\nexport const UNARY_OPERATORS = [\n  \"void\",\n  \"throw\",\n  ...BOOLEAN_UNARY_OPERATORS,\n  ...NUMBER_UNARY_OPERATORS,\n  ...STRING_UNARY_OPERATORS,\n];\n\nexport const INHERIT_KEYS = {\n  optional: [\"typeAnnotation\", \"typeParameters\", \"returnType\"],\n  force: [\"start\", \"loc\", \"end\"],\n} as const;\n\nexport const BLOCK_SCOPED_SYMBOL = Symbol.for(\"var used to be block scoped\");\nexport const NOT_LOCAL_BINDING = Symbol.for(\n  \"should not be considered a local binding\",\n);\n"],"mappings":";;;;;;AAAO,MAAMA,uBAAuB,GAAAC,OAAA,CAAAD,uBAAA,GAAG,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,CAAC;AACnE,MAAME,gBAAgB,GAAAD,OAAA,CAAAC,gBAAA,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC;AAChD,MAAMC,aAAa,GAAAF,OAAA,CAAAE,aAAA,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;AACtC,MAAMC,YAAY,GAAAH,OAAA,CAAAG,YAAA,GAAG,CAC1B,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,CACP;AAEH,MAAMC,iBAAiB,GAAAJ,OAAA,CAAAI,iBAAA,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;AAC5C,MAAMC,gBAAgB,GAAAL,OAAA,CAAAK,gBAAA,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC;AAErC,MAAMC,+BAA+B,GAAAN,OAAA,CAAAM,+BAAA,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC;AAC9D,MAAMC,yBAAyB,GAAAP,OAAA,CAAAO,yBAAA,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC;AAC5D,MAAMC,2BAA2B,GAAAR,OAAA,CAAAQ,2BAAA,GAAG,CACzC,GAAGD,yBAAyB,EAC5B,IAAI,EACJ,YAAY,CACb;AACM,MAAME,wBAAwB,GAAAT,OAAA,CAAAS,wBAAA,GAAG,CACtC,GAAGD,2BAA2B,EAC9B,GAAGF,+BAA+B,CACnC;AACM,MAAMI,uBAAuB,GAAAV,OAAA,CAAAU,uBAAA,GAAG,CACrC,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,IAAI,EACJ,GAAG,EACH,GAAG,EACH,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,GAAG,CACJ;AACM,MAAMC,gBAAgB,GAAAX,OAAA,CAAAW,gBAAA,GAAG,CAC9B,GAAG,EACH,GAAGD,uBAAuB,EAC1B,GAAGD,wBAAwB,EAC3B,IAAI,CACL;AAEM,MAAMG,oBAAoB,GAAAZ,OAAA,CAAAY,oBAAA,GAAG,CAClC,GAAG,EACH,IAAI,EACJ,GAAGF,uBAAuB,CAACG,GAAG,CAACC,EAAE,IAAIA,EAAE,GAAG,GAAG,CAAC,EAC9C,GAAGV,iBAAiB,CAACS,GAAG,CAACC,EAAE,IAAIA,EAAE,GAAG,GAAG,CAAC,CACzC;AAEM,MAAMC,uBAAuB,GAAAf,OAAA,CAAAe,uBAAA,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC;AAC/C,MAAMC,sBAAsB,GAAAhB,OAAA,CAAAgB,sBAAA,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;AAC9C,MAAMC,sBAAsB,GAAAjB,OAAA,CAAAiB,sBAAA,GAAG,CAAC,QAAQ,CAAC;AACzC,MAAMC,eAAe,GAAAlB,OAAA,CAAAkB,eAAA,GAAG,CAC7B,MAAM,EACN,OAAO,EACP,GAAGH,uBAAuB,EAC1B,GAAGC,sBAAsB,EACzB,GAAGC,sBAAsB,CAC1B;AAEM,MAAME,YAAY,GAAAnB,OAAA,CAAAmB,YAAA,GAAG;EAC1BC,QAAQ,EAAE,CAAC,gBAAgB,EAAE,gBAAgB,EAAE,YAAY,CAAC;EAC5DC,KAAK,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK;AAC/B,CAAU;AAEH,MAAMC,mBAAmB,GAAAtB,OAAA,CAAAsB,mBAAA,GAAGC,MAAM,CAACC,GAAG,CAAC,6BAA6B,CAAC;AACrE,MAAMC,iBAAiB,GAAAzB,OAAA,CAAAyB,iBAAA,GAAGF,MAAM,CAACC,GAAG,CACzC,0CACF,CAAC"}