domql 1.5.71 → 1.5.72

package/packages/emotion/node_modules/@babel/types/lib/index.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["react","isReactComponent","isCompatTag","buildChildren"],"sources":["../src/index.ts"],"sourcesContent":["import isReactComponent from \"./validators/react/isReactComponent\";\nimport isCompatTag from \"./validators/react/isCompatTag\";\nimport buildChildren from \"./builders/react/buildChildren\";\n\n// asserts\nexport { default as assertNode } from \"./asserts/assertNode\";\nexport * from \"./asserts/generated\";\n\n// builders\nexport { default as createTypeAnnotationBasedOnTypeof } from \"./builders/flow/createTypeAnnotationBasedOnTypeof\";\n/** @deprecated use createFlowUnionType instead */\nexport { default as createUnionTypeAnnotation } from \"./builders/flow/createFlowUnionType\";\nexport { default as createFlowUnionType } from \"./builders/flow/createFlowUnionType\";\nexport { default as createTSUnionType } from \"./builders/typescript/createTSUnionType\";\nexport * from \"./builders/generated\";\nexport * from \"./builders/generated/uppercase\";\n\n// clone\nexport { default as cloneNode } from \"./clone/cloneNode\";\nexport { default as clone } from \"./clone/clone\";\nexport { default as cloneDeep } from \"./clone/cloneDeep\";\nexport { default as cloneDeepWithoutLoc } from \"./clone/cloneDeepWithoutLoc\";\nexport { default as cloneWithoutLoc } from \"./clone/cloneWithoutLoc\";\n\n// comments\nexport { default as addComment } from \"./comments/addComment\";\nexport { default as addComments } from \"./comments/addComments\";\nexport { default as inheritInnerComments } from \"./comments/inheritInnerComments\";\nexport { default as inheritLeadingComments } from \"./comments/inheritLeadingComments\";\nexport { default as inheritsComments } from \"./comments/inheritsComments\";\nexport { default as inheritTrailingComments } from \"./comments/inheritTrailingComments\";\nexport { default as removeComments } from \"./comments/removeComments\";\n\n// constants\nexport * from \"./constants/generated\";\nexport * from \"./constants\";\n\n// converters\nexport { default as ensureBlock } from \"./converters/ensureBlock\";\nexport { default as toBindingIdentifierName } from \"./converters/toBindingIdentifierName\";\nexport { default as toBlock } from \"./converters/toBlock\";\nexport { default as toComputedKey } from \"./converters/toComputedKey\";\nexport { default as toExpression } from \"./converters/toExpression\";\nexport { default as toIdentifier } from \"./converters/toIdentifier\";\nexport { default as toKeyAlias } from \"./converters/toKeyAlias\";\nexport { default as toSequenceExpression } from \"./converters/toSequenceExpression\";\nexport { default as toStatement } from \"./converters/toStatement\";\nexport { default as valueToNode } from \"./converters/valueToNode\";\n\n// definitions\nexport * from \"./definitions\";\n\n// modifications\nexport { default as appendToMemberExpression } from \"./modifications/appendToMemberExpression\";\nexport { default as inherits } from \"./modifications/inherits\";\nexport { default as prependToMemberExpression } from \"./modifications/prependToMemberExpression\";\nexport {\n  default as removeProperties,\n  type Options as RemovePropertiesOptions,\n} from \"./modifications/removeProperties\";\nexport { default as removePropertiesDeep } from \"./modifications/removePropertiesDeep\";\nexport { default as removeTypeDuplicates } from \"./modifications/flow/removeTypeDuplicates\";\n\n// retrievers\nexport { default as getBindingIdentifiers } from \"./retrievers/getBindingIdentifiers\";\nexport { default as getOuterBindingIdentifiers } from \"./retrievers/getOuterBindingIdentifiers\";\n\n// traverse\nexport { default as traverse } from \"./traverse/traverse\";\nexport * from \"./traverse/traverse\";\nexport { default as traverseFast } from \"./traverse/traverseFast\";\n\n// utils\nexport { default as shallowEqual } from \"./utils/shallowEqual\";\n\n// validators\nexport { default as is } from \"./validators/is\";\nexport { default as isBinding } from \"./validators/isBinding\";\nexport { default as isBlockScoped } from \"./validators/isBlockScoped\";\nexport { default as isImmutable } from \"./validators/isImmutable\";\nexport { default as isLet } from \"./validators/isLet\";\nexport { default as isNode } from \"./validators/isNode\";\nexport { default as isNodesEquivalent } from \"./validators/isNodesEquivalent\";\nexport { default as isPlaceholderType } from \"./validators/isPlaceholderType\";\nexport { default as isReferenced } from \"./validators/isReferenced\";\nexport { default as isScope } from \"./validators/isScope\";\nexport { default as isSpecifierDefault } from \"./validators/isSpecifierDefault\";\nexport { default as isType } from \"./validators/isType\";\nexport { default as isValidES3Identifier } from \"./validators/isValidES3Identifier\";\nexport { default as isValidIdentifier } from \"./validators/isValidIdentifier\";\nexport { default as isVar } from \"./validators/isVar\";\nexport { default as matchesPattern } from \"./validators/matchesPattern\";\nexport { default as validate } from \"./validators/validate\";\nexport { default as buildMatchMemberExpression } from \"./validators/buildMatchMemberExpression\";\nexport * from \"./validators/generated\";\n\n// react\nexport const react = {\n  isReactComponent,\n  isCompatTag,\n  buildChildren,\n};\n\nexport * from \"./ast-types/generated\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AAGA;;AACA;;AAAA;EAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;;AAGA;;AAEA;;AAEA;;AACA;;AAAA;EAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;;AACA;;AAAA;EAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;;AAGA;;AACA;;AACA;;AACA;;AACA;;AAGA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAGA;;AAAA;EAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;;AACA;;AAAA;EAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;;AAGA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAGA;;AAAA;EAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;;AAGA;;AACA;;AACA;;AACA;;AAIA;;AACA;;AAGA;;AACA;;AAGA;;AACA;EAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;;AACA;;AAGA;;AAGA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAAA;EAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;;AASA;;AAAA;EAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;AANO,MAAMA,KAAK,GAAG;EACnBC,gBAAgB,EAAhBA,yBADmB;EAEnBC,WAAW,EAAXA,oBAFmB;EAGnBC,aAAa,EAAbA;AAHmB,CAAd"}

package/packages/emotion/node_modules/@babel/types/lib/modifications/appendToMemberExpression.js

@@ -1,17 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = appendToMemberExpression;
-
-var _generated = require("../builders/generated");
-
-function appendToMemberExpression(member, append, computed = false) {
-  member.object = (0, _generated.memberExpression)(member.object, member.property, member.computed);
-  member.property = append;
-  member.computed = !!computed;
-  return member;
-}
-
-//# sourceMappingURL=appendToMemberExpression.js.map

package/packages/emotion/node_modules/@babel/types/lib/modifications/appendToMemberExpression.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["appendToMemberExpression","member","append","computed","object","memberExpression","property"],"sources":["../../src/modifications/appendToMemberExpression.ts"],"sourcesContent":["import { memberExpression } from \"../builders/generated\";\nimport type * as t from \"..\";\n\n/**\n * Append a node to a member expression.\n */\nexport default function appendToMemberExpression(\n  member: t.MemberExpression,\n  append: t.MemberExpression[\"property\"],\n  computed: boolean = false,\n): t.MemberExpression {\n  member.object = memberExpression(\n    member.object,\n    member.property,\n    member.computed,\n  );\n  member.property = append;\n  member.computed = !!computed;\n\n  return member;\n}\n"],"mappings":";;;;;;;AAAA;;AAMe,SAASA,wBAAT,CACbC,MADa,EAEbC,MAFa,EAGbC,QAAiB,GAAG,KAHP,EAIO;EACpBF,MAAM,CAACG,MAAP,GAAgB,IAAAC,2BAAA,EACdJ,MAAM,CAACG,MADO,EAEdH,MAAM,CAACK,QAFO,EAGdL,MAAM,CAACE,QAHO,CAAhB;EAKAF,MAAM,CAACK,QAAP,GAAkBJ,MAAlB;EACAD,MAAM,CAACE,QAAP,GAAkB,CAAC,CAACA,QAApB;EAEA,OAAOF,MAAP;AACD"}

package/packages/emotion/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js

@@ -1,80 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = removeTypeDuplicates;
-
-var _generated = require("../../validators/generated");
-
-function getQualifiedName(node) {
-  return (0, _generated.isIdentifier)(node) ? node.name : `${node.id.name}.${getQualifiedName(node.qualification)}`;
-}
-
-function removeTypeDuplicates(nodes) {
-  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, _generated.isAnyTypeAnnotation)(node)) {
-      return [node];
-    }
-
-    if ((0, _generated.isFlowBaseAnnotation)(node)) {
-      bases.set(node.type, node);
-      continue;
-    }
-
-    if ((0, _generated.isUnionTypeAnnotation)(node)) {
-      if (!typeGroups.has(node.types)) {
-        nodes = nodes.concat(node.types);
-        typeGroups.add(node.types);
-      }
-
-      continue;
-    }
-
-    if ((0, _generated.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 = removeTypeDuplicates(existing.typeParameters.params.concat(node.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;
-}
-
-//# sourceMappingURL=removeTypeDuplicates.js.map

package/packages/emotion/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["getQualifiedName","node","isIdentifier","name","id","qualification","removeTypeDuplicates","nodes","generics","Map","bases","typeGroups","Set","types","i","length","indexOf","isAnyTypeAnnotation","isFlowBaseAnnotation","set","type","isUnionTypeAnnotation","has","concat","add","isGenericTypeAnnotation","existing","get","typeParameters","params","push","baseType","genericName"],"sources":["../../../src/modifications/flow/removeTypeDuplicates.ts"],"sourcesContent":["import {\n  isAnyTypeAnnotation,\n  isGenericTypeAnnotation,\n  isUnionTypeAnnotation,\n  isFlowBaseAnnotation,\n  isIdentifier,\n} from \"../../validators/generated\";\nimport type * as t from \"../..\";\n\nfunction getQualifiedName(node: t.GenericTypeAnnotation[\"id\"]): string {\n  return isIdentifier(node)\n    ? node.name\n    : `${node.id.name}.${getQualifiedName(node.qualification)}`;\n}\n\n/**\n * Dedupe type annotations.\n */\nexport default function removeTypeDuplicates(\n  // todo(babel-8): change type to Array<...>\n  nodes: ReadonlyArray<t.FlowType | false | null | undefined>,\n): t.FlowType[] {\n  const generics = new Map<string, t.GenericTypeAnnotation>();\n  const bases = new Map<t.FlowBaseAnnotation[\"type\"], t.FlowBaseAnnotation>();\n\n  // store union type groups to circular references\n  const typeGroups = new Set<t.FlowType[]>();\n\n  const types: t.FlowType[] = [];\n\n  for (let i = 0; i < nodes.length; i++) {\n    const node = nodes[i];\n    if (!node) continue;\n\n    // detect duplicates\n    if (types.indexOf(node) >= 0) {\n      continue;\n    }\n\n    // this type matches anything\n    if (isAnyTypeAnnotation(node)) {\n      return [node];\n    }\n\n    if (isFlowBaseAnnotation(node)) {\n      bases.set(node.type, node);\n      continue;\n    }\n\n    if (isUnionTypeAnnotation(node)) {\n      if (!typeGroups.has(node.types)) {\n        // todo(babel-8): use .push when nodes is mutable\n        nodes = nodes.concat(node.types);\n        typeGroups.add(node.types);\n      }\n      continue;\n    }\n\n    // find a matching generic type and merge and deduplicate the type parameters\n    if (isGenericTypeAnnotation(node)) {\n      const name = getQualifiedName(node.id);\n\n      if (generics.has(name)) {\n        let existing: t.Flow = generics.get(name);\n        if (existing.typeParameters) {\n          if (node.typeParameters) {\n            existing.typeParameters.params = removeTypeDuplicates(\n              existing.typeParameters.params.concat(node.typeParameters.params),\n            );\n          }\n        } else {\n          existing = node.typeParameters;\n        }\n      } else {\n        generics.set(name, node);\n      }\n\n      continue;\n    }\n\n    types.push(node);\n  }\n\n  // add back in bases\n  for (const [, baseType] of bases) {\n    types.push(baseType);\n  }\n\n  // add back in generics\n  for (const [, genericName] of generics) {\n    types.push(genericName);\n  }\n\n  return types;\n}\n"],"mappings":";;;;;;;AAAA;;AASA,SAASA,gBAAT,CAA0BC,IAA1B,EAAuE;EACrE,OAAO,IAAAC,uBAAA,EAAaD,IAAb,IACHA,IAAI,CAACE,IADF,GAEF,GAAEF,IAAI,CAACG,EAAL,CAAQD,IAAK,IAAGH,gBAAgB,CAACC,IAAI,CAACI,aAAN,CAAqB,EAF5D;AAGD;;AAKc,SAASC,oBAAT,CAEbC,KAFa,EAGC;EACd,MAAMC,QAAQ,GAAG,IAAIC,GAAJ,EAAjB;EACA,MAAMC,KAAK,GAAG,IAAID,GAAJ,EAAd;EAGA,MAAME,UAAU,GAAG,IAAIC,GAAJ,EAAnB;EAEA,MAAMC,KAAmB,GAAG,EAA5B;;EAEA,KAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGP,KAAK,CAACQ,MAA1B,EAAkCD,CAAC,EAAnC,EAAuC;IACrC,MAAMb,IAAI,GAAGM,KAAK,CAACO,CAAD,CAAlB;IACA,IAAI,CAACb,IAAL,EAAW;;IAGX,IAAIY,KAAK,CAACG,OAAN,CAAcf,IAAd,KAAuB,CAA3B,EAA8B;MAC5B;IACD;;IAGD,IAAI,IAAAgB,8BAAA,EAAoBhB,IAApB,CAAJ,EAA+B;MAC7B,OAAO,CAACA,IAAD,CAAP;IACD;;IAED,IAAI,IAAAiB,+BAAA,EAAqBjB,IAArB,CAAJ,EAAgC;MAC9BS,KAAK,CAACS,GAAN,CAAUlB,IAAI,CAACmB,IAAf,EAAqBnB,IAArB;MACA;IACD;;IAED,IAAI,IAAAoB,gCAAA,EAAsBpB,IAAtB,CAAJ,EAAiC;MAC/B,IAAI,CAACU,UAAU,CAACW,GAAX,CAAerB,IAAI,CAACY,KAApB,CAAL,EAAiC;QAE/BN,KAAK,GAAGA,KAAK,CAACgB,MAAN,CAAatB,IAAI,CAACY,KAAlB,CAAR;QACAF,UAAU,CAACa,GAAX,CAAevB,IAAI,CAACY,KAApB;MACD;;MACD;IACD;;IAGD,IAAI,IAAAY,kCAAA,EAAwBxB,IAAxB,CAAJ,EAAmC;MACjC,MAAME,IAAI,GAAGH,gBAAgB,CAACC,IAAI,CAACG,EAAN,CAA7B;;MAEA,IAAII,QAAQ,CAACc,GAAT,CAAanB,IAAb,CAAJ,EAAwB;QACtB,IAAIuB,QAAgB,GAAGlB,QAAQ,CAACmB,GAAT,CAAaxB,IAAb,CAAvB;;QACA,IAAIuB,QAAQ,CAACE,cAAb,EAA6B;UAC3B,IAAI3B,IAAI,CAAC2B,cAAT,EAAyB;YACvBF,QAAQ,CAACE,cAAT,CAAwBC,MAAxB,GAAiCvB,oBAAoB,CACnDoB,QAAQ,CAACE,cAAT,CAAwBC,MAAxB,CAA+BN,MAA/B,CAAsCtB,IAAI,CAAC2B,cAAL,CAAoBC,MAA1D,CADmD,CAArD;UAGD;QACF,CAND,MAMO;UACLH,QAAQ,GAAGzB,IAAI,CAAC2B,cAAhB;QACD;MACF,CAXD,MAWO;QACLpB,QAAQ,CAACW,GAAT,CAAahB,IAAb,EAAmBF,IAAnB;MACD;;MAED;IACD;;IAEDY,KAAK,CAACiB,IAAN,CAAW7B,IAAX;EACD;;EAGD,KAAK,MAAM,GAAG8B,QAAH,CAAX,IAA2BrB,KAA3B,EAAkC;IAChCG,KAAK,CAACiB,IAAN,CAAWC,QAAX;EACD;;EAGD,KAAK,MAAM,GAAGC,WAAH,CAAX,IAA8BxB,QAA9B,EAAwC;IACtCK,KAAK,CAACiB,IAAN,CAAWE,WAAX;EACD;;EAED,OAAOnB,KAAP;AACD"}

package/packages/emotion/node_modules/@babel/types/lib/modifications/inherits.js

@@ -1,35 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = inherits;
-
-var _constants = require("../constants");
-
-var _inheritsComments = require("../comments/inheritsComments");
-
-function inherits(child, parent) {
-  if (!child || !parent) return child;
-
-  for (const key of _constants.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 _constants.INHERIT_KEYS.force) {
-    child[key] = parent[key];
-  }
-
-  (0, _inheritsComments.default)(child, parent);
-  return child;
-}
-
-//# sourceMappingURL=inherits.js.map

package/packages/emotion/node_modules/@babel/types/lib/modifications/inherits.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["inherits","child","parent","key","INHERIT_KEYS","optional","Object","keys","force","inheritsComments"],"sources":["../../src/modifications/inherits.ts"],"sourcesContent":["import { INHERIT_KEYS } from \"../constants\";\nimport inheritsComments from \"../comments/inheritsComments\";\nimport type * as t from \"..\";\n\n/**\n * Inherit all contextual properties from `parent` node to `child` node.\n */\nexport default function inherits<T extends t.Node | null | undefined>(\n  child: T,\n  parent: t.Node | null | undefined,\n): T {\n  if (!child || !parent) return child;\n\n  // optionally inherit specific properties if not null\n  for (const key of INHERIT_KEYS.optional) {\n    // @ts-expect-error Fixme: refine parent types\n    if (child[key] == null) {\n      // @ts-expect-error Fixme: refine parent types\n      child[key] = parent[key];\n    }\n  }\n\n  // force inherit \"private\" properties\n  for (const key of Object.keys(parent)) {\n    if (key[0] === \"_\" && key !== \"__clone\") {\n      // @ts-expect-error Fixme: refine parent types\n      child[key] = parent[key];\n    }\n  }\n\n  // force inherit select properties\n  for (const key of INHERIT_KEYS.force) {\n    // @ts-expect-error Fixme: refine parent types\n    child[key] = parent[key];\n  }\n\n  inheritsComments(child, parent);\n\n  return child;\n}\n"],"mappings":";;;;;;;AAAA;;AACA;;AAMe,SAASA,QAAT,CACbC,KADa,EAEbC,MAFa,EAGV;EACH,IAAI,CAACD,KAAD,IAAU,CAACC,MAAf,EAAuB,OAAOD,KAAP;;EAGvB,KAAK,MAAME,GAAX,IAAkBC,uBAAA,CAAaC,QAA/B,EAAyC;IAEvC,IAAIJ,KAAK,CAACE,GAAD,CAAL,IAAc,IAAlB,EAAwB;MAEtBF,KAAK,CAACE,GAAD,CAAL,GAAaD,MAAM,CAACC,GAAD,CAAnB;IACD;EACF;;EAGD,KAAK,MAAMA,GAAX,IAAkBG,MAAM,CAACC,IAAP,CAAYL,MAAZ,CAAlB,EAAuC;IACrC,IAAIC,GAAG,CAAC,CAAD,CAAH,KAAW,GAAX,IAAkBA,GAAG,KAAK,SAA9B,EAAyC;MAEvCF,KAAK,CAACE,GAAD,CAAL,GAAaD,MAAM,CAACC,GAAD,CAAnB;IACD;EACF;;EAGD,KAAK,MAAMA,GAAX,IAAkBC,uBAAA,CAAaI,KAA/B,EAAsC;IAEpCP,KAAK,CAACE,GAAD,CAAL,GAAaD,MAAM,CAACC,GAAD,CAAnB;EACD;;EAED,IAAAM,yBAAA,EAAiBR,KAAjB,EAAwBC,MAAxB;EAEA,OAAOD,KAAP;AACD"}

package/packages/emotion/node_modules/@babel/types/lib/modifications/prependToMemberExpression.js

@@ -1,21 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = prependToMemberExpression;
-
-var _generated = require("../builders/generated");
-
-var _ = require("..");
-
-function prependToMemberExpression(member, prepend) {
-  if ((0, _.isSuper)(member.object)) {
-    throw new Error("Cannot prepend node to super property access (`super.foo`).");
-  }
-
-  member.object = (0, _generated.memberExpression)(prepend, member.object);
-  return member;
-}
-
-//# sourceMappingURL=prependToMemberExpression.js.map

package/packages/emotion/node_modules/@babel/types/lib/modifications/prependToMemberExpression.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["prependToMemberExpression","member","prepend","isSuper","object","Error","memberExpression"],"sources":["../../src/modifications/prependToMemberExpression.ts"],"sourcesContent":["import { memberExpression } from \"../builders/generated\";\nimport { isSuper } from \"..\";\nimport type * as t from \"..\";\n\n/**\n * Prepend a node to a member expression.\n */\nexport default function prependToMemberExpression<\n  T extends Pick<t.MemberExpression, \"object\" | \"property\">,\n>(member: T, prepend: t.MemberExpression[\"object\"]): T {\n  if (isSuper(member.object)) {\n    throw new Error(\n      \"Cannot prepend node to super property access (`super.foo`).\",\n    );\n  }\n  member.object = memberExpression(prepend, member.object);\n\n  return member;\n}\n"],"mappings":";;;;;;;AAAA;;AACA;;AAMe,SAASA,yBAAT,CAEbC,MAFa,EAEFC,OAFE,EAEwC;EACrD,IAAI,IAAAC,SAAA,EAAQF,MAAM,CAACG,MAAf,CAAJ,EAA4B;IAC1B,MAAM,IAAIC,KAAJ,CACJ,6DADI,CAAN;EAGD;;EACDJ,MAAM,CAACG,MAAP,GAAgB,IAAAE,2BAAA,EAAiBJ,OAAjB,EAA0BD,MAAM,CAACG,MAAjC,CAAhB;EAEA,OAAOH,MAAP;AACD"}

package/packages/emotion/node_modules/@babel/types/lib/modifications/removeProperties.js

@@ -1,31 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = removeProperties;
-
-var _constants = require("../constants");
-
-const CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
-const CLEAR_KEYS_PLUS_COMMENTS = [..._constants.COMMENT_KEYS, "comments", ...CLEAR_KEYS];
-
-function removeProperties(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;
-  }
-}
-
-//# sourceMappingURL=removeProperties.js.map

package/packages/emotion/node_modules/@babel/types/lib/modifications/removeProperties.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["CLEAR_KEYS","CLEAR_KEYS_PLUS_COMMENTS","COMMENT_KEYS","removeProperties","node","opts","map","preserveComments","key","undefined","Object","keys","symbols","getOwnPropertySymbols","sym"],"sources":["../../src/modifications/removeProperties.ts"],"sourcesContent":["import { COMMENT_KEYS } from \"../constants\";\nimport type * as t from \"..\";\n\nconst CLEAR_KEYS = [\n  \"tokens\", // only exist in t.File\n  \"start\",\n  \"end\",\n  \"loc\",\n  // Fixme: should be extra.raw / extra.rawValue?\n  \"raw\",\n  \"rawValue\",\n] as const;\n\nconst CLEAR_KEYS_PLUS_COMMENTS = [\n  ...COMMENT_KEYS,\n  \"comments\",\n  ...CLEAR_KEYS,\n] as const;\n\nexport type Options = { preserveComments?: boolean };\n/**\n * Remove all of the _* properties from a node along with the additional metadata\n * properties like location data and raw token data.\n */\nexport default function removeProperties(\n  node: t.Node,\n  opts: Options = {},\n): void {\n  const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;\n  for (const key of map) {\n    // @ts-expect-error tokens only exist in t.File\n    if (node[key] != null) node[key] = undefined;\n  }\n\n  for (const key of Object.keys(node)) {\n    // @ts-expect-error string can not index node\n    if (key[0] === \"_\" && node[key] != null) node[key] = undefined;\n  }\n\n  const symbols: Array<symbol> = Object.getOwnPropertySymbols(node);\n  for (const sym of symbols) {\n    // @ts-expect-error Fixme: document symbol properties\n    node[sym] = null;\n  }\n}\n"],"mappings":";;;;;;;AAAA;;AAGA,MAAMA,UAAU,GAAG,CACjB,QADiB,EAEjB,OAFiB,EAGjB,KAHiB,EAIjB,KAJiB,EAMjB,KANiB,EAOjB,UAPiB,CAAnB;AAUA,MAAMC,wBAAwB,GAAG,CAC/B,GAAGC,uBAD4B,EAE/B,UAF+B,EAG/B,GAAGF,UAH4B,CAAjC;;AAWe,SAASG,gBAAT,CACbC,IADa,EAEbC,IAAa,GAAG,EAFH,EAGP;EACN,MAAMC,GAAG,GAAGD,IAAI,CAACE,gBAAL,GAAwBP,UAAxB,GAAqCC,wBAAjD;;EACA,KAAK,MAAMO,GAAX,IAAkBF,GAAlB,EAAuB;IAErB,IAAIF,IAAI,CAACI,GAAD,CAAJ,IAAa,IAAjB,EAAuBJ,IAAI,CAACI,GAAD,CAAJ,GAAYC,SAAZ;EACxB;;EAED,KAAK,MAAMD,GAAX,IAAkBE,MAAM,CAACC,IAAP,CAAYP,IAAZ,CAAlB,EAAqC;IAEnC,IAAII,GAAG,CAAC,CAAD,CAAH,KAAW,GAAX,IAAkBJ,IAAI,CAACI,GAAD,CAAJ,IAAa,IAAnC,EAAyCJ,IAAI,CAACI,GAAD,CAAJ,GAAYC,SAAZ;EAC1C;;EAED,MAAMG,OAAsB,GAAGF,MAAM,CAACG,qBAAP,CAA6BT,IAA7B,CAA/B;;EACA,KAAK,MAAMU,GAAX,IAAkBF,OAAlB,EAA2B;IAEzBR,IAAI,CAACU,GAAD,CAAJ,GAAY,IAAZ;EACD;AACF"}

package/packages/emotion/node_modules/@babel/types/lib/modifications/removePropertiesDeep.js

@@ -1,17 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = removePropertiesDeep;
-
-var _traverseFast = require("../traverse/traverseFast");
-
-var _removeProperties = require("./removeProperties");
-
-function removePropertiesDeep(tree, opts) {
-  (0, _traverseFast.default)(tree, _removeProperties.default, opts);
-  return tree;
-}
-
-//# sourceMappingURL=removePropertiesDeep.js.map

package/packages/emotion/node_modules/@babel/types/lib/modifications/removePropertiesDeep.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["removePropertiesDeep","tree","opts","traverseFast","removeProperties"],"sources":["../../src/modifications/removePropertiesDeep.ts"],"sourcesContent":["import traverseFast from \"../traverse/traverseFast\";\nimport removeProperties from \"./removeProperties\";\nimport type * as t from \"..\";\n\nexport default function removePropertiesDeep<T extends t.Node>(\n  tree: T,\n  opts?: { preserveComments: boolean } | null,\n): T {\n  traverseFast(tree, removeProperties, opts);\n\n  return tree;\n}\n"],"mappings":";;;;;;;AAAA;;AACA;;AAGe,SAASA,oBAAT,CACbC,IADa,EAEbC,IAFa,EAGV;EACH,IAAAC,qBAAA,EAAaF,IAAb,EAAmBG,yBAAnB,EAAqCF,IAArC;EAEA,OAAOD,IAAP;AACD"}

package/packages/emotion/node_modules/@babel/types/lib/modifications/typescript/removeTypeDuplicates.js

@@ -1,80 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = removeTypeDuplicates;
-
-var _generated = require("../../validators/generated");
-
-function getQualifiedName(node) {
-  return (0, _generated.isIdentifier)(node) ? node.name : `${node.right.name}.${getQualifiedName(node.left)}`;
-}
-
-function removeTypeDuplicates(nodes) {
-  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, _generated.isTSAnyKeyword)(node)) {
-      return [node];
-    }
-
-    if ((0, _generated.isTSBaseType)(node)) {
-      bases.set(node.type, node);
-      continue;
-    }
-
-    if ((0, _generated.isTSUnionType)(node)) {
-      if (!typeGroups.has(node.types)) {
-        nodes.push(...node.types);
-        typeGroups.add(node.types);
-      }
-
-      continue;
-    }
-
-    if ((0, _generated.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 = removeTypeDuplicates(existing.typeParameters.params.concat(node.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;
-}
-
-//# sourceMappingURL=removeTypeDuplicates.js.map

package/packages/emotion/node_modules/@babel/types/lib/modifications/typescript/removeTypeDuplicates.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["getQualifiedName","node","isIdentifier","name","right","left","removeTypeDuplicates","nodes","generics","Map","bases","typeGroups","Set","types","i","length","indexOf","isTSAnyKeyword","isTSBaseType","set","type","isTSUnionType","has","push","add","isTSTypeReference","typeParameters","typeName","existing","get","params","concat","baseType","genericName"],"sources":["../../../src/modifications/typescript/removeTypeDuplicates.ts"],"sourcesContent":["import {\n  isIdentifier,\n  isTSAnyKeyword,\n  isTSTypeReference,\n  isTSUnionType,\n  isTSBaseType,\n} from \"../../validators/generated\";\nimport type * as t from \"../..\";\n\nfunction getQualifiedName(node: t.TSTypeReference[\"typeName\"]): string {\n  return isIdentifier(node)\n    ? node.name\n    : `${node.right.name}.${getQualifiedName(node.left)}`;\n}\n\n/**\n * Dedupe type annotations.\n */\nexport default function removeTypeDuplicates(\n  nodes: Array<t.TSType>,\n): Array<t.TSType> {\n  const generics = new Map<string, t.TSTypeReference>();\n  const bases = new Map<t.TSBaseType[\"type\"], t.TSBaseType>();\n\n  // store union type groups to circular references\n  const typeGroups = new Set<t.TSType[]>();\n\n  const types: t.TSType[] = [];\n\n  for (let i = 0; i < nodes.length; i++) {\n    const node = nodes[i];\n    if (!node) continue;\n\n    // detect duplicates\n    if (types.indexOf(node) >= 0) {\n      continue;\n    }\n\n    // this type matches anything\n    if (isTSAnyKeyword(node)) {\n      return [node];\n    }\n\n    // Analogue of FlowBaseAnnotation\n    if (isTSBaseType(node)) {\n      bases.set(node.type, node);\n      continue;\n    }\n\n    if (isTSUnionType(node)) {\n      if (!typeGroups.has(node.types)) {\n        nodes.push(...node.types);\n        typeGroups.add(node.types);\n      }\n      continue;\n    }\n\n    // todo: support merging tuples: number[]\n    if (isTSTypeReference(node) && node.typeParameters) {\n      const name = getQualifiedName(node.typeName);\n\n      if (generics.has(name)) {\n        let existing: t.TypeScript = generics.get(name);\n        if (existing.typeParameters) {\n          if (node.typeParameters) {\n            existing.typeParameters.params = removeTypeDuplicates(\n              existing.typeParameters.params.concat(node.typeParameters.params),\n            );\n          }\n        } else {\n          existing = node.typeParameters;\n        }\n      } else {\n        generics.set(name, node);\n      }\n\n      continue;\n    }\n\n    types.push(node);\n  }\n\n  // add back in bases\n  for (const [, baseType] of bases) {\n    types.push(baseType);\n  }\n\n  // add back in generics\n  for (const [, genericName] of generics) {\n    types.push(genericName);\n  }\n\n  return types;\n}\n"],"mappings":";;;;;;;AAAA;;AASA,SAASA,gBAAT,CAA0BC,IAA1B,EAAuE;EACrE,OAAO,IAAAC,uBAAA,EAAaD,IAAb,IACHA,IAAI,CAACE,IADF,GAEF,GAAEF,IAAI,CAACG,KAAL,CAAWD,IAAK,IAAGH,gBAAgB,CAACC,IAAI,CAACI,IAAN,CAAY,EAFtD;AAGD;;AAKc,SAASC,oBAAT,CACbC,KADa,EAEI;EACjB,MAAMC,QAAQ,GAAG,IAAIC,GAAJ,EAAjB;EACA,MAAMC,KAAK,GAAG,IAAID,GAAJ,EAAd;EAGA,MAAME,UAAU,GAAG,IAAIC,GAAJ,EAAnB;EAEA,MAAMC,KAAiB,GAAG,EAA1B;;EAEA,KAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGP,KAAK,CAACQ,MAA1B,EAAkCD,CAAC,EAAnC,EAAuC;IACrC,MAAMb,IAAI,GAAGM,KAAK,CAACO,CAAD,CAAlB;IACA,IAAI,CAACb,IAAL,EAAW;;IAGX,IAAIY,KAAK,CAACG,OAAN,CAAcf,IAAd,KAAuB,CAA3B,EAA8B;MAC5B;IACD;;IAGD,IAAI,IAAAgB,yBAAA,EAAehB,IAAf,CAAJ,EAA0B;MACxB,OAAO,CAACA,IAAD,CAAP;IACD;;IAGD,IAAI,IAAAiB,uBAAA,EAAajB,IAAb,CAAJ,EAAwB;MACtBS,KAAK,CAACS,GAAN,CAAUlB,IAAI,CAACmB,IAAf,EAAqBnB,IAArB;MACA;IACD;;IAED,IAAI,IAAAoB,wBAAA,EAAcpB,IAAd,CAAJ,EAAyB;MACvB,IAAI,CAACU,UAAU,CAACW,GAAX,CAAerB,IAAI,CAACY,KAApB,CAAL,EAAiC;QAC/BN,KAAK,CAACgB,IAAN,CAAW,GAAGtB,IAAI,CAACY,KAAnB;QACAF,UAAU,CAACa,GAAX,CAAevB,IAAI,CAACY,KAApB;MACD;;MACD;IACD;;IAGD,IAAI,IAAAY,4BAAA,EAAkBxB,IAAlB,KAA2BA,IAAI,CAACyB,cAApC,EAAoD;MAClD,MAAMvB,IAAI,GAAGH,gBAAgB,CAACC,IAAI,CAAC0B,QAAN,CAA7B;;MAEA,IAAInB,QAAQ,CAACc,GAAT,CAAanB,IAAb,CAAJ,EAAwB;QACtB,IAAIyB,QAAsB,GAAGpB,QAAQ,CAACqB,GAAT,CAAa1B,IAAb,CAA7B;;QACA,IAAIyB,QAAQ,CAACF,cAAb,EAA6B;UAC3B,IAAIzB,IAAI,CAACyB,cAAT,EAAyB;YACvBE,QAAQ,CAACF,cAAT,CAAwBI,MAAxB,GAAiCxB,oBAAoB,CACnDsB,QAAQ,CAACF,cAAT,CAAwBI,MAAxB,CAA+BC,MAA/B,CAAsC9B,IAAI,CAACyB,cAAL,CAAoBI,MAA1D,CADmD,CAArD;UAGD;QACF,CAND,MAMO;UACLF,QAAQ,GAAG3B,IAAI,CAACyB,cAAhB;QACD;MACF,CAXD,MAWO;QACLlB,QAAQ,CAACW,GAAT,CAAahB,IAAb,EAAmBF,IAAnB;MACD;;MAED;IACD;;IAEDY,KAAK,CAACU,IAAN,CAAWtB,IAAX;EACD;;EAGD,KAAK,MAAM,GAAG+B,QAAH,CAAX,IAA2BtB,KAA3B,EAAkC;IAChCG,KAAK,CAACU,IAAN,CAAWS,QAAX;EACD;;EAGD,KAAK,MAAM,GAAGC,WAAH,CAAX,IAA8BzB,QAA9B,EAAwC;IACtCK,KAAK,CAACU,IAAN,CAAWU,WAAX;EACD;;EAED,OAAOpB,KAAP;AACD"}

package/packages/emotion/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js

@@ -1,107 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = getBindingIdentifiers;
-
-var _generated = require("../validators/generated");
-
-function getBindingIdentifiers(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.keys[id.type];
-
-    if ((0, _generated.isIdentifier)(id)) {
-      if (duplicates) {
-        const _ids = ids[id.name] = ids[id.name] || [];
-
-        _ids.push(id);
-      } else {
-        ids[id.name] = id;
-      }
-
-      continue;
-    }
-
-    if ((0, _generated.isExportDeclaration)(id) && !(0, _generated.isExportAllDeclaration)(id)) {
-      if ((0, _generated.isDeclaration)(id.declaration)) {
-        search.push(id.declaration);
-      }
-
-      continue;
-    }
-
-    if (outerOnly) {
-      if ((0, _generated.isFunctionDeclaration)(id)) {
-        search.push(id.id);
-        continue;
-      }
-
-      if ((0, _generated.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.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"]
-};
-
-//# sourceMappingURL=getBindingIdentifiers.js.map

package/packages/emotion/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["getBindingIdentifiers","node","duplicates","outerOnly","search","concat","ids","Object","create","length","id","shift","keys","type","isIdentifier","_ids","name","push","isExportDeclaration","isExportAllDeclaration","isDeclaration","declaration","isFunctionDeclaration","isFunctionExpression","i","key","nodes","Array","isArray","DeclareClass","DeclareFunction","DeclareModule","DeclareVariable","DeclareInterface","DeclareTypeAlias","DeclareOpaqueType","InterfaceDeclaration","TypeAlias","OpaqueType","CatchClause","LabeledStatement","UnaryExpression","AssignmentExpression","ImportSpecifier","ImportNamespaceSpecifier","ImportDefaultSpecifier","ImportDeclaration","ExportSpecifier","ExportNamespaceSpecifier","ExportDefaultSpecifier","FunctionDeclaration","FunctionExpression","ArrowFunctionExpression","ObjectMethod","ClassMethod","ClassPrivateMethod","ForInStatement","ForOfStatement","ClassDeclaration","ClassExpression","RestElement","UpdateExpression","ObjectProperty","AssignmentPattern","ArrayPattern","ObjectPattern","VariableDeclaration","VariableDeclarator"],"sources":["../../src/retrievers/getBindingIdentifiers.ts"],"sourcesContent":["import {\n  isExportDeclaration,\n  isIdentifier,\n  isDeclaration,\n  isFunctionDeclaration,\n  isFunctionExpression,\n  isExportAllDeclaration,\n} from \"../validators/generated\";\nimport type * as t from \"..\";\n\nexport { getBindingIdentifiers as default };\n\nfunction getBindingIdentifiers(\n  node: t.Node,\n  duplicates: true,\n  outerOnly?: boolean,\n): Record<string, Array<t.Identifier>>;\n\nfunction getBindingIdentifiers(\n  node: t.Node,\n  duplicates?: false,\n  outerOnly?: boolean,\n): Record<string, t.Identifier>;\n\nfunction getBindingIdentifiers(\n  node: t.Node,\n  duplicates?: boolean,\n  outerOnly?: boolean,\n): Record<string, t.Identifier> | Record<string, Array<t.Identifier>>;\n\n/**\n * Return a list of binding identifiers associated with the input `node`.\n */\nfunction getBindingIdentifiers(\n  node: t.Node,\n  duplicates?: boolean,\n  outerOnly?: boolean,\n): Record<string, t.Identifier> | Record<string, Array<t.Identifier>> {\n  const search: t.Node[] = [].concat(node);\n  const ids = Object.create(null);\n\n  while (search.length) {\n    const id = search.shift();\n    if (!id) continue;\n\n    const keys =\n      // @ts-expect-error getBindingIdentifiers.keys do not cover all AST types\n      getBindingIdentifiers.keys[id.type];\n\n    if (isIdentifier(id)) {\n      if (duplicates) {\n        const _ids = (ids[id.name] = ids[id.name] || []);\n        _ids.push(id);\n      } else {\n        ids[id.name] = id;\n      }\n      continue;\n    }\n\n    if (isExportDeclaration(id) && !isExportAllDeclaration(id)) {\n      if (isDeclaration(id.declaration)) {\n        search.push(id.declaration);\n      }\n      continue;\n    }\n\n    if (outerOnly) {\n      if (isFunctionDeclaration(id)) {\n        search.push(id.id);\n        continue;\n      }\n\n      if (isFunctionExpression(id)) {\n        continue;\n      }\n    }\n\n    if (keys) {\n      for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        const nodes =\n          // @ts-expect-error key must present in id\n          id[key] as t.Node[] | t.Node | undefined | null;\n        if (nodes) {\n          Array.isArray(nodes) ? search.push(...nodes) : search.push(nodes);\n        }\n      }\n    }\n  }\n\n  // $FlowIssue Object.create() seems broken\n  return ids;\n}\n\n/**\n * Mapping of types to their identifier keys.\n */\ngetBindingIdentifiers.keys = {\n  DeclareClass: [\"id\"],\n  DeclareFunction: [\"id\"],\n  DeclareModule: [\"id\"],\n  DeclareVariable: [\"id\"],\n  DeclareInterface: [\"id\"],\n  DeclareTypeAlias: [\"id\"],\n  DeclareOpaqueType: [\"id\"],\n  InterfaceDeclaration: [\"id\"],\n  TypeAlias: [\"id\"],\n  OpaqueType: [\"id\"],\n\n  CatchClause: [\"param\"],\n  LabeledStatement: [\"label\"],\n  UnaryExpression: [\"argument\"],\n  AssignmentExpression: [\"left\"],\n\n  ImportSpecifier: [\"local\"],\n  ImportNamespaceSpecifier: [\"local\"],\n  ImportDefaultSpecifier: [\"local\"],\n  ImportDeclaration: [\"specifiers\"],\n\n  ExportSpecifier: [\"exported\"],\n  ExportNamespaceSpecifier: [\"exported\"],\n  ExportDefaultSpecifier: [\"exported\"],\n\n  FunctionDeclaration: [\"id\", \"params\"],\n  FunctionExpression: [\"id\", \"params\"],\n  ArrowFunctionExpression: [\"params\"],\n  ObjectMethod: [\"params\"],\n  ClassMethod: [\"params\"],\n  ClassPrivateMethod: [\"params\"],\n\n  ForInStatement: [\"left\"],\n  ForOfStatement: [\"left\"],\n\n  ClassDeclaration: [\"id\"],\n  ClassExpression: [\"id\"],\n\n  RestElement: [\"argument\"],\n  UpdateExpression: [\"argument\"],\n\n  ObjectProperty: [\"value\"],\n\n  AssignmentPattern: [\"left\"],\n  ArrayPattern: [\"elements\"],\n  ObjectPattern: [\"properties\"],\n\n  VariableDeclaration: [\"declarations\"],\n  VariableDeclarator: [\"id\"],\n};\n"],"mappings":"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"}

package/packages/emotion/node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js

@@ -1,17 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _getBindingIdentifiers = require("./getBindingIdentifiers");
-
-var _default = getOuterBindingIdentifiers;
-exports.default = _default;
-
-function getOuterBindingIdentifiers(node, duplicates) {
-  return (0, _getBindingIdentifiers.default)(node, duplicates, true);
-}
-
-//# sourceMappingURL=getOuterBindingIdentifiers.js.map

package/packages/emotion/node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["getOuterBindingIdentifiers","node","duplicates","getBindingIdentifiers"],"sources":["../../src/retrievers/getOuterBindingIdentifiers.ts"],"sourcesContent":["import getBindingIdentifiers from \"./getBindingIdentifiers\";\nimport type * as t from \"..\";\n\nexport default getOuterBindingIdentifiers as {\n  (node: t.Node, duplicates: true): Record<string, Array<t.Identifier>>;\n  (node: t.Node, duplicates?: false): Record<string, t.Identifier>;\n  (node: t.Node, duplicates?: boolean):\n    | Record<string, t.Identifier>\n    | Record<string, Array<t.Identifier>>;\n};\n\nfunction getOuterBindingIdentifiers(\n  node: t.Node,\n  duplicates: boolean,\n): Record<string, t.Identifier> | Record<string, Array<t.Identifier>> {\n  return getBindingIdentifiers(node, duplicates, true);\n}\n"],"mappings":";;;;;;;AAAA;;eAGeA,0B;;;AAQf,SAASA,0BAAT,CACEC,IADF,EAEEC,UAFF,EAGsE;EACpE,OAAO,IAAAC,8BAAA,EAAsBF,IAAtB,EAA4BC,UAA5B,EAAwC,IAAxC,CAAP;AACD"}

package/packages/emotion/node_modules/@babel/types/lib/traverse/traverse.js

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

package/packages/emotion/node_modules/@babel/types/lib/traverse/traverse.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["traverse","node","handlers","state","enter","exit","traverseSimpleImpl","ancestors","keys","VISITOR_KEYS","type","key","subNode","Array","isArray","i","length","child","push","index","pop"],"sources":["../../src/traverse/traverse.ts"],"sourcesContent":["import { VISITOR_KEYS } from \"../definitions\";\nimport type * as t from \"..\";\n\nexport type TraversalAncestors = Array<{\n  node: t.Node;\n  key: string;\n  index?: number;\n}>;\n\nexport type TraversalHandler<T> = (\n  this: undefined,\n  node: t.Node,\n  parent: TraversalAncestors,\n  state: T,\n) => void;\n\nexport type TraversalHandlers<T> = {\n  enter?: TraversalHandler<T>;\n  exit?: TraversalHandler<T>;\n};\n\n/**\n * A general AST traversal with both prefix and postfix handlers, and a\n * state object. Exposes ancestry data to each handler so that more complex\n * AST data can be taken into account.\n */\nexport default function traverse<T>(\n  node: t.Node,\n  handlers: TraversalHandler<T> | TraversalHandlers<T>,\n  state?: T,\n): void {\n  if (typeof handlers === \"function\") {\n    handlers = { enter: handlers };\n  }\n\n  const { enter, exit } = handlers as TraversalHandlers<T>;\n\n  traverseSimpleImpl(node, enter, exit, state, []);\n}\n\nfunction traverseSimpleImpl<T>(\n  node: any,\n  enter: Function | undefined,\n  exit: Function | undefined,\n  state: T | undefined,\n  ancestors: TraversalAncestors,\n) {\n  const keys = VISITOR_KEYS[node.type];\n  if (!keys) return;\n\n  if (enter) enter(node, ancestors, state);\n\n  for (const key of keys) {\n    const subNode = node[key];\n\n    if (Array.isArray(subNode)) {\n      for (let i = 0; i < subNode.length; i++) {\n        const child = subNode[i];\n        if (!child) continue;\n\n        ancestors.push({\n          node,\n          key,\n          index: i,\n        });\n\n        traverseSimpleImpl(child, enter, exit, state, ancestors);\n\n        ancestors.pop();\n      }\n    } else if (subNode) {\n      ancestors.push({\n        node,\n        key,\n      });\n\n      traverseSimpleImpl(subNode, enter, exit, state, ancestors);\n\n      ancestors.pop();\n    }\n  }\n\n  if (exit) exit(node, ancestors, state);\n}\n"],"mappings":";;;;;;;AAAA;;AA0Be,SAASA,QAAT,CACbC,IADa,EAEbC,QAFa,EAGbC,KAHa,EAIP;EACN,IAAI,OAAOD,QAAP,KAAoB,UAAxB,EAAoC;IAClCA,QAAQ,GAAG;MAAEE,KAAK,EAAEF;IAAT,CAAX;EACD;;EAED,MAAM;IAAEE,KAAF;IAASC;EAAT,IAAkBH,QAAxB;EAEAI,kBAAkB,CAACL,IAAD,EAAOG,KAAP,EAAcC,IAAd,EAAoBF,KAApB,EAA2B,EAA3B,CAAlB;AACD;;AAED,SAASG,kBAAT,CACEL,IADF,EAEEG,KAFF,EAGEC,IAHF,EAIEF,KAJF,EAKEI,SALF,EAME;EACA,MAAMC,IAAI,GAAGC,yBAAA,CAAaR,IAAI,CAACS,IAAlB,CAAb;EACA,IAAI,CAACF,IAAL,EAAW;EAEX,IAAIJ,KAAJ,EAAWA,KAAK,CAACH,IAAD,EAAOM,SAAP,EAAkBJ,KAAlB,CAAL;;EAEX,KAAK,MAAMQ,GAAX,IAAkBH,IAAlB,EAAwB;IACtB,MAAMI,OAAO,GAAGX,IAAI,CAACU,GAAD,CAApB;;IAEA,IAAIE,KAAK,CAACC,OAAN,CAAcF,OAAd,CAAJ,EAA4B;MAC1B,KAAK,IAAIG,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGH,OAAO,CAACI,MAA5B,EAAoCD,CAAC,EAArC,EAAyC;QACvC,MAAME,KAAK,GAAGL,OAAO,CAACG,CAAD,CAArB;QACA,IAAI,CAACE,KAAL,EAAY;QAEZV,SAAS,CAACW,IAAV,CAAe;UACbjB,IADa;UAEbU,GAFa;UAGbQ,KAAK,EAAEJ;QAHM,CAAf;QAMAT,kBAAkB,CAACW,KAAD,EAAQb,KAAR,EAAeC,IAAf,EAAqBF,KAArB,EAA4BI,SAA5B,CAAlB;QAEAA,SAAS,CAACa,GAAV;MACD;IACF,CAfD,MAeO,IAAIR,OAAJ,EAAa;MAClBL,SAAS,CAACW,IAAV,CAAe;QACbjB,IADa;QAEbU;MAFa,CAAf;MAKAL,kBAAkB,CAACM,OAAD,EAAUR,KAAV,EAAiBC,IAAjB,EAAuBF,KAAvB,EAA8BI,SAA9B,CAAlB;MAEAA,SAAS,CAACa,GAAV;IACD;EACF;;EAED,IAAIf,IAAJ,EAAUA,IAAI,CAACJ,IAAD,EAAOM,SAAP,EAAkBJ,KAAlB,CAAJ;AACX"}

package/packages/emotion/node_modules/@babel/types/lib/traverse/traverseFast.js

@@ -1,30 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = traverseFast;
-
-var _definitions = require("../definitions");
-
-function traverseFast(node, enter, opts) {
-  if (!node) return;
-  const keys = _definitions.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(node, enter, opts);
-      }
-    } else {
-      traverseFast(subNode, enter, opts);
-    }
-  }
-}
-
-//# sourceMappingURL=traverseFast.js.map

package/packages/emotion/node_modules/@babel/types/lib/traverse/traverseFast.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["traverseFast","node","enter","opts","keys","VISITOR_KEYS","type","key","subNode","Array","isArray"],"sources":["../../src/traverse/traverseFast.ts"],"sourcesContent":["import { VISITOR_KEYS } from \"../definitions\";\nimport type * as t from \"..\";\n\n/**\n * A prefix AST traversal implementation meant for simple searching\n * and processing.\n */\nexport default function traverseFast<Options = {}>(\n  node: t.Node | null | undefined,\n  enter: (node: t.Node, opts?: Options) => void,\n  opts?: Options,\n): void {\n  if (!node) return;\n\n  const keys = VISITOR_KEYS[node.type];\n  if (!keys) return;\n\n  opts = opts || ({} as Options);\n  enter(node, opts);\n\n  for (const key of keys) {\n    const subNode: t.Node | undefined | null =\n      // @ts-expect-error key must present in node\n      node[key];\n\n    if (Array.isArray(subNode)) {\n      for (const node of subNode) {\n        traverseFast(node, enter, opts);\n      }\n    } else {\n      traverseFast(subNode, enter, opts);\n    }\n  }\n}\n"],"mappings":";;;;;;;AAAA;;AAOe,SAASA,YAAT,CACbC,IADa,EAEbC,KAFa,EAGbC,IAHa,EAIP;EACN,IAAI,CAACF,IAAL,EAAW;EAEX,MAAMG,IAAI,GAAGC,yBAAA,CAAaJ,IAAI,CAACK,IAAlB,CAAb;EACA,IAAI,CAACF,IAAL,EAAW;EAEXD,IAAI,GAAGA,IAAI,IAAK,EAAhB;EACAD,KAAK,CAACD,IAAD,EAAOE,IAAP,CAAL;;EAEA,KAAK,MAAMI,GAAX,IAAkBH,IAAlB,EAAwB;IACtB,MAAMI,OAAkC,GAEtCP,IAAI,CAACM,GAAD,CAFN;;IAIA,IAAIE,KAAK,CAACC,OAAN,CAAcF,OAAd,CAAJ,EAA4B;MAC1B,KAAK,MAAMP,IAAX,IAAmBO,OAAnB,EAA4B;QAC1BR,YAAY,CAACC,IAAD,EAAOC,KAAP,EAAcC,IAAd,CAAZ;MACD;IACF,CAJD,MAIO;MACLH,YAAY,CAACQ,OAAD,EAAUN,KAAV,EAAiBC,IAAjB,CAAZ;IACD;EACF;AACF"}

package/packages/emotion/node_modules/@babel/types/lib/utils/inherit.js

@@ -1,14 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = inherit;
-
-function inherit(key, child, parent) {
-  if (child && parent) {
-    child[key] = Array.from(new Set([].concat(child[key], parent[key]).filter(Boolean)));
-  }
-}
-
-//# sourceMappingURL=inherit.js.map

package/packages/emotion/node_modules/@babel/types/lib/utils/inherit.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["inherit","key","child","parent","Array","from","Set","concat","filter","Boolean"],"sources":["../../src/utils/inherit.ts"],"sourcesContent":["import type * as t from \"..\";\n\nexport default function inherit<\n  C extends t.Node | undefined,\n  P extends t.Node | undefined,\n>(key: keyof C & keyof P, child: C, parent: P): void {\n  if (child && parent) {\n    // @ts-expect-error Could further refine key definitions\n    child[key] = Array.from(\n      new Set([].concat(child[key], parent[key]).filter(Boolean)),\n    );\n  }\n}\n"],"mappings":";;;;;;;AAEe,SAASA,OAAT,CAGbC,GAHa,EAGWC,KAHX,EAGqBC,MAHrB,EAGsC;EACnD,IAAID,KAAK,IAAIC,MAAb,EAAqB;IAEnBD,KAAK,CAACD,GAAD,CAAL,GAAaG,KAAK,CAACC,IAAN,CACX,IAAIC,GAAJ,CAAQ,GAAGC,MAAH,CAAUL,KAAK,CAACD,GAAD,CAAf,EAAsBE,MAAM,CAACF,GAAD,CAA5B,EAAmCO,MAAnC,CAA0CC,OAA1C,CAAR,CADW,CAAb;EAGD;AACF"}