Brunobkr/llama.cpp_AlgMor24_github

1import { declare } from '@babel/helper-plugin-utils';2import _getTargets, { prettifyTargets, getInclusionReasons, isRequired } from '@babel/helper-compilation-targets';3import * as _babel from '@babel/core';4import path from 'path';5import debounce from 'lodash.debounce';6import requireResolve from 'resolve';7import { createRequire } from 'module';8 9const {10  types: t$1,11  template: template12} = _babel.default || _babel;13const PossibleGlobalObjects = new Set(["global", "globalThis", "self", "window"]);14function intersection(a, b) {15  const result = new Set();16  a.forEach(v => b.has(v) && result.add(v));17  return result;18}19function has$1(object, key) {20  return Object.prototype.hasOwnProperty.call(object, key);21}22function resolve$1(path, seen = new Set()) {23  if (seen.has(path)) return;24  seen.add(path);25  if (path.isVariableDeclarator()) {26    if (path.get("id").isIdentifier()) {27      return resolve$1(path.get("init"), seen);28    }29  } else if (path.isReferencedIdentifier()) {30    const binding = path.scope.getBinding(path.node.name);31    if (!binding) return path;32    if (!binding.constant) return;33    return resolve$1(binding.path, seen);34  }35  return path;36}37function resolveId(path) {38  if (path.isIdentifier() && !path.scope.hasBinding(path.node.name, /* noGlobals */true)) {39    return path.node.name;40  }41 42  // globalThis.Object / window.Array / self.Map / global.Set -> resolve to43  // the property name, because accessing a built-in through a global object44  // reference is equivalent to accessing it directly.45  if (path.isMemberExpression() && !path.node.computed) {46    const object = path.get("object");47    const property = path.get("property");48    if (object.isIdentifier() && !object.scope.hasBinding(object.node.name, /* noGlobals */true) && PossibleGlobalObjects.has(object.node.name) && property.isIdentifier()) {49      return property.node.name;50    }51  }52  const resolved = resolve$1(path);53  if (resolved != null && resolved.isIdentifier()) {54    return resolved.node.name;55  }56}57function resolveKey(path, computed = false) {58  const {59    scope60  } = path;61  if (path.isStringLiteral()) return path.node.value;62  const isIdentifier = path.isIdentifier();63  if (isIdentifier && !(computed || path.parent.computed)) {64    return path.node.name;65  }66  if (computed && path.isMemberExpression() && path.get("object").isIdentifier({67    name: "Symbol"68  }) && !scope.hasBinding("Symbol", /* noGlobals */true)) {69    const sym = resolveKey(path.get("property"), path.node.computed);70    if (sym) return "Symbol." + sym;71  }72  if (isIdentifier ? scope.hasBinding(path.node.name, /* noGlobals */true) : path.isPure()) {73    const {74      value75    } = path.evaluate();76    if (typeof value === "string") return value;77  }78}79function resolveInstance(obj, seen) {80  const source = resolveSource(obj, seen);81  return source.placement === "prototype" ? source.id : null;82}83function resolveSource(obj, seen) {84  if (seen.has(obj)) {85    return {86      id: null,87      placement: null88    };89  }90  seen.add(obj);91  if (obj.isMemberExpression() && obj.get("property").isIdentifier({92    name: "prototype"93  })) {94    const id = resolveId(obj.get("object"));95    if (id) {96      return {97        id,98        placement: "prototype"99      };100    }101    return {102      id: null,103      placement: null104    };105  }106  const id = resolveId(obj);107  if (id) {108    return {109      id,110      placement: "static"111    };112  }113  const path = resolve$1(obj);114  switch (path == null ? void 0 : path.type) {115    case "NullLiteral":116      return {117        id: null,118        placement: null119      };120    case "RegExpLiteral":121      return {122        id: "RegExp",123        placement: "prototype"124      };125    case "StringLiteral":126    case "TemplateLiteral":127      return {128        id: "String",129        placement: "prototype"130      };131    case "NumericLiteral":132      return {133        id: "Number",134        placement: "prototype"135      };136    case "BooleanLiteral":137      return {138        id: "Boolean",139        placement: "prototype"140      };141    case "BigIntLiteral":142      return {143        id: "BigInt",144        placement: "prototype"145      };146    case "ObjectExpression":147      return {148        id: "Object",149        placement: "prototype"150      };151    case "ArrayExpression":152      return {153        id: "Array",154        placement: "prototype"155      };156    case "FunctionExpression":157    case "ArrowFunctionExpression":158    case "ClassExpression":159      return {160        id: "Function",161        placement: "prototype"162      };163    // new Constructor() -> resolve the constructor name164    case "NewExpression":165      {166        const calleeId = resolveId(path.get("callee"));167        if (calleeId) return {168          id: calleeId,169          placement: "prototype"170        };171        return {172          id: null,173          placement: null174        };175      }176    // Unary expressions -> result type depends on operator177    case "UnaryExpression":178      {179        const {180          operator181        } = path.node;182        if (operator === "typeof") return {183          id: "String",184          placement: "prototype"185        };186        if (operator === "!" || operator === "delete") return {187          id: "Boolean",188          placement: "prototype"189        };190        // Unary + always produces Number (throws on BigInt)191        if (operator === "+") return {192          id: "Number",193          placement: "prototype"194        };195        // Unary - and ~ can produce Number or BigInt depending on operand196        if (operator === "-" || operator === "~") {197          const arg = resolveInstance(path.get("argument"), seen);198          if (arg === "BigInt") return {199            id: "BigInt",200            placement: "prototype"201          };202          if (arg !== null) return {203            id: "Number",204            placement: "prototype"205          };206          return {207            id: null,208            placement: null209          };210        }211        return {212          id: null,213          placement: null214        };215      }216    // ++i, i++ produce Number or BigInt depending on the argument217    case "UpdateExpression":218      {219        const arg = resolveInstance(path.get("argument"), seen);220        if (arg === "BigInt") return {221          id: "BigInt",222          placement: "prototype"223        };224        if (arg !== null) return {225          id: "Number",226          placement: "prototype"227        };228        return {229          id: null,230          placement: null231        };232      }233    // Binary expressions -> result type depends on operator234    case "BinaryExpression":235      {236        const {237          operator238        } = path.node;239        if (operator === "==" || operator === "!=" || operator === "===" || operator === "!==" || operator === "<" || operator === ">" || operator === "<=" || operator === ">=" || operator === "instanceof" || operator === "in") {240          return {241            id: "Boolean",242            placement: "prototype"243          };244        }245        // >>> always produces Number246        if (operator === ">>>") {247          return {248            id: "Number",249            placement: "prototype"250          };251        }252        // Arithmetic and bitwise operators can produce Number or BigInt253        if (operator === "-" || operator === "*" || operator === "/" || operator === "%" || operator === "**" || operator === "&" || operator === "|" || operator === "^" || operator === "<<" || operator === ">>") {254          const left = resolveInstance(path.get("left"), seen);255          const right = resolveInstance(path.get("right"), seen);256          if (left === "BigInt" && right === "BigInt") {257            return {258              id: "BigInt",259              placement: "prototype"260            };261          }262          if (left !== null && right !== null) {263            return {264              id: "Number",265              placement: "prototype"266            };267          }268          return {269            id: null,270            placement: null271          };272        }273        // + depends on operand types: string wins, otherwise number or bigint274        if (operator === "+") {275          const left = resolveInstance(path.get("left"), seen);276          const right = resolveInstance(path.get("right"), seen);277          if (left === "String" || right === "String") {278            return {279              id: "String",280              placement: "prototype"281            };282          }283          if (left === "Number" && right === "Number") {284            return {285              id: "Number",286              placement: "prototype"287            };288          }289          if (left === "BigInt" && right === "BigInt") {290            return {291              id: "BigInt",292              placement: "prototype"293            };294          }295        }296        return {297          id: null,298          placement: null299        };300      }301    // (a, b, c) -> the result is the last expression302    case "SequenceExpression":303      {304        const expressions = path.get("expressions");305        return resolveSource(expressions[expressions.length - 1], seen);306      }307    // a = b -> the result is the right side308    case "AssignmentExpression":309      {310        if (path.node.operator === "=") {311          return resolveSource(path.get("right"), seen);312        }313        return {314          id: null,315          placement: null316        };317      }318    // a ? b : c -> if both branches resolve to the same type, use it319    case "ConditionalExpression":320      {321        const consequent = resolveSource(path.get("consequent"), seen);322        const alternate = resolveSource(path.get("alternate"), seen);323        if (consequent.id && consequent.id === alternate.id) {324          return consequent;325        }326        return {327          id: null,328          placement: null329        };330      }331    // (expr) -> unwrap parenthesized expressions332    case "ParenthesizedExpression":333      return resolveSource(path.get("expression"), seen);334    // TypeScript / Flow type wrappers -> unwrap to the inner expression335    case "TSAsExpression":336    case "TSSatisfiesExpression":337    case "TSNonNullExpression":338    case "TSInstantiationExpression":339    case "TSTypeAssertion":340    case "TypeCastExpression":341      return resolveSource(path.get("expression"), seen);342  }343  return {344    id: null,345    placement: null346  };347}348function getImportSource({349  node350}) {351  if (node.specifiers.length === 0) return node.source.value;352}353function getRequireSource({354  node355}) {356  if (!t$1.isExpressionStatement(node)) return;357  const {358    expression359  } = node;360  if (t$1.isCallExpression(expression) && t$1.isIdentifier(expression.callee) && expression.callee.name === "require" && expression.arguments.length === 1 && t$1.isStringLiteral(expression.arguments[0])) {361    return expression.arguments[0].value;362  }363}364function hoist(node) {365  // @ts-expect-error366  node._blockHoist = 3;367  return node;368}369function createUtilsGetter(cache) {370  return path => {371    const prog = path.findParent(p => p.isProgram());372    return {373      injectGlobalImport(url, moduleName) {374        cache.storeAnonymous(prog, url, moduleName, (isScript, source) => {375          return isScript ? template.statement.ast`require(${source})` : t$1.importDeclaration([], source);376        });377      },378      injectNamedImport(url, name, hint = name, moduleName) {379        return cache.storeNamed(prog, url, name, moduleName, (isScript, source, name) => {380          const id = prog.scope.generateUidIdentifier(hint);381          return {382            node: isScript ? hoist(template.statement.ast`383                  var ${id} = require(${source}).${name}384                `) : t$1.importDeclaration([t$1.importSpecifier(id, name)], source),385            name: id.name386          };387        });388      },389      injectDefaultImport(url, hint = url, moduleName) {390        return cache.storeNamed(prog, url, "default", moduleName, (isScript, source) => {391          const id = prog.scope.generateUidIdentifier(hint);392          return {393            node: isScript ? hoist(template.statement.ast`var ${id} = require(${source})`) : t$1.importDeclaration([t$1.importDefaultSpecifier(id)], source),394            name: id.name395          };396        });397      }398    };399  };400}401 402const {403  types: t404} = _babel.default || _babel;405class ImportsCachedInjector {406  constructor(resolver, getPreferredIndex) {407    this._imports = new WeakMap();408    this._anonymousImports = new WeakMap();409    this._lastImports = new WeakMap();410    this._resolver = resolver;411    this._getPreferredIndex = getPreferredIndex;412  }413  storeAnonymous(programPath, url, moduleName, getVal) {414    const key = this._normalizeKey(programPath, url);415    const imports = this._ensure(this._anonymousImports, programPath, Set);416    if (imports.has(key)) return;417    const node = getVal(programPath.node.sourceType === "script", t.stringLiteral(this._resolver(url)));418    imports.add(key);419    this._injectImport(programPath, node, moduleName);420  }421  storeNamed(programPath, url, name, moduleName, getVal) {422    const key = this._normalizeKey(programPath, url, name);423    const imports = this._ensure(this._imports, programPath, Map);424    if (!imports.has(key)) {425      const {426        node,427        name: id428      } = getVal(programPath.node.sourceType === "script", t.stringLiteral(this._resolver(url)), t.identifier(name));429      imports.set(key, id);430      this._injectImport(programPath, node, moduleName);431    }432    return t.identifier(imports.get(key));433  }434  _injectImport(programPath, node, moduleName) {435    var _this$_lastImports$ge;436    const newIndex = this._getPreferredIndex(moduleName);437    const lastImports = (_this$_lastImports$ge = this._lastImports.get(programPath)) != null ? _this$_lastImports$ge : [];438    const isPathStillValid = path => path.node &&439    // Sometimes the AST is modified and the "last import"440    // we have has been replaced441    path.parent === programPath.node && path.container === programPath.node.body;442    let last;443    if (newIndex === Infinity) {444      // Fast path: we can always just insert at the end if newIndex is `Infinity`445      if (lastImports.length > 0) {446        last = lastImports[lastImports.length - 1].path;447        if (!isPathStillValid(last)) last = undefined;448      }449    } else {450      for (const [i, data] of lastImports.entries()) {451        const {452          path,453          index454        } = data;455        if (isPathStillValid(path)) {456          if (newIndex < index) {457            const [newPath] = path.insertBefore(node);458            lastImports.splice(i, 0, {459              path: newPath,460              index: newIndex461            });462            return;463          }464          last = path;465        }466      }467    }468    if (last) {469      const [newPath] = last.insertAfter(node);470      lastImports.push({471        path: newPath,472        index: newIndex473      });474    } else {475      const [newPath] = programPath.unshiftContainer("body", [node]);476      this._lastImports.set(programPath, [{477        path: newPath,478        index: newIndex479      }]);480    }481  }482  _ensure(map, programPath, Collection) {483    let collection = map.get(programPath);484    if (!collection) {485      collection = new Collection();486      map.set(programPath, collection);487    }488    return collection;489  }490  _normalizeKey(programPath, url, name = "") {491    const {492      sourceType493    } = programPath.node;494 495    // If we rely on the imported binding (the "name" parameter), we also need to cache496    // based on the sourceType. This is because the module transforms change the names497    // of the import variables.498    return `${name && sourceType}::${url}::${name}`;499  }500}501 502const presetEnvSilentDebugHeader = "#__secret_key__@babel/preset-env__don't_log_debug_header_and_resolved_targets";503function stringifyTargetsMultiline(targets) {504  return JSON.stringify(prettifyTargets(targets), null, 2);505}506 507function patternToRegExp(pattern) {508  if (pattern instanceof RegExp) return pattern;509  try {510    return new RegExp(`^${pattern}$`);511  } catch {512    return null;513  }514}515function buildUnusedError(label, unused) {516  if (!unused.length) return "";517  return `  - The following "${label}" patterns didn't match any polyfill:\n` + unused.map(original => `    ${String(original)}\n`).join("");518}519function buldDuplicatesError(duplicates) {520  if (!duplicates.size) return "";521  return `  - The following polyfills were matched both by "include" and "exclude" patterns:\n` + Array.from(duplicates, name => `    ${name}\n`).join("");522}523function validateIncludeExclude(provider, polyfills, includePatterns, excludePatterns) {524  let current;525  const filter = pattern => {526    const regexp = patternToRegExp(pattern);527    if (!regexp) return false;528    let matched = false;529    for (const polyfill of polyfills.keys()) {530      if (regexp.test(polyfill)) {531        matched = true;532        current.add(polyfill);533      }534    }535    return !matched;536  };537 538  // prettier-ignore539  const include = current = new Set();540  const unusedInclude = Array.from(includePatterns).filter(filter);541 542  // prettier-ignore543  const exclude = current = new Set();544  const unusedExclude = Array.from(excludePatterns).filter(filter);545  const duplicates = intersection(include, exclude);546  if (duplicates.size > 0 || unusedInclude.length > 0 || unusedExclude.length > 0) {547    throw new Error(`Error while validating the "${provider}" provider options:\n` + buildUnusedError("include", unusedInclude) + buildUnusedError("exclude", unusedExclude) + buldDuplicatesError(duplicates));548  }549  return {550    include,551    exclude552  };553}554function applyMissingDependenciesDefaults(options, babelApi) {555  const {556    missingDependencies = {}557  } = options;558  if (missingDependencies === false) return false;559  const caller = babelApi.caller(caller => caller == null ? void 0 : caller.name);560  const {561    log = "deferred",562    inject = caller === "rollup-plugin-babel" ? "throw" : "import",563    all = false564  } = missingDependencies;565  return {566    log,567    inject,568    all569  };570}571 572function isRemoved(path) {573  if (path.removed) return true;574  if (!path.parentPath) return false;575  if (path.listKey) {576    var _path$parentPath$node;577    if (!((_path$parentPath$node = path.parentPath.node) != null && (_path$parentPath$node = _path$parentPath$node[path.listKey]) != null && _path$parentPath$node.includes(path.node))) return true;578  } else {579    var _path$parentPath$node2;580    if (((_path$parentPath$node2 = path.parentPath.node) == null ? void 0 : _path$parentPath$node2[path.key]) !== path.node) return true;581  }582  return isRemoved(path.parentPath);583}584var usage = callProvider => {585  function property(object, key, placement, path) {586    return callProvider({587      kind: "property",588      object,589      key,590      placement591    }, path);592  }593  function handleReferencedIdentifier(path) {594    const {595      node: {596        name597      },598      scope599    } = path;600    if (scope.getBindingIdentifier(name)) return;601    callProvider({602      kind: "global",603      name604    }, path);605  }606  function analyzeMemberExpression(path) {607    const key = resolveKey(path.get("property"), path.node.computed);608    return {609      key,610      handleAsMemberExpression: !!key && key !== "prototype"611    };612  }613  return {614    // Symbol(), new Promise615    ReferencedIdentifier(path) {616      const {617        parentPath618      } = path;619      if (parentPath.isMemberExpression({620        object: path.node621      }) && analyzeMemberExpression(parentPath).handleAsMemberExpression) {622        return;623      }624      handleReferencedIdentifier(path);625    },626    "MemberExpression|OptionalMemberExpression"(path) {627      const {628        key,629        handleAsMemberExpression630      } = analyzeMemberExpression(path);631      if (!handleAsMemberExpression) return;632      const object = path.get("object");633      let objectIsGlobalIdentifier = object.isIdentifier();634      if (objectIsGlobalIdentifier) {635        const binding = object.scope.getBinding(object.node.name);636        if (binding) {637          if (binding.path.isImportNamespaceSpecifier()) return;638          objectIsGlobalIdentifier = false;639        }640      }641      const source = resolveSource(object, new Set());642      const skipObject = property(source.id, key, source.placement, path);643      const canHandleObject = objectIsGlobalIdentifier && !path.shouldSkip && !object.shouldSkip && !isRemoved(object);644      if (canHandleObject && (!skipObject || PossibleGlobalObjects.has(source.id))) {645        handleReferencedIdentifier(object);646      }647    },648    ObjectPattern(path) {649      const {650        parentPath,651        parent652      } = path;653      let obj;654 655      // const { keys, values } = Object656      if (parentPath.isVariableDeclarator()) {657        obj = parentPath.get("init");658        // ({ keys, values } = Object)659      } else if (parentPath.isAssignmentExpression()) {660        obj = parentPath.get("right");661        // !function ({ keys, values }) {...} (Object)662        // resolution does not work after properties transform :-(663      } else if (parentPath.isFunction()) {664        const grand = parentPath.parentPath;665        if (grand.isCallExpression() || grand.isNewExpression()) {666          if (grand.node.callee === parent) {667            obj = grand.get("arguments")[path.key];668          }669        }670      }671      let id = null;672      let placement = null;673      if (obj) ({674        id,675        placement676      } = resolveSource(obj, new Set()));677      for (const prop of path.get("properties")) {678        if (prop.isObjectProperty()) {679          const key = resolveKey(prop.get("key"));680          if (key) property(id, key, placement, prop);681        }682      }683    },684    BinaryExpression(path) {685      if (path.node.operator !== "in") return;686      const source = resolveSource(path.get("right"), new Set());687      const key = resolveKey(path.get("left"), true);688      if (!key) return;689      callProvider({690        kind: "in",691        object: source.id,692        key,693        placement: source.placement694      }, path);695    }696  };697};698 699var entry = callProvider => ({700  ImportDeclaration(path) {701    const source = getImportSource(path);702    if (!source) return;703    callProvider({704      kind: "import",705      source706    }, path);707  },708  Program(path) {709    path.get("body").forEach(bodyPath => {710      const source = getRequireSource(bodyPath);711      if (!source) return;712      callProvider({713        kind: "import",714        source715      }, bodyPath);716    });717  }718});719 720const nativeRequireResolve = parseFloat(process.versions.node) >= 8.9;721const require = createRequire(import /*::(_)*/.meta.url); // eslint-disable-line722 723function myResolve(name, basedir) {724  if (nativeRequireResolve) {725    return require.resolve(name, {726      paths: [basedir]727    }).replace(/\\/g, "/");728  } else {729    return requireResolve.sync(name, {730      basedir731    }).replace(/\\/g, "/");732  }733}734function resolve(dirname, moduleName, absoluteImports) {735  if (absoluteImports === false) return moduleName;736  let basedir = dirname;737  if (typeof absoluteImports === "string") {738    basedir = path.resolve(basedir, absoluteImports);739  }740  try {741    return myResolve(moduleName, basedir);742  } catch (err) {743    if (err.code !== "MODULE_NOT_FOUND") throw err;744    throw Object.assign(new Error(`Failed to resolve "${moduleName}" relative to "${dirname}"`), {745      code: "BABEL_POLYFILL_NOT_FOUND",746      polyfill: moduleName,747      dirname748    });749  }750}751function has(basedir, name) {752  try {753    myResolve(name, basedir);754    return true;755  } catch {756    return false;757  }758}759function logMissing(missingDeps) {760  if (missingDeps.size === 0) return;761  const deps = Array.from(missingDeps).sort().join(" ");762  console.warn("\nSome polyfills have been added but are not present in your dependencies.\n" + "Please run one of the following commands:\n" + `\tnpm install --save ${deps}\n` + `\tyarn add ${deps}\n`);763  process.exitCode = 1;764}765let allMissingDeps = new Set();766const laterLogMissingDependencies = debounce(() => {767  logMissing(allMissingDeps);768  allMissingDeps = new Set();769}, 100);770function laterLogMissing(missingDeps) {771  if (missingDeps.size === 0) return;772  missingDeps.forEach(name => allMissingDeps.add(name));773  laterLogMissingDependencies();774}775 776function createMetaResolver(polyfills) {777  const {778    static: staticP,779    instance: instanceP,780    global: globalP781  } = polyfills;782  return meta => {783    if (meta.kind === "global" && globalP && has$1(globalP, meta.name)) {784      return {785        kind: "global",786        desc: globalP[meta.name],787        name: meta.name788      };789    }790    if (meta.kind === "property" || meta.kind === "in") {791      const {792        placement,793        object,794        key795      } = meta;796      if (object && placement === "static") {797        if (globalP && PossibleGlobalObjects.has(object) && has$1(globalP, key)) {798          return {799            kind: "global",800            desc: globalP[key],801            name: key802          };803        }804        if (staticP && has$1(staticP, object) && has$1(staticP[object], key)) {805          return {806            kind: "static",807            desc: staticP[object][key],808            name: `${object}$${key}`809          };810        }811      }812      if (instanceP && has$1(instanceP, key)) {813        return {814          kind: "instance",815          desc: instanceP[key],816          name: `${key}`817        };818      }819    }820  };821}822 823const getTargets = _getTargets.default || _getTargets;824function resolveOptions(options, babelApi) {825  const {826    method,827    targets: targetsOption,828    ignoreBrowserslistConfig,829    configPath,830    debug,831    shouldInjectPolyfill,832    absoluteImports,833    ...providerOptions834  } = options;835  if (isEmpty(options)) {836    throw new Error(`\837This plugin requires options, for example:838    {839      "plugins": [840        ["<plugin name>", { method: "usage-pure" }]841      ]842    }843 844See more options at https://github.com/babel/babel-polyfills/blob/main/docs/usage.md`);845  }846  let methodName;847  if (method === "usage-global") methodName = "usageGlobal";else if (method === "entry-global") methodName = "entryGlobal";else if (method === "usage-pure") methodName = "usagePure";else if (typeof method !== "string") {848    throw new Error(".method must be a string");849  } else {850    throw new Error(`.method must be one of "entry-global", "usage-global"` + ` or "usage-pure" (received ${JSON.stringify(method)})`);851  }852  if (typeof shouldInjectPolyfill === "function") {853    if (options.include || options.exclude) {854      throw new Error(`.include and .exclude are not supported when using the` + ` .shouldInjectPolyfill function.`);855    }856  } else if (shouldInjectPolyfill != null) {857    throw new Error(`.shouldInjectPolyfill must be a function, or undefined` + ` (received ${JSON.stringify(shouldInjectPolyfill)})`);858  }859  if (absoluteImports != null && typeof absoluteImports !== "boolean" && typeof absoluteImports !== "string") {860    throw new Error(`.absoluteImports must be a boolean, a string, or undefined` + ` (received ${JSON.stringify(absoluteImports)})`);861  }862  let targets;863  if (864  // If any browserslist-related option is specified, fallback to the old865  // behavior of not using the targets specified in the top-level options.866  targetsOption || configPath || ignoreBrowserslistConfig) {867    const targetsObj = typeof targetsOption === "string" || Array.isArray(targetsOption) ? {868      browsers: targetsOption869    } : targetsOption;870    targets = getTargets(targetsObj, {871      ignoreBrowserslistConfig,872      configPath873    });874  } else {875    targets = babelApi.targets();876  }877  return {878    method,879    methodName,880    targets,881    absoluteImports: absoluteImports != null ? absoluteImports : false,882    shouldInjectPolyfill,883    debug: !!debug,884    providerOptions: providerOptions885  };886}887function instantiateProvider(factory, options, missingDependencies, dirname, debugLog, babelApi) {888  const {889    method,890    methodName,891    targets,892    debug,893    shouldInjectPolyfill,894    providerOptions,895    absoluteImports896  } = resolveOptions(options, babelApi);897 898  // eslint-disable-next-line prefer-const899  let include, exclude;900  let polyfillsSupport;901  let polyfillsNames;902  let filterPolyfills;903  const getUtils = createUtilsGetter(new ImportsCachedInjector(moduleName => resolve(dirname, moduleName, absoluteImports), name => {904    var _polyfillsNames$get, _polyfillsNames;905    return (_polyfillsNames$get = (_polyfillsNames = polyfillsNames) == null ? void 0 : _polyfillsNames.get(name)) != null ? _polyfillsNames$get : Infinity;906  }));907  const depsCache = new Map();908  const api = {909    babel: babelApi,910    getUtils,911    method: options.method,912    targets,913    createMetaResolver,914    shouldInjectPolyfill(name) {915      if (polyfillsNames === undefined) {916        throw new Error(`Internal error in the ${factory.name} provider: ` + `shouldInjectPolyfill() can't be called during initialization.`);917      }918      if (!polyfillsNames.has(name)) {919        console.warn(`Internal error in the ${providerName} provider: ` + `unknown polyfill "${name}".`);920      }921      if (filterPolyfills && !filterPolyfills(name)) return false;922      let shouldInject = isRequired(name, targets, {923        compatData: polyfillsSupport,924        includes: include,925        excludes: exclude926      });927      if (shouldInjectPolyfill) {928        shouldInject = shouldInjectPolyfill(name, shouldInject);929        if (typeof shouldInject !== "boolean") {930          throw new Error(`.shouldInjectPolyfill must return a boolean.`);931        }932      }933      return shouldInject;934    },935    debug(name) {936      var _debugLog, _debugLog$polyfillsSu;937      debugLog().found = true;938      if (!debug || !name) return;939      if (debugLog().polyfills.has(providerName)) return;940      debugLog().polyfills.add(name);941      (_debugLog$polyfillsSu = (_debugLog = debugLog()).polyfillsSupport) != null ? _debugLog$polyfillsSu : _debugLog.polyfillsSupport = polyfillsSupport;942    },943    assertDependency(name, version = "*") {944      if (missingDependencies === false) return;945      if (absoluteImports) {946        // If absoluteImports is not false, we will try resolving947        // the dependency and throw if it's not possible. We can948        // skip the check here.949        return;950      }951      const dep = version === "*" ? name : `${name}@^${version}`;952      const found = missingDependencies.all ? false : mapGetOr(depsCache, `${name} :: ${dirname}`, () => has(dirname, name));953      if (!found) {954        debugLog().missingDeps.add(dep);955      }956    }957  };958  const provider = factory(api, providerOptions, dirname);959  const providerName = provider.name || factory.name;960  if (typeof provider[methodName] !== "function") {961    throw new Error(`The "${providerName}" provider doesn't support the "${method}" polyfilling method.`);962  }963  if (Array.isArray(provider.polyfills)) {964    polyfillsNames = new Map(provider.polyfills.map((name, index) => [name, index]));965    filterPolyfills = provider.filterPolyfills;966  } else if (provider.polyfills) {967    polyfillsNames = new Map(Object.keys(provider.polyfills).map((name, index) => [name, index]));968    polyfillsSupport = provider.polyfills;969    filterPolyfills = provider.filterPolyfills;970  } else {971    polyfillsNames = new Map();972  }973  ({974    include,975    exclude976  } = validateIncludeExclude(providerName, polyfillsNames, providerOptions.include || [], providerOptions.exclude || []));977  let callProvider;978  if (methodName === "usageGlobal") {979    callProvider = (payload, path) => {980      var _ref;981      const utils = getUtils(path);982      return (_ref = provider[methodName](payload, utils, path)) != null ? _ref : false;983    };984  } else {985    callProvider = (payload, path) => {986      const utils = getUtils(path);987      provider[methodName](payload, utils, path);988      return false;989    };990  }991  return {992    debug,993    method,994    targets,995    provider,996    providerName,997    callProvider998  };999}1000function definePolyfillProvider(factory) {1001  return declare((babelApi, options, dirname) => {1002    babelApi.assertVersion("^7.0.0 || ^8.0.0-alpha.0");1003    const {1004      traverse1005    } = babelApi;1006    let debugLog;1007    const missingDependencies = applyMissingDependenciesDefaults(options, babelApi);1008    const {1009      debug,1010      method,1011      targets,1012      provider,1013      providerName,1014      callProvider1015    } = instantiateProvider(factory, options, missingDependencies, dirname, () => debugLog, babelApi);1016    const createVisitor = method === "entry-global" ? entry : usage;1017    const visitor = provider.visitor ? traverse.visitors.merge([createVisitor(callProvider), provider.visitor]) : createVisitor(callProvider);1018    if (debug && debug !== presetEnvSilentDebugHeader) {1019      console.log(`${providerName}: \`DEBUG\` option`);1020      console.log(`\nUsing targets: ${stringifyTargetsMultiline(targets)}`);1021      console.log(`\nUsing polyfills with \`${method}\` method:`);1022    }1023    const {1024      runtimeName1025    } = provider;1026    return {1027      name: "inject-polyfills",1028      visitor,1029      pre(file) {1030        var _provider$pre;1031        if (runtimeName) {1032          if (file.get("runtimeHelpersModuleName") && file.get("runtimeHelpersModuleName") !== runtimeName) {1033            console.warn(`Two different polyfill providers` + ` (${file.get("runtimeHelpersModuleProvider")}` + ` and ${providerName}) are trying to define two` + ` conflicting @babel/runtime alternatives:` + ` ${file.get("runtimeHelpersModuleName")} and ${runtimeName}.` + ` The second one will be ignored.`);1034          } else {1035            file.set("runtimeHelpersModuleName", runtimeName);1036            file.set("runtimeHelpersModuleProvider", providerName);1037          }1038        }1039        debugLog = {1040          polyfills: new Set(),1041          polyfillsSupport: undefined,1042          found: false,1043          providers: new Set(),1044          missingDeps: new Set()1045        };1046        (_provider$pre = provider.pre) == null || _provider$pre.apply(this, arguments);1047      },1048      post() {1049        var _provider$post;1050        (_provider$post = provider.post) == null || _provider$post.apply(this, arguments);1051        if (missingDependencies !== false) {1052          if (missingDependencies.log === "per-file") {1053            logMissing(debugLog.missingDeps);1054          } else {1055            laterLogMissing(debugLog.missingDeps);1056          }1057        }1058        if (!debug) return;1059        if (this.filename) console.log(`\n[${this.filename}]`);1060        if (debugLog.polyfills.size === 0) {1061          console.log(method === "entry-global" ? debugLog.found ? `Based on your targets, the ${providerName} polyfill did not add any polyfill.` : `The entry point for the ${providerName} polyfill has not been found.` : `Based on your code and targets, the ${providerName} polyfill did not add any polyfill.`);1062          return;1063        }1064        if (method === "entry-global") {1065          console.log(`The ${providerName} polyfill entry has been replaced with ` + `the following polyfills:`);1066        } else {1067          console.log(`The ${providerName} polyfill added the following polyfills:`);1068        }1069        for (const name of debugLog.polyfills) {1070          var _debugLog$polyfillsSu2;1071          if ((_debugLog$polyfillsSu2 = debugLog.polyfillsSupport) != null && _debugLog$polyfillsSu2[name]) {1072            const filteredTargets = getInclusionReasons(name, targets, debugLog.polyfillsSupport);1073            const formattedTargets = JSON.stringify(filteredTargets).replace(/,/g, ", ").replace(/^\{"/, '{ "').replace(/"\}$/, '" }');1074            console.log(`  ${name} ${formattedTargets}`);1075          } else {1076            console.log(`  ${name}`);1077          }1078        }1079      }1080    };1081  });1082}1083function mapGetOr(map, key, getDefault) {1084  let val = map.get(key);1085  if (val === undefined) {1086    val = getDefault();1087    map.set(key, val);1088  }1089  return val;1090}1091function isEmpty(obj) {1092  return Object.keys(obj).length === 0;1093}1094 1095export { definePolyfillProvider as default };1096//# sourceMappingURL=index.node.mjs.map1097