$

node_modules/babel-plugin-polyfill-corejs3/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Nicolò Ribaudo and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/babel-plugin-polyfill-corejs3/README.md

@@ -0,0 +1,28 @@
+# babel-plugin-polyfill-corejs3
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev babel-plugin-polyfill-corejs3
+```
+
+or using yarn:
+
+```sh
+yarn add babel-plugin-polyfill-corejs3 --dev
+```
+
+## Usage
+
+Add this plugin to your Babel configuration:
+
+```json
+{
+  "plugins": [["polyfill-corejs3", { "method": "usage-global", "version": "3.20" }]]
+}
+```
+
+This package supports the `usage-pure`, `usage-global`, and `entry-global` methods.
+When `entry-global` is used, it replaces imports to `core-js`.

node_modules/babel-plugin-polyfill-corejs3/core-js-compat/README.md

@@ -0,0 +1,4 @@
+`core-js-compat` exposes some files as JSON, and they cannot be
+imported by Node.js ESM files.
+This folder proxies `core-js-compat` to ensure that every entry
+is CJS and can be safely imported.

node_modules/babel-plugin-polyfill-corejs3/core-js-compat/data.js

@@ -0,0 +1 @@
+module.exports = require("core-js-compat/data");

node_modules/babel-plugin-polyfill-corejs3/core-js-compat/entries.js

@@ -0,0 +1 @@
+module.exports = require("core-js-compat/entries");

node_modules/babel-plugin-polyfill-corejs3/core-js-compat/get-modules-list-for-target-version.js

@@ -0,0 +1 @@
+module.exports = require("core-js-compat/get-modules-list-for-target-version");

node_modules/babel-plugin-polyfill-corejs3/lib/index.js

@@ -0,0 +1,301 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _data = _interopRequireDefault(require("../core-js-compat/data.js"));
+
+var _shippedProposals = _interopRequireDefault(require("./shipped-proposals"));
+
+var _getModulesListForTargetVersion = _interopRequireDefault(require("../core-js-compat/get-modules-list-for-target-version.js"));
+
+var _builtInDefinitions = require("./built-in-definitions");
+
+var _babel = _interopRequireWildcard(require("@babel/core"));
+
+var _utils = require("./utils");
+
+var _helperDefinePolyfillProvider = _interopRequireDefault(require("@babel/helper-define-polyfill-provider"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+const {
+  types: t
+} = _babel.default || _babel;
+const runtimeCompat = "#__secret_key__@babel/runtime__compatibility";
+
+const esnextFallback = (name, cb) => {
+  if (cb(name)) return true;
+  if (!name.startsWith("es.")) return false;
+  const fallback = `esnext.${name.slice(3)}`;
+  if (!_data.default[fallback]) return false;
+  return cb(fallback);
+};
+
+var _default = (0, _helperDefinePolyfillProvider.default)(function ({
+  getUtils,
+  method,
+  shouldInjectPolyfill,
+  createMetaResolver,
+  debug,
+  babel
+}, {
+  version = 3,
+  proposals,
+  shippedProposals,
+  [runtimeCompat]: {
+    useBabelRuntime,
+    ext = ".js"
+  } = {
+    useBabelRuntime: ""
+  }
+}) {
+  const isWebpack = babel.caller(caller => (caller == null ? void 0 : caller.name) === "babel-loader");
+  const resolve = createMetaResolver({
+    global: _builtInDefinitions.BuiltIns,
+    static: _builtInDefinitions.StaticProperties,
+    instance: _builtInDefinitions.InstanceProperties
+  });
+  const available = new Set((0, _getModulesListForTargetVersion.default)(version));
+
+  function getCoreJSPureBase(useProposalBase) {
+    return useBabelRuntime ? useProposalBase ? `${useBabelRuntime}/core-js` : `${useBabelRuntime}/core-js-stable` : useProposalBase ? "core-js-pure/features" : "core-js-pure/stable";
+  }
+
+  function maybeInjectGlobalImpl(name, utils) {
+    if (shouldInjectPolyfill(name)) {
+      debug(name);
+      utils.injectGlobalImport((0, _utils.coreJSModule)(name));
+      return true;
+    }
+
+    return false;
+  }
+
+  function maybeInjectGlobal(names, utils, fallback = true) {
+    for (const name of names) {
+      if (fallback) {
+        esnextFallback(name, name => maybeInjectGlobalImpl(name, utils));
+      } else {
+        maybeInjectGlobalImpl(name, utils);
+      }
+    }
+  }
+
+  function maybeInjectPure(desc, hint, utils, object) {
+    if (desc.pure && !(object && desc.exclude && desc.exclude.includes(object)) && esnextFallback(desc.name, shouldInjectPolyfill)) {
+      const {
+        name
+      } = desc;
+      let useProposalBase = false;
+
+      if (proposals || shippedProposals && name.startsWith("esnext.")) {
+        useProposalBase = true;
+      } else if (name.startsWith("es.") && !available.has(name)) {
+        useProposalBase = true;
+      }
+
+      const coreJSPureBase = getCoreJSPureBase(useProposalBase);
+      return utils.injectDefaultImport(`${coreJSPureBase}/${desc.pure}${ext}`, hint);
+    }
+  }
+
+  function isFeatureStable(name) {
+    if (name.startsWith("esnext.")) {
+      const esName = `es.${name.slice(7)}`; // If its imaginative esName is not in latest compat data, it means
+      // the proposal is not stage 4
+
+      return esName in _data.default;
+    }
+
+    return true;
+  }
+
+  return {
+    name: "corejs3",
+    polyfills: _data.default,
+
+    filterPolyfills(name) {
+      if (!available.has(name)) return false;
+      if (proposals || method === "entry-global") return true;
+
+      if (shippedProposals && _shippedProposals.default.has(name)) {
+        return true;
+      }
+
+      return isFeatureStable(name);
+    },
+
+    entryGlobal(meta, utils, path) {
+      if (meta.kind !== "import") return;
+      const modules = (0, _utils.isCoreJSSource)(meta.source);
+      if (!modules) return;
+
+      if (modules.length === 1 && meta.source === (0, _utils.coreJSModule)(modules[0]) && shouldInjectPolyfill(modules[0])) {
+        // Avoid infinite loop: do not replace imports with a new copy of
+        // themselves.
+        debug(null);
+        return;
+      }
+
+      const modulesSet = new Set(modules);
+      const filteredModules = modules.filter(module => {
+        if (!module.startsWith("esnext.")) return true;
+        const stable = module.replace("esnext.", "es.");
+
+        if (modulesSet.has(stable) && shouldInjectPolyfill(stable)) {
+          return false;
+        }
+
+        return true;
+      });
+      maybeInjectGlobal(filteredModules, utils, false);
+      path.remove();
+    },
+
+    usageGlobal(meta, utils) {
+      const resolved = resolve(meta);
+      if (!resolved) return;
+      let deps = resolved.desc.global;
+
+      if (resolved.kind !== "global" && "object" in meta && meta.object && meta.placement === "prototype") {
+        const low = meta.object.toLowerCase();
+        deps = deps.filter(m => m.includes(low) || _builtInDefinitions.CommonInstanceDependencies.has(m));
+      }
+
+      maybeInjectGlobal(deps, utils);
+    },
+
+    usagePure(meta, utils, path) {
+      if (meta.kind === "in") {
+        if (meta.key === "Symbol.iterator") {
+          path.replaceWith(t.callExpression(utils.injectDefaultImport((0, _utils.coreJSPureHelper)("is-iterable", useBabelRuntime, ext), "isIterable"), [path.node.right] // meta.kind === "in" narrows this
+          ));
+        }
+
+        return;
+      }
+
+      if (path.parentPath.isUnaryExpression({
+        operator: "delete"
+      })) return;
+
+      if (meta.kind === "property") {
+        // We can't compile destructuring and updateExpression.
+        if (!path.isMemberExpression()) return;
+        if (!path.isReferenced()) return;
+        if (path.parentPath.isUpdateExpression()) return;
+
+        if (meta.key === "Symbol.iterator") {
+          if (!shouldInjectPolyfill("es.symbol.iterator")) return;
+          const {
+            parent,
+            node
+          } = path;
+
+          if (t.isCallExpression(parent, {
+            callee: node
+          })) {
+            if (parent.arguments.length === 0) {
+              path.parentPath.replaceWith(t.callExpression(utils.injectDefaultImport((0, _utils.coreJSPureHelper)("get-iterator", useBabelRuntime, ext), "getIterator"), [node.object]));
+              path.skip();
+            } else {
+              (0, _utils.callMethod)(path, utils.injectDefaultImport((0, _utils.coreJSPureHelper)("get-iterator-method", useBabelRuntime, ext), "getIteratorMethod"));
+            }
+          } else {
+            path.replaceWith(t.callExpression(utils.injectDefaultImport((0, _utils.coreJSPureHelper)("get-iterator-method", useBabelRuntime, ext), "getIteratorMethod"), [path.node.object]));
+          }
+
+          return;
+        }
+      }
+
+      let resolved = resolve(meta);
+      if (!resolved) return;
+
+      if (useBabelRuntime && resolved.desc.pure && resolved.desc.pure.slice(-6) === "/index") {
+        // Remove /index, since it doesn't exist in @babel/runtime-corejs3s
+        resolved = _extends({}, resolved, {
+          desc: _extends({}, resolved.desc, {
+            pure: resolved.desc.pure.slice(0, -6)
+          })
+        });
+      }
+
+      if (resolved.kind === "global") {
+        const id = maybeInjectPure(resolved.desc, resolved.name, utils);
+        if (id) path.replaceWith(id);
+      } else if (resolved.kind === "static") {
+        const id = maybeInjectPure(resolved.desc, resolved.name, utils, // @ts-expect-error
+        meta.object);
+        if (id) path.replaceWith(id);
+      } else if (resolved.kind === "instance") {
+        const id = maybeInjectPure(resolved.desc, `${resolved.name}InstanceProperty`, utils, // @ts-expect-error
+        meta.object);
+        if (!id) return;
+        const {
+          node
+        } = path;
+
+        if (t.isCallExpression(path.parent, {
+          callee: node
+        })) {
+          (0, _utils.callMethod)(path, id);
+        } else {
+          path.replaceWith(t.callExpression(id, [node.object]));
+        }
+      }
+    },
+
+    visitor: method === "usage-global" && {
+      // import("foo")
+      CallExpression(path) {
+        if (path.get("callee").isImport()) {
+          const utils = getUtils(path);
+
+          if (isWebpack) {
+            // Webpack uses Promise.all to handle dynamic import.
+            maybeInjectGlobal(_builtInDefinitions.PromiseDependenciesWithIterators, utils);
+          } else {
+            maybeInjectGlobal(_builtInDefinitions.PromiseDependencies, utils);
+          }
+        }
+      },
+
+      // (async function () { }).finally(...)
+      Function(path) {
+        if (path.node.async) {
+          maybeInjectGlobal(_builtInDefinitions.PromiseDependencies, getUtils(path));
+        }
+      },
+
+      // for-of, [a, b] = c
+      "ForOfStatement|ArrayPattern"(path) {
+        maybeInjectGlobal(_builtInDefinitions.CommonIterators, getUtils(path));
+      },
+
+      // [...spread]
+      SpreadElement(path) {
+        if (!path.parentPath.isObjectExpression()) {
+          maybeInjectGlobal(_builtInDefinitions.CommonIterators, getUtils(path));
+        }
+      },
+
+      // yield*
+      YieldExpression(path) {
+        if (path.node.delegate) {
+          maybeInjectGlobal(_builtInDefinitions.CommonIterators, getUtils(path));
+        }
+      }
+
+    }
+  };
+});
+
+exports.default = _default;

node_modules/babel-plugin-polyfill-corejs3/lib/shipped-proposals.js

@@ -0,0 +1,9 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+// This file is automatically generated by scripts/build-corejs3-shipped-proposals.mjs
+var _default = new Set(["esnext.array.find-last", "esnext.array.find-last-index", "esnext.typed-array.find-last", "esnext.typed-array.find-last-index"]);
+
+exports.default = _default;

node_modules/babel-plugin-polyfill-corejs3/lib/utils.js

@@ -0,0 +1,55 @@
+"use strict";
+
+exports.__esModule = true;
+exports.callMethod = callMethod;
+exports.coreJSModule = coreJSModule;
+exports.coreJSPureHelper = coreJSPureHelper;
+exports.isCoreJSSource = isCoreJSSource;
+
+var _babel = _interopRequireWildcard(require("@babel/core"));
+
+var _entries = _interopRequireDefault(require("../core-js-compat/entries.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const {
+  types: t
+} = _babel.default || _babel;
+
+function callMethod(path, id) {
+  const {
+    object
+  } = path.node;
+  let context1, context2;
+
+  if (t.isIdentifier(object)) {
+    context1 = object;
+    context2 = t.cloneNode(object);
+  } else {
+    context1 = path.scope.generateDeclaredUidIdentifier("context");
+    context2 = t.assignmentExpression("=", t.cloneNode(context1), object);
+  }
+
+  path.replaceWith(t.memberExpression(t.callExpression(id, [context2]), t.identifier("call")));
+  path.parentPath.unshiftContainer("arguments", context1);
+}
+
+function isCoreJSSource(source) {
+  if (typeof source === "string") {
+    source = source.replace(/\\/g, "/").replace(/(\/(index)?)?(\.js)?$/i, "").toLowerCase();
+  }
+
+  return Object.prototype.hasOwnProperty.call(_entries.default, source) && _entries.default[source];
+}
+
+function coreJSModule(name) {
+  return `core-js/modules/${name}.js`;
+}
+
+function coreJSPureHelper(name, useBabelRuntime, ext) {
+  return useBabelRuntime ? `${useBabelRuntime}/core-js/${name}${ext}` : `core-js-pure/features/${name}.js`;
+}

node_modules/babel-plugin-polyfill-corejs3/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "babel-plugin-polyfill-corejs3",
+  "version": "0.5.3",
+  "description": "A Babel plugin to inject imports to core-js@3 polyfills",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel-polyfills.git",
+    "directory": "packages/babel-plugin-polyfill-corejs3"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "lib/index.js",
+  "exports": {
+    ".": [
+      {
+        "import": "./esm/index.mjs",
+        "default": "./lib/index.js"
+      },
+      "./lib/index.js"
+    ],
+    "./package.json": "./package.json"
+  },
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-define-polyfill-provider": "^0.3.2",
+    "core-js-compat": "^3.21.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.17.8",
+    "@babel/helper-plugin-test-runner": "^7.16.7",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/plugin-transform-classes": "^7.16.7",
+    "@babel/plugin-transform-for-of": "^7.16.7",
+    "@babel/plugin-transform-modules-commonjs": "^7.17.7",
+    "@babel/plugin-transform-spread": "^7.16.7",
+    "core-js": "^3.21.0",
+    "core-js-pure": "^3.21.0"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "gitHead": "62b9025beeec450a1ff5d61fadcf63963aec5015"
+}