@venos-inc/venos 0.1.5 → 0.1.6

package/etc/mcp-server/node_modules/@babel/types/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_isReactComponent","require","_isCompatTag","_buildChildren","_assertNode","_index","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_createTypeAnnotationBasedOnTypeof","_createFlowUnionType","_createTSUnionType","_productions","_index2","_cloneNode","_clone","_cloneDeep","_cloneDeepWithoutLoc","_cloneWithoutLoc","_addComment","_addComments","_inheritInnerComments","_inheritLeadingComments","_inheritsComments","_inheritTrailingComments","_removeComments","_index3","_index4","_ensureBlock","_toBindingIdentifierName","_toBlock","_toComputedKey","_toExpression","_toIdentifier","_toKeyAlias","_toStatement","_valueToNode","_index5","_appendToMemberExpression","_inherits","_prependToMemberExpression","_removeProperties","_removePropertiesDeep","_removeTypeDuplicates","_getAssignmentIdentifiers","_getBindingIdentifiers","_getOuterBindingIdentifiers","_getFunctionName","_traverse","_traverseFast","_shallowEqual","_is","_isBinding","_isBlockScoped","_isImmutable","_isLet","_isNode","_isNodesEquivalent","_isPlaceholderType","_isReferenced","_isScope","_isSpecifierDefault","_isType","_isValidES3Identifier","_isValidIdentifier","_isVar","_matchesPattern","_validate","_buildMatchMemberExpression","_index6","_deprecationWarning","_toSequenceExpression","react","isReactComponent","isCompatTag","buildChildren","toSequenceExpression","process","env","BABEL_TYPES_8_BREAKING","console","warn"],"sources":["../src/index.ts"],"sourcesContent":["import isReactComponent from \"./validators/react/isReactComponent.ts\";\nimport isCompatTag from \"./validators/react/isCompatTag.ts\";\nimport buildChildren from \"./builders/react/buildChildren.ts\";\n\n// asserts\nexport { default as assertNode } from \"./asserts/assertNode.ts\";\nexport * from \"./asserts/generated/index.ts\";\n\n// builders\nexport { default as createTypeAnnotationBasedOnTypeof } from \"./builders/flow/createTypeAnnotationBasedOnTypeof.ts\";\n/** @deprecated use createFlowUnionType instead */\nexport { default as createUnionTypeAnnotation } from \"./builders/flow/createFlowUnionType.ts\";\nexport { default as createFlowUnionType } from \"./builders/flow/createFlowUnionType.ts\";\nexport { default as createTSUnionType } from \"./builders/typescript/createTSUnionType.ts\";\nexport * from \"./builders/productions.ts\";\nexport * from \"./builders/generated/index.ts\"; // includes AST types\n\n// clone\nexport { default as cloneNode } from \"./clone/cloneNode.ts\";\nexport { default as clone } from \"./clone/clone.ts\";\nexport { default as cloneDeep } from \"./clone/cloneDeep.ts\";\nexport { default as cloneDeepWithoutLoc } from \"./clone/cloneDeepWithoutLoc.ts\";\nexport { default as cloneWithoutLoc } from \"./clone/cloneWithoutLoc.ts\";\n\n// comments\nexport { default as addComment } from \"./comments/addComment.ts\";\nexport { default as addComments } from \"./comments/addComments.ts\";\nexport { default as inheritInnerComments } from \"./comments/inheritInnerComments.ts\";\nexport { default as inheritLeadingComments } from \"./comments/inheritLeadingComments.ts\";\nexport { default as inheritsComments } from \"./comments/inheritsComments.ts\";\nexport { default as inheritTrailingComments } from \"./comments/inheritTrailingComments.ts\";\nexport { default as removeComments } from \"./comments/removeComments.ts\";\n\n// constants\nexport * from \"./constants/generated/index.ts\";\nexport * from \"./constants/index.ts\";\n\n// converters\nexport { default as ensureBlock } from \"./converters/ensureBlock.ts\";\nexport { default as toBindingIdentifierName } from \"./converters/toBindingIdentifierName.ts\";\nexport { default as toBlock } from \"./converters/toBlock.ts\";\nexport { default as toComputedKey } from \"./converters/toComputedKey.ts\";\nexport { default as toExpression } from \"./converters/toExpression.ts\";\nexport { default as toIdentifier } from \"./converters/toIdentifier.ts\";\nexport { default as toKeyAlias } from \"./converters/toKeyAlias.ts\";\nexport { default as toStatement } from \"./converters/toStatement.ts\";\nexport { default as valueToNode } from \"./converters/valueToNode.ts\";\n\n// definitions\nexport * from \"./definitions/index.ts\";\n\n// modifications\nexport { default as appendToMemberExpression } from \"./modifications/appendToMemberExpression.ts\";\nexport { default as inherits } from \"./modifications/inherits.ts\";\nexport { default as prependToMemberExpression } from \"./modifications/prependToMemberExpression.ts\";\nexport {\n  default as removeProperties,\n  type Options as RemovePropertiesOptions,\n} from \"./modifications/removeProperties.ts\";\nexport { default as removePropertiesDeep } from \"./modifications/removePropertiesDeep.ts\";\nexport { default as removeTypeDuplicates } from \"./modifications/flow/removeTypeDuplicates.ts\";\n\n// retrievers\nexport { default as getAssignmentIdentifiers } from \"./retrievers/getAssignmentIdentifiers.ts\";\nexport { default as getBindingIdentifiers } from \"./retrievers/getBindingIdentifiers.ts\";\nexport { default as getOuterBindingIdentifiers } from \"./retrievers/getOuterBindingIdentifiers.ts\";\nexport { default as getFunctionName } from \"./retrievers/getFunctionName.ts\";\n\n// traverse\nexport { default as traverse } from \"./traverse/traverse.ts\";\nexport * from \"./traverse/traverse.ts\";\nexport { default as traverseFast } from \"./traverse/traverseFast.ts\";\n\n// utils\nexport { default as shallowEqual } from \"./utils/shallowEqual.ts\";\n\n// validators\nexport { default as is } from \"./validators/is.ts\";\nexport { default as isBinding } from \"./validators/isBinding.ts\";\nexport { default as isBlockScoped } from \"./validators/isBlockScoped.ts\";\nexport { default as isImmutable } from \"./validators/isImmutable.ts\";\nexport { default as isLet } from \"./validators/isLet.ts\";\nexport { default as isNode } from \"./validators/isNode.ts\";\nexport { default as isNodesEquivalent } from \"./validators/isNodesEquivalent.ts\";\nexport { default as isPlaceholderType } from \"./validators/isPlaceholderType.ts\";\nexport { default as isReferenced } from \"./validators/isReferenced.ts\";\nexport { default as isScope } from \"./validators/isScope.ts\";\nexport { default as isSpecifierDefault } from \"./validators/isSpecifierDefault.ts\";\nexport { default as isType } from \"./validators/isType.ts\";\nexport { default as isValidES3Identifier } from \"./validators/isValidES3Identifier.ts\";\nexport { default as isValidIdentifier } from \"./validators/isValidIdentifier.ts\";\nexport { default as isVar } from \"./validators/isVar.ts\";\nexport { default as matchesPattern } from \"./validators/matchesPattern.ts\";\nexport { default as validate } from \"./validators/validate.ts\";\nexport { default as buildMatchMemberExpression } from \"./validators/buildMatchMemberExpression.ts\";\nexport * from \"./validators/generated/index.ts\";\n\n// react\nexport const react = {\n  isReactComponent,\n  isCompatTag,\n  buildChildren,\n};\n\n// this is used by @babel/traverse to warn about deprecated visitors\nexport { default as __internal__deprecationWarning } from \"./utils/deprecationWarning.ts\";\n\nimport toSequenceExpression from \"./converters/toSequenceExpression.ts\" with { if: \"!process.env.BABEL_8_BREAKING && !USE_ESM && !IS_STANDALONE\" };\nif (!process.env.BABEL_8_BREAKING && !USE_ESM && !IS_STANDALONE) {\n  // eslint-disable-next-line no-restricted-globals\n  exports.toSequenceExpression = toSequenceExpression;\n}\n\nif (!process.env.BABEL_8_BREAKING && process.env.BABEL_TYPES_8_BREAKING) {\n  console.warn(\n    \"BABEL_TYPES_8_BREAKING is not supported anymore. Use the latest Babel 8.0.0 pre-release instead!\",\n  );\n}\n"],"mappings":"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","ignoreList":[]}

package/etc/mcp-server/node_modules/@babel/types/lib/modifications/appendToMemberExpression.js

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

package/etc/mcp-server/node_modules/@babel/types/lib/modifications/appendToMemberExpression.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","appendToMemberExpression","member","append","computed","object","memberExpression","property"],"sources":["../../src/modifications/appendToMemberExpression.ts"],"sourcesContent":["import { memberExpression } from \"../builders/generated/index.ts\";\nimport type * as t from \"../index.ts\";\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,IAAAA,MAAA,GAAAC,OAAA;AAMe,SAASC,wBAAwBA,CAC9CC,MAA0B,EAC1BC,MAAsC,EACtCC,QAAiB,GAAG,KAAK,EACL;EACpBF,MAAM,CAACG,MAAM,GAAG,IAAAC,uBAAgB,EAC9BJ,MAAM,CAACG,MAAM,EACbH,MAAM,CAACK,QAAQ,EACfL,MAAM,CAACE,QACT,CAAC;EACDF,MAAM,CAACK,QAAQ,GAAGJ,MAAM;EACxBD,MAAM,CAACE,QAAQ,GAAG,CAAC,CAACA,QAAQ;EAE5B,OAAOF,MAAM;AACf","ignoreList":[]}

package/etc/mcp-server/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removeTypeDuplicates;
+var _index = require("../../validators/generated/index.js");
+function getQualifiedName(node) {
+  return (0, _index.isIdentifier)(node) ? node.name : `${node.id.name}.${getQualifiedName(node.qualification)}`;
+}
+function removeTypeDuplicates(nodesIn) {
+  const nodes = Array.from(nodesIn);
+  const generics = new Map();
+  const bases = new Map();
+  const typeGroups = new Set();
+  const types = [];
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (!node) continue;
+    if (types.includes(node)) {
+      continue;
+    }
+    if ((0, _index.isAnyTypeAnnotation)(node)) {
+      return [node];
+    }
+    if ((0, _index.isFlowBaseAnnotation)(node)) {
+      bases.set(node.type, node);
+      continue;
+    }
+    if ((0, _index.isUnionTypeAnnotation)(node)) {
+      if (!typeGroups.has(node.types)) {
+        nodes.push(...node.types);
+        typeGroups.add(node.types);
+      }
+      continue;
+    }
+    if ((0, _index.isGenericTypeAnnotation)(node)) {
+      const name = getQualifiedName(node.id);
+      if (generics.has(name)) {
+        let existing = generics.get(name);
+        if (existing.typeParameters) {
+          if (node.typeParameters) {
+            existing.typeParameters.params.push(...node.typeParameters.params);
+            existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params);
+          }
+        } else {
+          existing = node.typeParameters;
+        }
+      } else {
+        generics.set(name, node);
+      }
+      continue;
+    }
+    types.push(node);
+  }
+  for (const [, baseType] of bases) {
+    types.push(baseType);
+  }
+  for (const [, genericName] of generics) {
+    types.push(genericName);
+  }
+  return types;
+}
+
+//# sourceMappingURL=removeTypeDuplicates.js.map

package/etc/mcp-server/node_modules/@babel/types/lib/modifications/flow/removeTypeDuplicates.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","getQualifiedName","node","isIdentifier","name","id","qualification","removeTypeDuplicates","nodesIn","nodes","Array","from","generics","Map","bases","typeGroups","Set","types","i","length","includes","isAnyTypeAnnotation","isFlowBaseAnnotation","set","type","isUnionTypeAnnotation","has","push","add","isGenericTypeAnnotation","existing","get","typeParameters","params","baseType","genericName"],"sources":["../../../src/modifications/flow/removeTypeDuplicates.ts"],"sourcesContent":["import {\n  isAnyTypeAnnotation,\n  isGenericTypeAnnotation,\n  isUnionTypeAnnotation,\n  isFlowBaseAnnotation,\n  isIdentifier,\n} from \"../../validators/generated/index.ts\";\nimport type * as t from \"../../index.ts\";\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  nodesIn: readonly (t.FlowType | false | null | undefined)[],\n): t.FlowType[] {\n  const nodes = Array.from(nodesIn);\n\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.includes(node)) {\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        nodes.push(...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.push(...node.typeParameters.params);\n            existing.typeParameters.params = removeTypeDuplicates(\n              existing.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,IAAAA,MAAA,GAAAC,OAAA;AASA,SAASC,gBAAgBA,CAACC,IAAmC,EAAU;EACrE,OAAO,IAAAC,mBAAY,EAACD,IAAI,CAAC,GACrBA,IAAI,CAACE,IAAI,GACT,GAAGF,IAAI,CAACG,EAAE,CAACD,IAAI,IAAIH,gBAAgB,CAACC,IAAI,CAACI,aAAa,CAAC,EAAE;AAC/D;AAKe,SAASC,oBAAoBA,CAC1CC,OAA2D,EAC7C;EACd,MAAMC,KAAK,GAAGC,KAAK,CAACC,IAAI,CAACH,OAAO,CAAC;EAEjC,MAAMI,QAAQ,GAAG,IAAIC,GAAG,CAAkC,CAAC;EAC3D,MAAMC,KAAK,GAAG,IAAID,GAAG,CAAqD,CAAC;EAG3E,MAAME,UAAU,GAAG,IAAIC,GAAG,CAAe,CAAC;EAE1C,MAAMC,KAAmB,GAAG,EAAE;EAE9B,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGT,KAAK,CAACU,MAAM,EAAED,CAAC,EAAE,EAAE;IACrC,MAAMhB,IAAI,GAAGO,KAAK,CAACS,CAAC,CAAC;IACrB,IAAI,CAAChB,IAAI,EAAE;IAGX,IAAIe,KAAK,CAACG,QAAQ,CAAClB,IAAI,CAAC,EAAE;MACxB;IACF;IAGA,IAAI,IAAAmB,0BAAmB,EAACnB,IAAI,CAAC,EAAE;MAC7B,OAAO,CAACA,IAAI,CAAC;IACf;IAEA,IAAI,IAAAoB,2BAAoB,EAACpB,IAAI,CAAC,EAAE;MAC9BY,KAAK,CAACS,GAAG,CAACrB,IAAI,CAACsB,IAAI,EAAEtB,IAAI,CAAC;MAC1B;IACF;IAEA,IAAI,IAAAuB,4BAAqB,EAACvB,IAAI,CAAC,EAAE;MAC/B,IAAI,CAACa,UAAU,CAACW,GAAG,CAACxB,IAAI,CAACe,KAAK,CAAC,EAAE;QAC/BR,KAAK,CAACkB,IAAI,CAAC,GAAGzB,IAAI,CAACe,KAAK,CAAC;QACzBF,UAAU,CAACa,GAAG,CAAC1B,IAAI,CAACe,KAAK,CAAC;MAC5B;MACA;IACF;IAGA,IAAI,IAAAY,8BAAuB,EAAC3B,IAAI,CAAC,EAAE;MACjC,MAAME,IAAI,GAAGH,gBAAgB,CAACC,IAAI,CAACG,EAAE,CAAC;MAEtC,IAAIO,QAAQ,CAACc,GAAG,CAACtB,IAAI,CAAC,EAAE;QACtB,IAAI0B,QAAgB,GAAGlB,QAAQ,CAACmB,GAAG,CAAC3B,IAAI,CAAC;QACzC,IAAI0B,QAAQ,CAACE,cAAc,EAAE;UAC3B,IAAI9B,IAAI,CAAC8B,cAAc,EAAE;YACvBF,QAAQ,CAACE,cAAc,CAACC,MAAM,CAACN,IAAI,CAAC,GAAGzB,IAAI,CAAC8B,cAAc,CAACC,MAAM,CAAC;YAClEH,QAAQ,CAACE,cAAc,CAACC,MAAM,GAAG1B,oBAAoB,CACnDuB,QAAQ,CAACE,cAAc,CAACC,MAC1B,CAAC;UACH;QACF,CAAC,MAAM;UACLH,QAAQ,GAAG5B,IAAI,CAAC8B,cAAc;QAChC;MACF,CAAC,MAAM;QACLpB,QAAQ,CAACW,GAAG,CAACnB,IAAI,EAAEF,IAAI,CAAC;MAC1B;MAEA;IACF;IAEAe,KAAK,CAACU,IAAI,CAACzB,IAAI,CAAC;EAClB;EAGA,KAAK,MAAM,GAAGgC,QAAQ,CAAC,IAAIpB,KAAK,EAAE;IAChCG,KAAK,CAACU,IAAI,CAACO,QAAQ,CAAC;EACtB;EAGA,KAAK,MAAM,GAAGC,WAAW,CAAC,IAAIvB,QAAQ,EAAE;IACtCK,KAAK,CAACU,IAAI,CAACQ,WAAW,CAAC;EACzB;EAEA,OAAOlB,KAAK;AACd","ignoreList":[]}

package/etc/mcp-server/node_modules/@babel/types/lib/modifications/inherits.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = inherits;
+var _index = require("../constants/index.js");
+var _inheritsComments = require("../comments/inheritsComments.js");
+function inherits(child, parent) {
+  if (!child || !parent) return child;
+  for (const key of _index.INHERIT_KEYS.optional) {
+    if (child[key] == null) {
+      child[key] = parent[key];
+    }
+  }
+  for (const key of Object.keys(parent)) {
+    if (key.startsWith("_") && key !== "__clone") {
+      child[key] = parent[key];
+    }
+  }
+  for (const key of _index.INHERIT_KEYS.force) {
+    child[key] = parent[key];
+  }
+  (0, _inheritsComments.default)(child, parent);
+  return child;
+}
+
+//# sourceMappingURL=inherits.js.map

package/etc/mcp-server/node_modules/@babel/types/lib/modifications/inherits.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","_inheritsComments","inherits","child","parent","key","INHERIT_KEYS","optional","Object","keys","startsWith","force","inheritsComments"],"sources":["../../src/modifications/inherits.ts"],"sourcesContent":["import { INHERIT_KEYS } from \"../constants/index.ts\";\nimport inheritsComments from \"../comments/inheritsComments.ts\";\nimport type * as t from \"../index.ts\";\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.startsWith(\"_\") && 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,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,iBAAA,GAAAD,OAAA;AAMe,SAASE,QAAQA,CAC9BC,KAAQ,EACRC,MAAiC,EAC9B;EACH,IAAI,CAACD,KAAK,IAAI,CAACC,MAAM,EAAE,OAAOD,KAAK;EAGnC,KAAK,MAAME,GAAG,IAAIC,mBAAY,CAACC,QAAQ,EAAE;IAEvC,IAAIJ,KAAK,CAACE,GAAG,CAAC,IAAI,IAAI,EAAE;MAEtBF,KAAK,CAACE,GAAG,CAAC,GAAGD,MAAM,CAACC,GAAG,CAAC;IAC1B;EACF;EAGA,KAAK,MAAMA,GAAG,IAAIG,MAAM,CAACC,IAAI,CAACL,MAAM,CAAC,EAAE;IACrC,IAAIC,GAAG,CAACK,UAAU,CAAC,GAAG,CAAC,IAAIL,GAAG,KAAK,SAAS,EAAE;MAE5CF,KAAK,CAACE,GAAG,CAAC,GAAGD,MAAM,CAACC,GAAG,CAAC;IAC1B;EACF;EAGA,KAAK,MAAMA,GAAG,IAAIC,mBAAY,CAACK,KAAK,EAAE;IAEpCR,KAAK,CAACE,GAAG,CAAC,GAAGD,MAAM,CAACC,GAAG,CAAC;EAC1B;EAEA,IAAAO,yBAAgB,EAACT,KAAK,EAAEC,MAAM,CAAC;EAE/B,OAAOD,KAAK;AACd","ignoreList":[]}

package/etc/mcp-server/node_modules/@babel/types/lib/modifications/prependToMemberExpression.js

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

package/etc/mcp-server/node_modules/@babel/types/lib/modifications/prependToMemberExpression.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","_index2","prependToMemberExpression","member","prepend","isSuper","object","Error","memberExpression"],"sources":["../../src/modifications/prependToMemberExpression.ts"],"sourcesContent":["import { memberExpression } from \"../builders/generated/index.ts\";\nimport { isSuper } from \"../index.ts\";\nimport type * as t from \"../index.ts\";\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,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AAMe,SAASE,yBAAyBA,CAE/CC,MAAS,EAAEC,OAAqC,EAAK;EACrD,IAAI,IAAAC,eAAO,EAACF,MAAM,CAACG,MAAM,CAAC,EAAE;IAC1B,MAAM,IAAIC,KAAK,CACb,6DACF,CAAC;EACH;EACAJ,MAAM,CAACG,MAAM,GAAG,IAAAE,uBAAgB,EAACJ,OAAO,EAAED,MAAM,CAACG,MAAM,CAAC;EAExD,OAAOH,MAAM;AACf","ignoreList":[]}

package/etc/mcp-server/node_modules/@babel/types/lib/modifications/removeProperties.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removeProperties;
+var _index = require("../constants/index.js");
+const CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
+const CLEAR_KEYS_PLUS_COMMENTS = [..._index.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.startsWith("_") && node[key] != null) node[key] = undefined;
+  }
+  const symbols = Object.getOwnPropertySymbols(node);
+  for (const sym of symbols) {
+    node[sym] = null;
+  }
+}
+
+//# sourceMappingURL=removeProperties.js.map

package/etc/mcp-server/node_modules/@babel/types/lib/modifications/removeProperties.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","CLEAR_KEYS","CLEAR_KEYS_PLUS_COMMENTS","COMMENT_KEYS","removeProperties","node","opts","map","preserveComments","key","undefined","Object","keys","startsWith","symbols","getOwnPropertySymbols","sym"],"sources":["../../src/modifications/removeProperties.ts"],"sourcesContent":["import { COMMENT_KEYS } from \"../constants/index.ts\";\nimport type * as t from \"../index.ts\";\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.startsWith(\"_\") && node[key] != null) node[key] = undefined;\n  }\n\n  const symbols: 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,IAAAA,MAAA,GAAAC,OAAA;AAGA,MAAMC,UAAU,GAAG,CACjB,QAAQ,EACR,OAAO,EACP,KAAK,EACL,KAAK,EAEL,KAAK,EACL,UAAU,CACF;AAEV,MAAMC,wBAAwB,GAAG,CAC/B,GAAGC,mBAAY,EACf,UAAU,EACV,GAAGF,UAAU,CACL;AAOK,SAASG,gBAAgBA,CACtCC,IAAY,EACZC,IAAa,GAAG,CAAC,CAAC,EACZ;EACN,MAAMC,GAAG,GAAGD,IAAI,CAACE,gBAAgB,GAAGP,UAAU,GAAGC,wBAAwB;EACzE,KAAK,MAAMO,GAAG,IAAIF,GAAG,EAAE;IAErB,IAAIF,IAAI,CAACI,GAAG,CAAC,IAAI,IAAI,EAAEJ,IAAI,CAACI,GAAG,CAAC,GAAGC,SAAS;EAC9C;EAEA,KAAK,MAAMD,GAAG,IAAIE,MAAM,CAACC,IAAI,CAACP,IAAI,CAAC,EAAE;IAEnC,IAAII,GAAG,CAACI,UAAU,CAAC,GAAG,CAAC,IAAIR,IAAI,CAACI,GAAG,CAAC,IAAI,IAAI,EAAEJ,IAAI,CAACI,GAAG,CAAC,GAAGC,SAAS;EACrE;EAEA,MAAMI,OAAiB,GAAGH,MAAM,CAACI,qBAAqB,CAACV,IAAI,CAAC;EAC5D,KAAK,MAAMW,GAAG,IAAIF,OAAO,EAAE;IAEzBT,IAAI,CAACW,GAAG,CAAC,GAAG,IAAI;EAClB;AACF","ignoreList":[]}

package/etc/mcp-server/node_modules/@babel/types/lib/modifications/removePropertiesDeep.js

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

package/etc/mcp-server/node_modules/@babel/types/lib/modifications/removePropertiesDeep.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_traverseFast","require","_removeProperties","removePropertiesDeep","tree","opts","traverseFast","removeProperties"],"sources":["../../src/modifications/removePropertiesDeep.ts"],"sourcesContent":["import traverseFast from \"../traverse/traverseFast.ts\";\nimport removeProperties from \"./removeProperties.ts\";\nimport type * as t from \"../index.ts\";\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,IAAAA,aAAA,GAAAC,OAAA;AACA,IAAAC,iBAAA,GAAAD,OAAA;AAGe,SAASE,oBAAoBA,CAC1CC,IAAO,EACPC,IAA2C,EACxC;EACH,IAAAC,qBAAY,EAACF,IAAI,EAAEG,yBAAgB,EAAEF,IAAI,CAAC;EAE1C,OAAOD,IAAI;AACb","ignoreList":[]}

package/etc/mcp-server/node_modules/@babel/types/lib/modifications/typescript/removeTypeDuplicates.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = removeTypeDuplicates;
+var _index = require("../../validators/generated/index.js");
+function getQualifiedName(node) {
+  return (0, _index.isIdentifier)(node) ? node.name : (0, _index.isThisExpression)(node) ? "this" : `${node.right.name}.${getQualifiedName(node.left)}`;
+}
+function removeTypeDuplicates(nodesIn) {
+  const nodes = Array.from(nodesIn);
+  const generics = new Map();
+  const bases = new Map();
+  const typeGroups = new Set();
+  const types = [];
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (!node) continue;
+    if (types.includes(node)) {
+      continue;
+    }
+    if ((0, _index.isTSAnyKeyword)(node)) {
+      return [node];
+    }
+    if ((0, _index.isTSBaseType)(node)) {
+      bases.set(node.type, node);
+      continue;
+    }
+    if ((0, _index.isTSUnionType)(node)) {
+      if (!typeGroups.has(node.types)) {
+        nodes.push(...node.types);
+        typeGroups.add(node.types);
+      }
+      continue;
+    }
+    const typeArgumentsKey = "typeParameters";
+    if ((0, _index.isTSTypeReference)(node) && node[typeArgumentsKey]) {
+      const typeArguments = node[typeArgumentsKey];
+      const name = getQualifiedName(node.typeName);
+      if (generics.has(name)) {
+        let existing = generics.get(name);
+        const existingTypeArguments = existing[typeArgumentsKey];
+        if (existingTypeArguments) {
+          existingTypeArguments.params.push(...typeArguments.params);
+          existingTypeArguments.params = removeTypeDuplicates(existingTypeArguments.params);
+        } else {
+          existing = typeArguments;
+        }
+      } 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/etc/mcp-server/node_modules/@babel/types/lib/modifications/typescript/removeTypeDuplicates.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","getQualifiedName","node","isIdentifier","name","isThisExpression","right","left","removeTypeDuplicates","nodesIn","nodes","Array","from","generics","Map","bases","typeGroups","Set","types","i","length","includes","isTSAnyKeyword","isTSBaseType","set","type","isTSUnionType","has","push","add","typeArgumentsKey","isTSTypeReference","typeArguments","typeName","existing","get","existingTypeArguments","params","baseType","genericName"],"sources":["../../../src/modifications/typescript/removeTypeDuplicates.ts"],"sourcesContent":["import {\n  isIdentifier,\n  isThisExpression,\n  isTSAnyKeyword,\n  isTSTypeReference,\n  isTSUnionType,\n  isTSBaseType,\n} from \"../../validators/generated/index.ts\";\nimport type * as t from \"../../index.ts\";\n\nfunction getQualifiedName(node: t.TSTypeReference[\"typeName\"]): string {\n  return isIdentifier(node)\n    ? node.name\n    : isThisExpression(node)\n      ? \"this\"\n      : `${node.right.name}.${getQualifiedName(node.left)}`;\n}\n\n/**\n * Dedupe type annotations.\n */\nexport default function removeTypeDuplicates(\n  nodesIn: readonly t.TSType[],\n): t.TSType[] {\n  const nodes = Array.from(nodesIn);\n\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.includes(node)) {\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    const typeArgumentsKey = process.env.BABEL_8_BREAKING\n      ? \"typeArguments\"\n      : \"typeParameters\";\n    // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST\n    if (isTSTypeReference(node) && node[typeArgumentsKey]) {\n      // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST\n      const typeArguments = node[typeArgumentsKey];\n      const name = getQualifiedName(node.typeName);\n\n      if (generics.has(name)) {\n        let existing: t.TypeScript = generics.get(name);\n        // @ts-ignore(Babel 7 vs Babel 8) Babel 8 AST\n        const existingTypeArguments = existing[typeArgumentsKey];\n        if (existingTypeArguments) {\n          existingTypeArguments.params.push(...typeArguments.params);\n          existingTypeArguments.params = removeTypeDuplicates(\n            existingTypeArguments.params,\n          );\n        } else {\n          existing = typeArguments;\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":"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","ignoreList":[]}

package/etc/mcp-server/node_modules/@babel/types/lib/retrievers/getAssignmentIdentifiers.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getAssignmentIdentifiers;
+function getAssignmentIdentifiers(node) {
+  const search = [].concat(node);
+  const ids = Object.create(null);
+  while (search.length) {
+    const id = search.pop();
+    if (!id) continue;
+    switch (id.type) {
+      case "ArrayPattern":
+        search.push(...id.elements);
+        break;
+      case "AssignmentExpression":
+      case "AssignmentPattern":
+      case "ForInStatement":
+      case "ForOfStatement":
+        search.push(id.left);
+        break;
+      case "ObjectPattern":
+        search.push(...id.properties);
+        break;
+      case "ObjectProperty":
+        search.push(id.value);
+        break;
+      case "RestElement":
+      case "UpdateExpression":
+        search.push(id.argument);
+        break;
+      case "UnaryExpression":
+        if (id.operator === "delete") {
+          search.push(id.argument);
+        }
+        break;
+      case "Identifier":
+        ids[id.name] = id;
+        break;
+      default:
+        break;
+    }
+  }
+  return ids;
+}
+
+//# sourceMappingURL=getAssignmentIdentifiers.js.map

package/etc/mcp-server/node_modules/@babel/types/lib/retrievers/getAssignmentIdentifiers.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getAssignmentIdentifiers","node","search","concat","ids","Object","create","length","id","pop","type","push","elements","left","properties","value","argument","operator","name"],"sources":["../../src/retrievers/getAssignmentIdentifiers.ts"],"sourcesContent":["import type * as t from \"../index.ts\";\n\n/**\n * For the given node, generate a map from assignment id names to the identifier node.\n * Unlike getBindingIdentifiers, this function does not handle declarations and imports.\n * @param node the assignment expression or forXstatement\n * @returns an object map\n * @see getBindingIdentifiers\n */\nexport default function getAssignmentIdentifiers(\n  node: t.Node | t.Node[],\n): Record<string, t.Identifier> {\n  // null represents holes in an array pattern\n  const search: (t.Node | null)[] = [].concat(node);\n  const ids = Object.create(null);\n\n  while (search.length) {\n    const id = search.pop();\n    if (!id) continue;\n\n    switch (id.type) {\n      case \"ArrayPattern\":\n        search.push(...id.elements);\n        break;\n\n      case \"AssignmentExpression\":\n      case \"AssignmentPattern\":\n      case \"ForInStatement\":\n      case \"ForOfStatement\":\n        search.push(id.left);\n        break;\n\n      case \"ObjectPattern\":\n        search.push(...id.properties);\n        break;\n\n      case \"ObjectProperty\":\n        search.push(id.value);\n        break;\n\n      case \"RestElement\":\n      case \"UpdateExpression\":\n        search.push(id.argument);\n        break;\n\n      case \"UnaryExpression\":\n        if (id.operator === \"delete\") {\n          search.push(id.argument);\n        }\n        break;\n\n      case \"Identifier\":\n        ids[id.name] = id;\n        break;\n\n      default:\n        break;\n    }\n  }\n\n  return ids;\n}\n"],"mappings":";;;;;;AASe,SAASA,wBAAwBA,CAC9CC,IAAuB,EACO;EAE9B,MAAMC,MAAyB,GAAG,EAAE,CAACC,MAAM,CAACF,IAAI,CAAC;EACjD,MAAMG,GAAG,GAAGC,MAAM,CAACC,MAAM,CAAC,IAAI,CAAC;EAE/B,OAAOJ,MAAM,CAACK,MAAM,EAAE;IACpB,MAAMC,EAAE,GAAGN,MAAM,CAACO,GAAG,CAAC,CAAC;IACvB,IAAI,CAACD,EAAE,EAAE;IAET,QAAQA,EAAE,CAACE,IAAI;MACb,KAAK,cAAc;QACjBR,MAAM,CAACS,IAAI,CAAC,GAAGH,EAAE,CAACI,QAAQ,CAAC;QAC3B;MAEF,KAAK,sBAAsB;MAC3B,KAAK,mBAAmB;MACxB,KAAK,gBAAgB;MACrB,KAAK,gBAAgB;QACnBV,MAAM,CAACS,IAAI,CAACH,EAAE,CAACK,IAAI,CAAC;QACpB;MAEF,KAAK,eAAe;QAClBX,MAAM,CAACS,IAAI,CAAC,GAAGH,EAAE,CAACM,UAAU,CAAC;QAC7B;MAEF,KAAK,gBAAgB;QACnBZ,MAAM,CAACS,IAAI,CAACH,EAAE,CAACO,KAAK,CAAC;QACrB;MAEF,KAAK,aAAa;MAClB,KAAK,kBAAkB;QACrBb,MAAM,CAACS,IAAI,CAACH,EAAE,CAACQ,QAAQ,CAAC;QACxB;MAEF,KAAK,iBAAiB;QACpB,IAAIR,EAAE,CAACS,QAAQ,KAAK,QAAQ,EAAE;UAC5Bf,MAAM,CAACS,IAAI,CAACH,EAAE,CAACQ,QAAQ,CAAC;QAC1B;QACA;MAEF,KAAK,YAAY;QACfZ,GAAG,CAACI,EAAE,CAACU,IAAI,CAAC,GAAGV,EAAE;QACjB;MAEF;QACE;IACJ;EACF;EAEA,OAAOJ,GAAG;AACZ","ignoreList":[]}

package/etc/mcp-server/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getBindingIdentifiers;
+var _index = require("../validators/generated/index.js");
+function getBindingIdentifiers(node, duplicates, outerOnly, newBindingsOnly) {
+  const search = [].concat(node);
+  const ids = Object.create(null);
+  while (search.length) {
+    const id = search.shift();
+    if (!id) continue;
+    if (newBindingsOnly && ((0, _index.isAssignmentExpression)(id) || (0, _index.isUnaryExpression)(id) || (0, _index.isUpdateExpression)(id))) {
+      continue;
+    }
+    if ((0, _index.isIdentifier)(id)) {
+      if (duplicates) {
+        const _ids = ids[id.name] = ids[id.name] || [];
+        _ids.push(id);
+      } else {
+        ids[id.name] = id;
+      }
+      continue;
+    }
+    if ((0, _index.isExportDeclaration)(id) && !(0, _index.isExportAllDeclaration)(id)) {
+      if ((0, _index.isDeclaration)(id.declaration)) {
+        search.push(id.declaration);
+      }
+      continue;
+    }
+    if (outerOnly) {
+      if ((0, _index.isFunctionDeclaration)(id)) {
+        search.push(id.id);
+        continue;
+      }
+      if ((0, _index.isFunctionExpression)(id)) {
+        continue;
+      }
+    }
+    const keys = getBindingIdentifiers.keys[id.type];
+    if (keys) {
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const nodes = id[key];
+        if (nodes) {
+          if (Array.isArray(nodes)) {
+            search.push(...nodes);
+          } else {
+            search.push(nodes);
+          }
+        }
+      }
+    }
+  }
+  return ids;
+}
+const 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"],
+  TSImportEqualsDeclaration: ["id"],
+  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"]
+};
+getBindingIdentifiers.keys = keys;
+
+//# sourceMappingURL=getBindingIdentifiers.js.map

package/etc/mcp-server/node_modules/@babel/types/lib/retrievers/getBindingIdentifiers.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","getBindingIdentifiers","node","duplicates","outerOnly","newBindingsOnly","search","concat","ids","Object","create","length","id","shift","isAssignmentExpression","isUnaryExpression","isUpdateExpression","isIdentifier","_ids","name","push","isExportDeclaration","isExportAllDeclaration","isDeclaration","declaration","isFunctionDeclaration","isFunctionExpression","keys","type","i","key","nodes","Array","isArray","DeclareClass","DeclareFunction","DeclareModule","DeclareVariable","DeclareInterface","DeclareTypeAlias","DeclareOpaqueType","InterfaceDeclaration","TypeAlias","OpaqueType","CatchClause","LabeledStatement","UnaryExpression","AssignmentExpression","ImportSpecifier","ImportNamespaceSpecifier","ImportDefaultSpecifier","ImportDeclaration","TSImportEqualsDeclaration","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  isClassExpression,\n  isDeclaration,\n  isFunctionDeclaration,\n  isFunctionExpression,\n  isExportAllDeclaration,\n  isAssignmentExpression,\n  isUnaryExpression,\n  isUpdateExpression,\n} from \"../validators/generated/index.ts\";\nimport type * as t from \"../index.ts\";\n\nexport { getBindingIdentifiers as default };\n\nfunction getBindingIdentifiers(\n  node: t.Node,\n  duplicates: true,\n  outerOnly?: boolean,\n  newBindingsOnly?: boolean,\n): Record<string, t.Identifier[]>;\n\nfunction getBindingIdentifiers(\n  node: t.Node,\n  duplicates?: false,\n  outerOnly?: boolean,\n  newBindingsOnly?: boolean,\n): Record<string, t.Identifier>;\n\nfunction getBindingIdentifiers(\n  node: t.Node,\n  duplicates?: boolean,\n  outerOnly?: boolean,\n  newBindingsOnly?: boolean,\n): Record<string, t.Identifier> | Record<string, 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  newBindingsOnly?: boolean,\n): Record<string, t.Identifier> | Record<string, 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    if (\n      newBindingsOnly &&\n      // These nodes do not introduce _new_ bindings, but they are included\n      // in getBindingIdentifiers.keys for backwards compatibility.\n      // TODO(@nicolo-ribaudo): Check if we can remove them from .keys in a\n      // backward-compatible way, and if not what we need to do to remove them\n      // in Babel 8.\n      (isAssignmentExpression(id) ||\n        isUnaryExpression(id) ||\n        isUpdateExpression(id))\n    ) {\n      continue;\n    }\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 (\n        isFunctionExpression(id) ||\n        (process.env.BABEL_8_BREAKING && isClassExpression(id))\n      ) {\n        continue;\n      }\n    }\n\n    const keys = getBindingIdentifiers.keys[id.type];\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          if (Array.isArray(nodes)) {\n            search.push(...nodes);\n          } else {\n            search.push(nodes);\n          }\n        }\n      }\n    }\n  }\n  return ids;\n}\n\n/**\n * Mapping of types to their identifier keys.\n */\ntype KeysMap = {\n  [N in t.Node as N[\"type\"]]?: (keyof N)[];\n};\n\nconst keys: KeysMap = {\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  TSImportEqualsDeclaration: [\"id\"],\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\ngetBindingIdentifiers.keys = keys;\n"],"mappings":"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","ignoreList":[]}

package/etc/mcp-server/node_modules/@babel/types/lib/retrievers/getFunctionName.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getFunctionName;
+var _index = require("../validators/generated/index.js");
+function getNameFromLiteralId(id) {
+  if ((0, _index.isNullLiteral)(id)) {
+    return "null";
+  }
+  if ((0, _index.isRegExpLiteral)(id)) {
+    return `/${id.pattern}/${id.flags}`;
+  }
+  if ((0, _index.isTemplateLiteral)(id)) {
+    return id.quasis.map(quasi => quasi.value.raw).join("");
+  }
+  if (id.value !== undefined) {
+    return String(id.value);
+  }
+  return null;
+}
+function getObjectMemberKey(node) {
+  if (!node.computed || (0, _index.isLiteral)(node.key)) {
+    return node.key;
+  }
+}
+function getFunctionName(node, parent) {
+  if ("id" in node && node.id) {
+    return {
+      name: node.id.name,
+      originalNode: node.id
+    };
+  }
+  let prefix = "";
+  let id;
+  if ((0, _index.isObjectProperty)(parent, {
+    value: node
+  })) {
+    id = getObjectMemberKey(parent);
+  } else if ((0, _index.isObjectMethod)(node) || (0, _index.isClassMethod)(node)) {
+    id = getObjectMemberKey(node);
+    if (node.kind === "get") prefix = "get ";else if (node.kind === "set") prefix = "set ";
+  } else if ((0, _index.isVariableDeclarator)(parent, {
+    init: node
+  })) {
+    id = parent.id;
+  } else if ((0, _index.isAssignmentExpression)(parent, {
+    operator: "=",
+    right: node
+  })) {
+    id = parent.left;
+  }
+  if (!id) return null;
+  const name = (0, _index.isLiteral)(id) ? getNameFromLiteralId(id) : (0, _index.isIdentifier)(id) ? id.name : (0, _index.isPrivateName)(id) ? id.id.name : null;
+  if (name == null) return null;
+  return {
+    name: prefix + name,
+    originalNode: id
+  };
+}
+
+//# sourceMappingURL=getFunctionName.js.map

package/etc/mcp-server/node_modules/@babel/types/lib/retrievers/getFunctionName.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","getNameFromLiteralId","id","isNullLiteral","isRegExpLiteral","pattern","flags","isTemplateLiteral","quasis","map","quasi","value","raw","join","undefined","String","getObjectMemberKey","node","computed","isLiteral","key","getFunctionName","parent","name","originalNode","prefix","isObjectProperty","isObjectMethod","isClassMethod","kind","isVariableDeclarator","init","isAssignmentExpression","operator","right","left","isIdentifier","isPrivateName"],"sources":["../../src/retrievers/getFunctionName.ts"],"sourcesContent":["import type * as t from \"../index.ts\";\n\nimport {\n  isAssignmentExpression,\n  isClassMethod,\n  isIdentifier,\n  isLiteral,\n  isNullLiteral,\n  isObjectMethod,\n  isObjectProperty,\n  isPrivateName,\n  isRegExpLiteral,\n  isTemplateLiteral,\n  isVariableDeclarator,\n} from \"../validators/generated/index.ts\";\n\nfunction getNameFromLiteralId(id: t.Literal): string {\n  if (isNullLiteral(id)) {\n    return \"null\";\n  }\n\n  if (isRegExpLiteral(id)) {\n    return `/${id.pattern}/${id.flags}`;\n  }\n\n  if (isTemplateLiteral(id)) {\n    return id.quasis.map(quasi => quasi.value.raw).join(\"\");\n  }\n\n  if (id.value !== undefined) {\n    return String(id.value);\n  }\n\n  return null;\n}\n\nfunction getObjectMemberKey(\n  node: t.ObjectProperty | t.ObjectMethod | t.ClassProperty | t.ClassMethod,\n): t.Expression | t.PrivateName {\n  if (!node.computed || isLiteral(node.key)) {\n    return node.key;\n  }\n}\n\ntype GetFunctionNameResult = {\n  name: string;\n  originalNode: t.Node;\n} | null;\n\nexport default function getFunctionName(\n  node: t.ObjectMethod | t.ClassMethod,\n): GetFunctionNameResult;\nexport default function getFunctionName(\n  node: t.Function | t.Class,\n  parent: t.Node,\n): GetFunctionNameResult;\nexport default function getFunctionName(\n  node: t.Function | t.Class,\n  parent?: t.Node,\n): GetFunctionNameResult {\n  if (\"id\" in node && node.id) {\n    return {\n      name: node.id.name,\n      originalNode: node.id,\n    };\n  }\n\n  let prefix = \"\";\n\n  let id;\n  if (isObjectProperty(parent, { value: node })) {\n    // { foo: () => {} };\n    id = getObjectMemberKey(parent);\n  } else if (isObjectMethod(node) || isClassMethod(node)) {\n    // { foo() {} };\n    id = getObjectMemberKey(node);\n    if (node.kind === \"get\") prefix = \"get \";\n    else if (node.kind === \"set\") prefix = \"set \";\n  } else if (isVariableDeclarator(parent, { init: node })) {\n    // let foo = function () {};\n    id = parent.id;\n  } else if (isAssignmentExpression(parent, { operator: \"=\", right: node })) {\n    // foo = function () {};\n    id = parent.left;\n  }\n\n  if (!id) return null;\n\n  const name = isLiteral(id)\n    ? getNameFromLiteralId(id)\n    : isIdentifier(id)\n      ? id.name\n      : isPrivateName(id)\n        ? id.id.name\n        : null;\n  if (name == null) return null;\n\n  return { name: prefix + name, originalNode: id };\n}\n"],"mappings":";;;;;;AAEA,IAAAA,MAAA,GAAAC,OAAA;AAcA,SAASC,oBAAoBA,CAACC,EAAa,EAAU;EACnD,IAAI,IAAAC,oBAAa,EAACD,EAAE,CAAC,EAAE;IACrB,OAAO,MAAM;EACf;EAEA,IAAI,IAAAE,sBAAe,EAACF,EAAE,CAAC,EAAE;IACvB,OAAO,IAAIA,EAAE,CAACG,OAAO,IAAIH,EAAE,CAACI,KAAK,EAAE;EACrC;EAEA,IAAI,IAAAC,wBAAiB,EAACL,EAAE,CAAC,EAAE;IACzB,OAAOA,EAAE,CAACM,MAAM,CAACC,GAAG,CAACC,KAAK,IAAIA,KAAK,CAACC,KAAK,CAACC,GAAG,CAAC,CAACC,IAAI,CAAC,EAAE,CAAC;EACzD;EAEA,IAAIX,EAAE,CAACS,KAAK,KAAKG,SAAS,EAAE;IAC1B,OAAOC,MAAM,CAACb,EAAE,CAACS,KAAK,CAAC;EACzB;EAEA,OAAO,IAAI;AACb;AAEA,SAASK,kBAAkBA,CACzBC,IAAyE,EAC3C;EAC9B,IAAI,CAACA,IAAI,CAACC,QAAQ,IAAI,IAAAC,gBAAS,EAACF,IAAI,CAACG,GAAG,CAAC,EAAE;IACzC,OAAOH,IAAI,CAACG,GAAG;EACjB;AACF;AAce,SAASC,eAAeA,CACrCJ,IAA0B,EAC1BK,MAAe,EACQ;EACvB,IAAI,IAAI,IAAIL,IAAI,IAAIA,IAAI,CAACf,EAAE,EAAE;IAC3B,OAAO;MACLqB,IAAI,EAAEN,IAAI,CAACf,EAAE,CAACqB,IAAI;MAClBC,YAAY,EAAEP,IAAI,CAACf;IACrB,CAAC;EACH;EAEA,IAAIuB,MAAM,GAAG,EAAE;EAEf,IAAIvB,EAAE;EACN,IAAI,IAAAwB,uBAAgB,EAACJ,MAAM,EAAE;IAAEX,KAAK,EAAEM;EAAK,CAAC,CAAC,EAAE;IAE7Cf,EAAE,GAAGc,kBAAkB,CAACM,MAAM,CAAC;EACjC,CAAC,MAAM,IAAI,IAAAK,qBAAc,EAACV,IAAI,CAAC,IAAI,IAAAW,oBAAa,EAACX,IAAI,CAAC,EAAE;IAEtDf,EAAE,GAAGc,kBAAkB,CAACC,IAAI,CAAC;IAC7B,IAAIA,IAAI,CAACY,IAAI,KAAK,KAAK,EAAEJ,MAAM,GAAG,MAAM,CAAC,KACpC,IAAIR,IAAI,CAACY,IAAI,KAAK,KAAK,EAAEJ,MAAM,GAAG,MAAM;EAC/C,CAAC,MAAM,IAAI,IAAAK,2BAAoB,EAACR,MAAM,EAAE;IAAES,IAAI,EAAEd;EAAK,CAAC,CAAC,EAAE;IAEvDf,EAAE,GAAGoB,MAAM,CAACpB,EAAE;EAChB,CAAC,MAAM,IAAI,IAAA8B,6BAAsB,EAACV,MAAM,EAAE;IAAEW,QAAQ,EAAE,GAAG;IAAEC,KAAK,EAAEjB;EAAK,CAAC,CAAC,EAAE;IAEzEf,EAAE,GAAGoB,MAAM,CAACa,IAAI;EAClB;EAEA,IAAI,CAACjC,EAAE,EAAE,OAAO,IAAI;EAEpB,MAAMqB,IAAI,GAAG,IAAAJ,gBAAS,EAACjB,EAAE,CAAC,GACtBD,oBAAoB,CAACC,EAAE,CAAC,GACxB,IAAAkC,mBAAY,EAAClC,EAAE,CAAC,GACdA,EAAE,CAACqB,IAAI,GACP,IAAAc,oBAAa,EAACnC,EAAE,CAAC,GACfA,EAAE,CAACA,EAAE,CAACqB,IAAI,GACV,IAAI;EACZ,IAAIA,IAAI,IAAI,IAAI,EAAE,OAAO,IAAI;EAE7B,OAAO;IAAEA,IAAI,EAAEE,MAAM,GAAGF,IAAI;IAAEC,YAAY,EAAEtB;EAAG,CAAC;AAClD","ignoreList":[]}

package/etc/mcp-server/node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js

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

package/etc/mcp-server/node_modules/@babel/types/lib/retrievers/getOuterBindingIdentifiers.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_getBindingIdentifiers","require","_default","exports","default","getOuterBindingIdentifiers","node","duplicates","getBindingIdentifiers"],"sources":["../../src/retrievers/getOuterBindingIdentifiers.ts"],"sourcesContent":["import getBindingIdentifiers from \"./getBindingIdentifiers.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default getOuterBindingIdentifiers as {\n  (node: t.Node, duplicates: true): Record<string, t.Identifier[]>;\n  (node: t.Node, duplicates?: false): Record<string, t.Identifier>;\n  (\n    node: t.Node,\n    duplicates?: boolean,\n  ): Record<string, t.Identifier> | Record<string, t.Identifier[]>;\n};\n\nfunction getOuterBindingIdentifiers(\n  node: t.Node,\n  duplicates: boolean,\n): Record<string, t.Identifier> | Record<string, t.Identifier[]> {\n  return getBindingIdentifiers(node, duplicates, true);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,sBAAA,GAAAC,OAAA;AAA+D,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAGhDC,0BAA0B;AASzC,SAASA,0BAA0BA,CACjCC,IAAY,EACZC,UAAmB,EAC4C;EAC/D,OAAO,IAAAC,8BAAqB,EAACF,IAAI,EAAEC,UAAU,EAAE,IAAI,CAAC;AACtD","ignoreList":[]}