refactor(classes): 重构类转换ref插件

- 类转换逻辑
- 添加新辅助重写 transformClass.js 文件，优化函数和优化现有辅助函数的使用类转换逻辑
- 添加新辅助
- 改进对超类函数和优化现有辅助函数的使用构造函数调用的处理方式

- 改进对超类- 优化类方法和属性的处理逻辑
构造函数调用的处理方式

node_modules/@babel/plugin-transform-classes/lib/inline-callSuper-helpers.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = addCallSuperHelper;
+var _core = require("@babel/core");
+const helper = _core.template.statement`
+  function CALL_SUPER(
+    _this,
+    derived,
+    args,
+  ) {
+    function isNativeReflectConstruct() {
+      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+
+      // core-js@3
+      if (Reflect.construct.sham) return false;
+
+      // Proxy can't be polyfilled. Every browser implemented
+      // proxies before or at the same time as Reflect.construct,
+      // so if they support Proxy they also support Reflect.construct.
+      if (typeof Proxy === "function") return true;
+
+      // Since Reflect.construct can't be properly polyfilled, some
+      // implementations (e.g. core-js@2) don't set the correct internal slots.
+      // Those polyfills don't allow us to subclass built-ins, so we need to
+      // use our fallback implementation.
+      try {
+        // If the internal slots aren't set, this throws an error similar to
+        //   TypeError: this is not a Boolean object.
+        return !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}),);
+      } catch (e) {
+        return false;
+      }
+    }
+
+    // Super
+    derived = GET_PROTOTYPE_OF(derived);
+    return POSSIBLE_CONSTRUCTOR_RETURN(
+      _this,
+      isNativeReflectConstruct()
+        ? // NOTE: This doesn't work if this.__proto__.constructor has been modified.
+          Reflect.construct(
+            derived,
+            args || [],
+            GET_PROTOTYPE_OF(_this).constructor,
+          )
+        : derived.apply(_this, args),
+    );
+  }
+`;
+const helperIDs = new WeakMap();
+function addCallSuperHelper(file) {
+  if (helperIDs.has(file)) {
+    return (_core.types.cloneNode || _core.types.clone)(helperIDs.get(file));
+  }
+  try {
+    return file.addHelper("callSuper");
+  } catch (_unused) {}
+  const id = file.scope.generateUidIdentifier("callSuper");
+  helperIDs.set(file, id);
+  const fn = helper({
+    CALL_SUPER: id,
+    GET_PROTOTYPE_OF: file.addHelper("getPrototypeOf"),
+    POSSIBLE_CONSTRUCTOR_RETURN: file.addHelper("possibleConstructorReturn")
+  });
+  file.path.unshiftContainer("body", [fn]);
+  file.scope.registerDeclaration(file.path.get("body.0"));
+  return _core.types.cloneNode(id);
+}
+
+//# sourceMappingURL=inline-callSuper-helpers.js.map

node_modules/@babel/plugin-transform-classes/lib/transformClass.js

@@ -0,0 +1,544 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformClass;
+var _helperReplaceSupers = require("@babel/helper-replace-supers");
+var _core = require("@babel/core");
+var _traverse = require("@babel/traverse");
+var _helperAnnotateAsPure = require("@babel/helper-annotate-as-pure");
+var _inlineCallSuperHelpers = require("./inline-callSuper-helpers.js");
+function buildConstructor(classRef, constructorBody, node) {
+  const func = _core.types.functionDeclaration(_core.types.cloneNode(classRef), [], constructorBody);
+  _core.types.inherits(func, node);
+  return func;
+}
+function transformClass(path, file, builtinClasses, isLoose, assumptions, supportUnicodeId) {
+  const classState = {
+    parent: undefined,
+    scope: undefined,
+    node: undefined,
+    path: undefined,
+    file: undefined,
+    classId: undefined,
+    classRef: undefined,
+    superName: null,
+    superReturns: [],
+    isDerived: false,
+    extendsNative: false,
+    construct: undefined,
+    constructorBody: undefined,
+    userConstructor: undefined,
+    userConstructorPath: undefined,
+    hasConstructor: false,
+    body: [],
+    superThises: [],
+    pushedInherits: false,
+    pushedCreateClass: false,
+    protoAlias: null,
+    isLoose: false,
+    dynamicKeys: new Map(),
+    methods: {
+      instance: {
+        hasComputed: false,
+        list: [],
+        map: new Map()
+      },
+      static: {
+        hasComputed: false,
+        list: [],
+        map: new Map()
+      }
+    }
+  };
+  const setState = newState => {
+    Object.assign(classState, newState);
+  };
+  const findThisesVisitor = _traverse.visitors.environmentVisitor({
+    ThisExpression(path) {
+      classState.superThises.push(path);
+    }
+  });
+  function createClassHelper(args) {
+    return _core.types.callExpression(classState.file.addHelper("createClass"), args);
+  }
+  function maybeCreateConstructor() {
+    const classBodyPath = classState.path.get("body");
+    for (const path of classBodyPath.get("body")) {
+      if (path.isClassMethod({
+        kind: "constructor"
+      })) return;
+    }
+    let params, body;
+    if (classState.isDerived) {
+      const constructor = _core.template.expression.ast`
+        (function () {
+          super(...arguments);
+        })
+      `;
+      params = constructor.params;
+      body = constructor.body;
+    } else {
+      params = [];
+      body = _core.types.blockStatement([]);
+    }
+    classBodyPath.unshiftContainer("body", _core.types.classMethod("constructor", _core.types.identifier("constructor"), params, body));
+  }
+  function buildBody() {
+    maybeCreateConstructor();
+    pushBody();
+    verifyConstructor();
+    if (classState.userConstructor) {
+      const {
+        constructorBody,
+        userConstructor,
+        construct
+      } = classState;
+      constructorBody.body.push(...userConstructor.body.body);
+      _core.types.inherits(construct, userConstructor);
+      _core.types.inherits(constructorBody, userConstructor.body);
+    }
+    pushDescriptors();
+  }
+  function pushBody() {
+    const classBodyPaths = classState.path.get("body.body");
+    for (const path of classBodyPaths) {
+      const node = path.node;
+      if (path.isClassProperty() || path.isClassPrivateProperty()) {
+        throw path.buildCodeFrameError("Missing class properties transform.");
+      }
+      if (node.decorators) {
+        throw path.buildCodeFrameError("Method has decorators, put the decorator plugin before the classes one.");
+      }
+      if (_core.types.isClassMethod(node)) {
+        const isConstructor = node.kind === "constructor";
+        const replaceSupers = new _helperReplaceSupers.default({
+          methodPath: path,
+          objectRef: classState.classRef,
+          superRef: classState.superName,
+          constantSuper: assumptions.constantSuper,
+          file: classState.file,
+          refToPreserve: classState.classRef
+        });
+        replaceSupers.replace();
+        const superReturns = [];
+        path.traverse(_traverse.visitors.environmentVisitor({
+          ReturnStatement(path) {
+            if (!path.getFunctionParent().isArrowFunctionExpression()) {
+              superReturns.push(path);
+            }
+          }
+        }));
+        if (isConstructor) {
+          pushConstructor(superReturns, node, path);
+        } else {
+          {
+            var _path$ensureFunctionN;
+            (_path$ensureFunctionN = path.ensureFunctionName) != null ? _path$ensureFunctionN : path.ensureFunctionName = require("@babel/traverse").NodePath.prototype.ensureFunctionName;
+          }
+          path.ensureFunctionName(supportUnicodeId);
+          let wrapped;
+          if (node !== path.node) {
+            wrapped = path.node;
+            path.replaceWith(node);
+          }
+          pushMethod(node, wrapped);
+        }
+      }
+    }
+  }
+  function pushDescriptors() {
+    pushInheritsToBody();
+    const {
+      body
+    } = classState;
+    const props = {
+      instance: null,
+      static: null
+    };
+    for (const placement of ["static", "instance"]) {
+      if (classState.methods[placement].list.length) {
+        props[placement] = classState.methods[placement].list.map(desc => {
+          const obj = _core.types.objectExpression([_core.types.objectProperty(_core.types.identifier("key"), desc.key)]);
+          for (const kind of ["get", "set", "value"]) {
+            if (desc[kind] != null) {
+              obj.properties.push(_core.types.objectProperty(_core.types.identifier(kind), desc[kind]));
+            }
+          }
+          return obj;
+        });
+      }
+    }
+    if (props.instance || props.static) {
+      let args = [_core.types.cloneNode(classState.classRef), props.instance ? _core.types.arrayExpression(props.instance) : _core.types.nullLiteral(), props.static ? _core.types.arrayExpression(props.static) : _core.types.nullLiteral()];
+      let lastNonNullIndex = 0;
+      for (let i = 0; i < args.length; i++) {
+        if (!_core.types.isNullLiteral(args[i])) lastNonNullIndex = i;
+      }
+      args = args.slice(0, lastNonNullIndex + 1);
+      body.push(_core.types.returnStatement(createClassHelper(args)));
+      classState.pushedCreateClass = true;
+    }
+  }
+  function wrapSuperCall(bareSuper, superRef, thisRef, body) {
+    const bareSuperNode = bareSuper.node;
+    let call;
+    if (assumptions.superIsCallableConstructor) {
+      bareSuperNode.arguments.unshift(_core.types.thisExpression());
+      if (bareSuperNode.arguments.length === 2 && _core.types.isSpreadElement(bareSuperNode.arguments[1]) && _core.types.isIdentifier(bareSuperNode.arguments[1].argument, {
+        name: "arguments"
+      })) {
+        bareSuperNode.arguments[1] = bareSuperNode.arguments[1].argument;
+        bareSuperNode.callee = _core.types.memberExpression(_core.types.cloneNode(superRef), _core.types.identifier("apply"));
+      } else {
+        bareSuperNode.callee = _core.types.memberExpression(_core.types.cloneNode(superRef), _core.types.identifier("call"));
+      }
+      call = _core.types.logicalExpression("||", bareSuperNode, _core.types.thisExpression());
+    } else {
+      var _bareSuperNode$argume;
+      const args = [_core.types.thisExpression(), _core.types.cloneNode(classState.classRef)];
+      if ((_bareSuperNode$argume = bareSuperNode.arguments) != null && _bareSuperNode$argume.length) {
+        const bareSuperNodeArguments = bareSuperNode.arguments;
+        if (bareSuperNodeArguments.length === 1 && _core.types.isSpreadElement(bareSuperNodeArguments[0]) && _core.types.isIdentifier(bareSuperNodeArguments[0].argument, {
+          name: "arguments"
+        })) {
+          args.push(bareSuperNodeArguments[0].argument);
+        } else {
+          args.push(_core.types.arrayExpression(bareSuperNodeArguments));
+        }
+      }
+      call = _core.types.callExpression((0, _inlineCallSuperHelpers.default)(classState.file), args);
+    }
+    if (bareSuper.parentPath.isExpressionStatement() && bareSuper.parentPath.container === body.node.body && body.node.body.length - 1 === bareSuper.parentPath.key) {
+      if (classState.superThises.length) {
+        call = _core.types.assignmentExpression("=", thisRef(), call);
+      }
+      bareSuper.parentPath.replaceWith(_core.types.returnStatement(call));
+    } else {
+      bareSuper.replaceWith(_core.types.assignmentExpression("=", thisRef(), call));
+    }
+  }
+  function verifyConstructor() {
+    if (!classState.isDerived) return;
+    const path = classState.userConstructorPath;
+    const body = path.get("body");
+    const constructorBody = path.get("body");
+    let maxGuaranteedSuperBeforeIndex = constructorBody.node.body.length;
+    path.traverse(findThisesVisitor);
+    let thisRef = function () {
+      const ref = path.scope.generateDeclaredUidIdentifier("this");
+      maxGuaranteedSuperBeforeIndex++;
+      thisRef = () => _core.types.cloneNode(ref);
+      return ref;
+    };
+    const buildAssertThisInitialized = function () {
+      return _core.types.callExpression(classState.file.addHelper("assertThisInitialized"), [thisRef()]);
+    };
+    const bareSupers = [];
+    path.traverse(_traverse.visitors.environmentVisitor({
+      Super(path) {
+        const {
+          node,
+          parentPath
+        } = path;
+        if (parentPath.isCallExpression({
+          callee: node
+        })) {
+          bareSupers.unshift(parentPath);
+        }
+      }
+    }));
+    for (const bareSuper of bareSupers) {
+      wrapSuperCall(bareSuper, classState.superName, thisRef, body);
+      if (maxGuaranteedSuperBeforeIndex >= 0) {
+        let lastParentPath;
+        bareSuper.find(function (parentPath) {
+          if (parentPath === constructorBody) {
+            maxGuaranteedSuperBeforeIndex = Math.min(maxGuaranteedSuperBeforeIndex, lastParentPath.key);
+            return true;
+          }
+          const {
+            type
+          } = parentPath;
+          switch (type) {
+            case "ExpressionStatement":
+            case "SequenceExpression":
+            case "AssignmentExpression":
+            case "BinaryExpression":
+            case "MemberExpression":
+            case "CallExpression":
+            case "NewExpression":
+            case "VariableDeclarator":
+            case "VariableDeclaration":
+            case "BlockStatement":
+            case "ArrayExpression":
+            case "ObjectExpression":
+            case "ObjectProperty":
+            case "TemplateLiteral":
+              lastParentPath = parentPath;
+              return false;
+            default:
+              if (type === "LogicalExpression" && parentPath.node.left === lastParentPath.node || parentPath.isConditional() && parentPath.node.test === lastParentPath.node || type === "OptionalCallExpression" && parentPath.node.callee === lastParentPath.node || type === "OptionalMemberExpression" && parentPath.node.object === lastParentPath.node) {
+                lastParentPath = parentPath;
+                return false;
+              }
+          }
+          maxGuaranteedSuperBeforeIndex = -1;
+          return true;
+        });
+      }
+    }
+    const guaranteedCalls = new Set();
+    for (const thisPath of classState.superThises) {
+      const {
+        node,
+        parentPath
+      } = thisPath;
+      if (parentPath.isMemberExpression({
+        object: node
+      })) {
+        thisPath.replaceWith(thisRef());
+        continue;
+      }
+      let thisIndex;
+      thisPath.find(function (parentPath) {
+        if (parentPath.parentPath === constructorBody) {
+          thisIndex = parentPath.key;
+          return true;
+        }
+      });
+      let exprPath = thisPath.parentPath.isSequenceExpression() ? thisPath.parentPath : thisPath;
+      if (exprPath.listKey === "arguments" && (exprPath.parentPath.isCallExpression() || exprPath.parentPath.isOptionalCallExpression())) {
+        exprPath = exprPath.parentPath;
+      } else {
+        exprPath = null;
+      }
+      if (maxGuaranteedSuperBeforeIndex !== -1 && thisIndex > maxGuaranteedSuperBeforeIndex || guaranteedCalls.has(exprPath)) {
+        thisPath.replaceWith(thisRef());
+      } else {
+        if (exprPath) {
+          guaranteedCalls.add(exprPath);
+        }
+        thisPath.replaceWith(buildAssertThisInitialized());
+      }
+    }
+    let wrapReturn;
+    if (classState.isLoose) {
+      wrapReturn = returnArg => {
+        const thisExpr = buildAssertThisInitialized();
+        return returnArg ? _core.types.logicalExpression("||", returnArg, thisExpr) : thisExpr;
+      };
+    } else {
+      wrapReturn = returnArg => {
+        const returnParams = [thisRef()];
+        if (returnArg != null) {
+          returnParams.push(returnArg);
+        }
+        return _core.types.callExpression(classState.file.addHelper("possibleConstructorReturn"), returnParams);
+      };
+    }
+    const bodyPaths = body.get("body");
+    const guaranteedSuperBeforeFinish = maxGuaranteedSuperBeforeIndex !== -1 && maxGuaranteedSuperBeforeIndex < bodyPaths.length;
+    if (!bodyPaths.length || !bodyPaths.pop().isReturnStatement()) {
+      body.pushContainer("body", _core.types.returnStatement(guaranteedSuperBeforeFinish ? thisRef() : buildAssertThisInitialized()));
+    }
+    for (const returnPath of classState.superReturns) {
+      returnPath.get("argument").replaceWith(wrapReturn(returnPath.node.argument));
+    }
+  }
+  function pushMethod(node, wrapped) {
+    if (node.kind === "method") {
+      if (processMethod(node)) return;
+    }
+    const placement = node.static ? "static" : "instance";
+    const methods = classState.methods[placement];
+    const descKey = node.kind === "method" ? "value" : node.kind;
+    const key = _core.types.isNumericLiteral(node.key) || _core.types.isBigIntLiteral(node.key) ? _core.types.stringLiteral(String(node.key.value)) : _core.types.toComputedKey(node);
+    methods.hasComputed = !_core.types.isStringLiteral(key);
+    const fn = wrapped != null ? wrapped : _core.types.toExpression(node);
+    let descriptor;
+    if (!methods.hasComputed && methods.map.has(key.value)) {
+      descriptor = methods.map.get(key.value);
+      descriptor[descKey] = fn;
+      if (descKey === "value") {
+        descriptor.get = null;
+        descriptor.set = null;
+      } else {
+        descriptor.value = null;
+      }
+    } else {
+      descriptor = {
+        key: key,
+        [descKey]: fn
+      };
+      methods.list.push(descriptor);
+      if (!methods.hasComputed) {
+        methods.map.set(key.value, descriptor);
+      }
+    }
+  }
+  function processMethod(node) {
+    if (assumptions.setClassMethods && !node.decorators) {
+      let {
+        classRef
+      } = classState;
+      if (!node.static) {
+        insertProtoAliasOnce();
+        classRef = classState.protoAlias;
+      }
+      const methodName = _core.types.memberExpression(_core.types.cloneNode(classRef), node.key, node.computed || _core.types.isLiteral(node.key));
+      const func = _core.types.functionExpression(node.id, node.params, node.body, node.generator, node.async);
+      _core.types.inherits(func, node);
+      const expr = _core.types.expressionStatement(_core.types.assignmentExpression("=", methodName, func));
+      _core.types.inheritsComments(expr, node);
+      classState.body.push(expr);
+      return true;
+    }
+    return false;
+  }
+  function insertProtoAliasOnce() {
+    if (classState.protoAlias === null) {
+      setState({
+        protoAlias: classState.scope.generateUidIdentifier("proto")
+      });
+      const classProto = _core.types.memberExpression(classState.classRef, _core.types.identifier("prototype"));
+      const protoDeclaration = _core.types.variableDeclaration("var", [_core.types.variableDeclarator(classState.protoAlias, classProto)]);
+      classState.body.push(protoDeclaration);
+    }
+  }
+  function pushConstructor(superReturns, method, path) {
+    setState({
+      userConstructorPath: path,
+      userConstructor: method,
+      hasConstructor: true,
+      superReturns
+    });
+    const {
+      construct
+    } = classState;
+    _core.types.inheritsComments(construct, method);
+    construct.params = method.params;
+    _core.types.inherits(construct.body, method.body);
+    construct.body.directives = method.body.directives;
+    if (classState.hasInstanceDescriptors || classState.hasStaticDescriptors) {
+      pushDescriptors();
+    }
+    pushInheritsToBody();
+  }
+  function pushInheritsToBody() {
+    if (!classState.isDerived || classState.pushedInherits) return;
+    classState.pushedInherits = true;
+    classState.body.unshift(_core.types.expressionStatement(_core.types.callExpression(classState.file.addHelper(classState.isLoose ? "inheritsLoose" : "inherits"), [_core.types.cloneNode(classState.classRef), _core.types.cloneNode(classState.superName)])));
+  }
+  function extractDynamicKeys() {
+    const {
+      dynamicKeys,
+      node,
+      scope
+    } = classState;
+    for (const elem of node.body.body) {
+      if (!_core.types.isClassMethod(elem) || !elem.computed) continue;
+      if (scope.isPure(elem.key, true)) continue;
+      const id = scope.generateUidIdentifierBasedOnNode(elem.key);
+      dynamicKeys.set(id.name, elem.key);
+      elem.key = id;
+    }
+  }
+  function setupClosureParamsArgs() {
+    const {
+      superName,
+      dynamicKeys
+    } = classState;
+    const closureParams = [];
+    const closureArgs = [];
+    if (classState.isDerived) {
+      let arg = _core.types.cloneNode(superName);
+      if (classState.extendsNative) {
+        arg = _core.types.callExpression(classState.file.addHelper("wrapNativeSuper"), [arg]);
+        (0, _helperAnnotateAsPure.default)(arg);
+      }
+      const param = classState.scope.generateUidIdentifierBasedOnNode(superName);
+      closureParams.push(param);
+      closureArgs.push(arg);
+      setState({
+        superName: _core.types.cloneNode(param)
+      });
+    }
+    for (const [name, value] of dynamicKeys) {
+      closureParams.push(_core.types.identifier(name));
+      closureArgs.push(value);
+    }
+    return {
+      closureParams,
+      closureArgs
+    };
+  }
+  function classTransformer(path, file, builtinClasses, isLoose) {
+    setState({
+      parent: path.parent,
+      scope: path.scope,
+      node: path.node,
+      path,
+      file,
+      isLoose
+    });
+    setState({
+      classId: classState.node.id,
+      classRef: classState.node.id ? _core.types.identifier(classState.node.id.name) : classState.scope.generateUidIdentifier("class"),
+      superName: classState.node.superClass,
+      isDerived: !!classState.node.superClass,
+      constructorBody: _core.types.blockStatement([])
+    });
+    setState({
+      extendsNative: _core.types.isIdentifier(classState.superName) && builtinClasses.has(classState.superName.name) && !classState.scope.hasBinding(classState.superName.name, true)
+    });
+    const {
+      classRef,
+      node,
+      constructorBody
+    } = classState;
+    setState({
+      construct: buildConstructor(classRef, constructorBody, node)
+    });
+    extractDynamicKeys();
+    const {
+      body
+    } = classState;
+    const {
+      closureParams,
+      closureArgs
+    } = setupClosureParamsArgs();
+    buildBody();
+    if (!assumptions.noClassCalls) {
+      constructorBody.body.unshift(_core.types.expressionStatement(_core.types.callExpression(classState.file.addHelper("classCallCheck"), [_core.types.thisExpression(), _core.types.cloneNode(classState.classRef)])));
+    }
+    const isStrict = path.isInStrictMode();
+    let constructorOnly = body.length === 0;
+    if (constructorOnly && !isStrict) {
+      for (const param of classState.construct.params) {
+        if (!_core.types.isIdentifier(param)) {
+          constructorOnly = false;
+          break;
+        }
+      }
+    }
+    const directives = constructorOnly ? classState.construct.body.directives : [];
+    if (!isStrict) {
+      directives.push(_core.types.directive(_core.types.directiveLiteral("use strict")));
+    }
+    if (constructorOnly) {
+      const expr = _core.types.toExpression(classState.construct);
+      return classState.isLoose ? expr : createClassHelper([expr]);
+    }
+    if (!classState.pushedCreateClass) {
+      body.push(_core.types.returnStatement(classState.isLoose ? _core.types.cloneNode(classState.classRef) : createClassHelper([_core.types.cloneNode(classState.classRef)])));
+    }
+    body.unshift(classState.construct);
+    const container = _core.types.arrowFunctionExpression(closureParams, _core.types.blockStatement(body, directives));
+    return _core.types.callExpression(container, closureArgs);
+  }
+  return classTransformer(path, file, builtinClasses, isLoose);
+}
+
+//# sourceMappingURL=transformClass.js.map

node_modules/@babel/plugin-transform-computed-properties/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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-transform-computed-properties/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-computed-properties
+
+> Compile ES2015 computed properties to ES5
+
+See our website [@babel/plugin-transform-computed-properties](https://babeljs.io/docs/babel-plugin-transform-computed-properties) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-computed-properties
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-computed-properties --dev
+```

node_modules/@babel/plugin-transform-computed-properties/lib/index.js

@@ -0,0 +1,168 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _core = require("@babel/core");
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+var _template = require("@babel/template");
+{
+  var DefineAccessorHelper = _template.default.expression.ast`
+    function (type, obj, key, fn) {
+      var desc = { configurable: true, enumerable: true };
+      desc[type] = fn;
+      return Object.defineProperty(obj, key, desc);
+    }
+  `;
+  DefineAccessorHelper._compact = true;
+}
+var _default = exports.default = (0, _helperPluginUtils.declare)((api, options) => {
+  var _api$assumption;
+  api.assertVersion(7);
+  const setComputedProperties = (_api$assumption = api.assumption("setComputedProperties")) != null ? _api$assumption : options.loose;
+  const pushComputedProps = setComputedProperties ? pushComputedPropsLoose : pushComputedPropsSpec;
+  function buildDefineAccessor(state, obj, prop) {
+    const type = prop.kind;
+    const key = !prop.computed && _core.types.isIdentifier(prop.key) ? _core.types.stringLiteral(prop.key.name) : prop.key;
+    const fn = getValue(prop);
+    {
+      let helper;
+      if (state.availableHelper("defineAccessor")) {
+        helper = state.addHelper("defineAccessor");
+      } else {
+        const file = state.file;
+        helper = file.get("fallbackDefineAccessorHelper");
+        if (!helper) {
+          const id = file.scope.generateUidIdentifier("defineAccessor");
+          file.scope.push({
+            id,
+            init: DefineAccessorHelper
+          });
+          file.set("fallbackDefineAccessorHelper", helper = id);
+        }
+        helper = _core.types.cloneNode(helper);
+      }
+      return _core.types.callExpression(helper, [_core.types.stringLiteral(type), obj, key, fn]);
+    }
+  }
+  function getValue(prop) {
+    if (_core.types.isObjectProperty(prop)) {
+      return prop.value;
+    } else if (_core.types.isObjectMethod(prop)) {
+      return _core.types.functionExpression(null, prop.params, prop.body, prop.generator, prop.async);
+    }
+  }
+  function pushAssign(objId, prop, body) {
+    body.push(_core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.memberExpression(_core.types.cloneNode(objId), prop.key, prop.computed || _core.types.isLiteral(prop.key)), getValue(prop))));
+  }
+  function pushComputedPropsLoose(info) {
+    const {
+      computedProps,
+      state,
+      initPropExpression,
+      objId,
+      body
+    } = info;
+    for (const prop of computedProps) {
+      if (_core.types.isObjectMethod(prop) && (prop.kind === "get" || prop.kind === "set")) {
+        if (computedProps.length === 1) {
+          return buildDefineAccessor(state, initPropExpression, prop);
+        } else {
+          body.push(_core.types.expressionStatement(buildDefineAccessor(state, _core.types.cloneNode(objId), prop)));
+        }
+      } else {
+        pushAssign(_core.types.cloneNode(objId), prop, body);
+      }
+    }
+  }
+  function pushComputedPropsSpec(info) {
+    const {
+      objId,
+      body,
+      computedProps,
+      state
+    } = info;
+    const CHUNK_LENGTH_CAP = 10;
+    let currentChunk = null;
+    const computedPropsChunks = [];
+    for (const prop of computedProps) {
+      if (!currentChunk || currentChunk.length === CHUNK_LENGTH_CAP) {
+        currentChunk = [];
+        computedPropsChunks.push(currentChunk);
+      }
+      currentChunk.push(prop);
+    }
+    for (const chunk of computedPropsChunks) {
+      const single = computedPropsChunks.length === 1;
+      let node = single ? info.initPropExpression : _core.types.cloneNode(objId);
+      for (const prop of chunk) {
+        if (_core.types.isObjectMethod(prop) && (prop.kind === "get" || prop.kind === "set")) {
+          node = buildDefineAccessor(info.state, node, prop);
+        } else {
+          node = _core.types.callExpression(state.addHelper("defineProperty"), [node, _core.types.toComputedKey(prop), getValue(prop)]);
+        }
+      }
+      if (single) return node;
+      body.push(_core.types.expressionStatement(node));
+    }
+  }
+  return {
+    name: "transform-computed-properties",
+    visitor: {
+      ObjectExpression: {
+        exit(path, state) {
+          const {
+            node,
+            parent,
+            scope
+          } = path;
+          let hasComputed = false;
+          for (const prop of node.properties) {
+            hasComputed = prop.computed === true;
+            if (hasComputed) break;
+          }
+          if (!hasComputed) return;
+          const initProps = [];
+          const computedProps = [];
+          let foundComputed = false;
+          for (const prop of node.properties) {
+            if (_core.types.isSpreadElement(prop)) {
+              continue;
+            }
+            if (prop.computed) {
+              foundComputed = true;
+            }
+            if (foundComputed) {
+              computedProps.push(prop);
+            } else {
+              initProps.push(prop);
+            }
+          }
+          const objId = scope.generateUidIdentifierBasedOnNode(parent);
+          const initPropExpression = _core.types.objectExpression(initProps);
+          const body = [];
+          body.push(_core.types.variableDeclaration("var", [_core.types.variableDeclarator(objId, initPropExpression)]));
+          const single = pushComputedProps({
+            scope,
+            objId,
+            body,
+            computedProps,
+            initPropExpression,
+            state
+          });
+          if (single) {
+            path.replaceWith(single);
+          } else {
+            if (setComputedProperties) {
+              body.push(_core.types.expressionStatement(_core.types.cloneNode(objId)));
+            }
+            path.replaceWithMultiple(body);
+          }
+        }
+      }
+    }
+  };
+});
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/plugin-transform-computed-properties/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@babel/plugin-transform-computed-properties",
+  "version": "7.25.9",
+  "description": "Compile ES2015 computed properties to ES5",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-plugin-transform-computed-properties"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-plugin-transform-computed-properties",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "^7.25.9",
+    "@babel/template": "^7.25.9"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.9",
+    "@babel/helper-plugin-test-runner": "^7.25.9"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}

node_modules/@babel/plugin-transform-destructuring/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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-transform-destructuring/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-destructuring
+
+> Compile ES2015 destructuring to ES5
+
+See our website [@babel/plugin-transform-destructuring](https://babeljs.io/docs/babel-plugin-transform-destructuring) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-destructuring
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-destructuring --dev
+```

node_modules/@babel/plugin-transform-destructuring/lib/index.js

@@ -0,0 +1,577 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helperPluginUtils = require('@babel/helper-plugin-utils');
+var core = require('@babel/core');
+
+function isPureVoid(node) {
+  return core.types.isUnaryExpression(node) && node.operator === "void" && core.types.isPureish(node.argument);
+}
+function unshiftForXStatementBody(statementPath, newStatements) {
+  statementPath.ensureBlock();
+  const {
+    scope,
+    node
+  } = statementPath;
+  const bodyScopeBindings = statementPath.get("body").scope.bindings;
+  const hasShadowedBlockScopedBindings = Object.keys(bodyScopeBindings).some(name => scope.hasBinding(name));
+  if (hasShadowedBlockScopedBindings) {
+    node.body = core.types.blockStatement([...newStatements, node.body]);
+  } else {
+    node.body.body.unshift(...newStatements);
+  }
+}
+function hasArrayRest(pattern) {
+  return pattern.elements.some(elem => core.types.isRestElement(elem));
+}
+function hasObjectRest(pattern) {
+  return pattern.properties.some(prop => core.types.isRestElement(prop));
+}
+const STOP_TRAVERSAL = {};
+const arrayUnpackVisitor = (node, ancestors, state) => {
+  if (!ancestors.length) {
+    return;
+  }
+  if (core.types.isIdentifier(node) && core.types.isReferenced(node, ancestors[ancestors.length - 1].node) && state.bindings[node.name]) {
+    state.deopt = true;
+    throw STOP_TRAVERSAL;
+  }
+};
+class DestructuringTransformer {
+  constructor(opts) {
+    this.blockHoist = void 0;
+    this.operator = void 0;
+    this.arrayRefSet = void 0;
+    this.nodes = void 0;
+    this.scope = void 0;
+    this.kind = void 0;
+    this.iterableIsArray = void 0;
+    this.arrayLikeIsIterable = void 0;
+    this.objectRestNoSymbols = void 0;
+    this.useBuiltIns = void 0;
+    this.addHelper = void 0;
+    this.blockHoist = opts.blockHoist;
+    this.operator = opts.operator;
+    this.arrayRefSet = new Set();
+    this.nodes = opts.nodes || [];
+    this.scope = opts.scope;
+    this.kind = opts.kind;
+    this.iterableIsArray = opts.iterableIsArray;
+    this.arrayLikeIsIterable = opts.arrayLikeIsIterable;
+    this.objectRestNoSymbols = opts.objectRestNoSymbols;
+    this.useBuiltIns = opts.useBuiltIns;
+    this.addHelper = opts.addHelper;
+  }
+  getExtendsHelper() {
+    return this.useBuiltIns ? core.types.memberExpression(core.types.identifier("Object"), core.types.identifier("assign")) : this.addHelper("extends");
+  }
+  buildVariableAssignment(id, init) {
+    let op = this.operator;
+    if (core.types.isMemberExpression(id) || core.types.isOptionalMemberExpression(id)) op = "=";
+    let node;
+    if (op) {
+      node = core.types.expressionStatement(core.types.assignmentExpression(op, id, core.types.cloneNode(init) || this.scope.buildUndefinedNode()));
+    } else {
+      let nodeInit;
+      if ((this.kind === "const" || this.kind === "using") && init === null) {
+        nodeInit = this.scope.buildUndefinedNode();
+      } else {
+        nodeInit = core.types.cloneNode(init);
+      }
+      node = core.types.variableDeclaration(this.kind, [core.types.variableDeclarator(id, nodeInit)]);
+    }
+    node._blockHoist = this.blockHoist;
+    return node;
+  }
+  buildVariableDeclaration(id, init) {
+    const declar = core.types.variableDeclaration("var", [core.types.variableDeclarator(core.types.cloneNode(id), core.types.cloneNode(init))]);
+    declar._blockHoist = this.blockHoist;
+    return declar;
+  }
+  push(id, _init) {
+    const init = core.types.cloneNode(_init);
+    if (core.types.isObjectPattern(id)) {
+      this.pushObjectPattern(id, init);
+    } else if (core.types.isArrayPattern(id)) {
+      this.pushArrayPattern(id, init);
+    } else if (core.types.isAssignmentPattern(id)) {
+      this.pushAssignmentPattern(id, init);
+    } else {
+      this.nodes.push(this.buildVariableAssignment(id, init));
+    }
+  }
+  toArray(node, count) {
+    if (this.iterableIsArray || core.types.isIdentifier(node) && this.arrayRefSet.has(node.name)) {
+      return node;
+    } else {
+      const {
+        scope,
+        arrayLikeIsIterable
+      } = this;
+      if (core.types.isIdentifier(node)) {
+        const binding = scope.getBinding(node.name);
+        if (binding != null && binding.constant && binding.path.isGenericType("Array")) {
+          return node;
+        }
+      }
+      if (core.types.isArrayExpression(node)) {
+        return node;
+      }
+      if (core.types.isIdentifier(node, {
+        name: "arguments"
+      })) {
+        return core.template.expression.ast`
+          Array.prototype.slice.call(${node})
+        `;
+      }
+      let helperName;
+      const args = [node];
+      if (typeof count === "number") {
+        args.push(core.types.numericLiteral(count));
+        helperName = "slicedToArray";
+      } else {
+        helperName = "toArray";
+      }
+      if (arrayLikeIsIterable) {
+        args.unshift(scope.path.hub.addHelper(helperName));
+        helperName = "maybeArrayLike";
+      }
+      return core.types.callExpression(scope.path.hub.addHelper(helperName), args);
+    }
+  }
+  pushAssignmentPattern({
+    left,
+    right
+  }, valueRef) {
+    if (isPureVoid(valueRef)) {
+      this.push(left, right);
+      return;
+    }
+    const tempId = this.scope.generateUidIdentifierBasedOnNode(valueRef);
+    this.nodes.push(this.buildVariableDeclaration(tempId, valueRef));
+    const tempConditional = core.types.conditionalExpression(core.types.binaryExpression("===", core.types.cloneNode(tempId), this.scope.buildUndefinedNode()), right, core.types.cloneNode(tempId));
+    if (core.types.isPattern(left)) {
+      let patternId;
+      let node;
+      if (this.kind === "const" || this.kind === "let" || this.kind === "using") {
+        patternId = this.scope.generateUidIdentifier(tempId.name);
+        node = this.buildVariableDeclaration(patternId, tempConditional);
+      } else {
+        patternId = tempId;
+        node = core.types.expressionStatement(core.types.assignmentExpression("=", core.types.cloneNode(tempId), tempConditional));
+      }
+      this.nodes.push(node);
+      this.push(left, patternId);
+    } else {
+      this.nodes.push(this.buildVariableAssignment(left, tempConditional));
+    }
+  }
+  pushObjectRest(pattern, objRef, spreadProp, spreadPropIndex) {
+    const value = buildObjectExcludingKeys(pattern.properties.slice(0, spreadPropIndex), objRef, this.scope, name => this.addHelper(name), this.objectRestNoSymbols, this.useBuiltIns);
+    this.nodes.push(this.buildVariableAssignment(spreadProp.argument, value));
+  }
+  pushObjectProperty(prop, propRef) {
+    if (core.types.isLiteral(prop.key)) prop.computed = true;
+    const pattern = prop.value;
+    const objRef = core.types.memberExpression(core.types.cloneNode(propRef), prop.key, prop.computed);
+    if (core.types.isPattern(pattern)) {
+      this.push(pattern, objRef);
+    } else {
+      this.nodes.push(this.buildVariableAssignment(pattern, objRef));
+    }
+  }
+  pushObjectPattern(pattern, objRef) {
+    if (!pattern.properties.length) {
+      this.nodes.push(core.types.expressionStatement(core.types.callExpression(this.addHelper("objectDestructuringEmpty"), isPureVoid(objRef) ? [] : [objRef])));
+      return;
+    }
+    if (pattern.properties.length > 1 && !this.scope.isStatic(objRef)) {
+      const temp = this.scope.generateUidIdentifierBasedOnNode(objRef);
+      this.nodes.push(this.buildVariableDeclaration(temp, objRef));
+      objRef = temp;
+    }
+    if (hasObjectRest(pattern)) {
+      let copiedPattern;
+      for (let i = 0; i < pattern.properties.length; i++) {
+        const prop = pattern.properties[i];
+        if (core.types.isRestElement(prop)) {
+          break;
+        }
+        const key = prop.key;
+        if (prop.computed && !this.scope.isPure(key)) {
+          const name = this.scope.generateUidIdentifierBasedOnNode(key);
+          this.nodes.push(this.buildVariableDeclaration(name, key));
+          if (!copiedPattern) {
+            copiedPattern = pattern = Object.assign({}, pattern, {
+              properties: pattern.properties.slice()
+            });
+          }
+          copiedPattern.properties[i] = Object.assign({}, prop, {
+            key: name
+          });
+        }
+      }
+    }
+    for (let i = 0; i < pattern.properties.length; i++) {
+      const prop = pattern.properties[i];
+      if (core.types.isRestElement(prop)) {
+        this.pushObjectRest(pattern, objRef, prop, i);
+      } else {
+        this.pushObjectProperty(prop, objRef);
+      }
+    }
+  }
+  canUnpackArrayPattern(pattern, arr) {
+    if (!core.types.isArrayExpression(arr)) return false;
+    if (pattern.elements.length > arr.elements.length) return;
+    if (pattern.elements.length < arr.elements.length && !hasArrayRest(pattern)) {
+      return false;
+    }
+    for (const elem of pattern.elements) {
+      if (!elem) return false;
+      if (core.types.isMemberExpression(elem)) return false;
+    }
+    for (const elem of arr.elements) {
+      if (core.types.isSpreadElement(elem)) return false;
+      if (core.types.isCallExpression(elem)) return false;
+      if (core.types.isMemberExpression(elem)) return false;
+    }
+    const bindings = core.types.getBindingIdentifiers(pattern);
+    const state = {
+      deopt: false,
+      bindings
+    };
+    try {
+      core.types.traverse(arr, arrayUnpackVisitor, state);
+    } catch (e) {
+      if (e !== STOP_TRAVERSAL) throw e;
+    }
+    return !state.deopt;
+  }
+  pushUnpackedArrayPattern(pattern, arr) {
+    const holeToUndefined = el => el != null ? el : this.scope.buildUndefinedNode();
+    for (let i = 0; i < pattern.elements.length; i++) {
+      const elem = pattern.elements[i];
+      if (core.types.isRestElement(elem)) {
+        this.push(elem.argument, core.types.arrayExpression(arr.elements.slice(i).map(holeToUndefined)));
+      } else {
+        this.push(elem, holeToUndefined(arr.elements[i]));
+      }
+    }
+  }
+  pushArrayPattern(pattern, arrayRef) {
+    if (arrayRef === null) {
+      this.nodes.push(core.types.expressionStatement(core.types.callExpression(this.addHelper("objectDestructuringEmpty"), [])));
+      return;
+    }
+    if (!pattern.elements) return;
+    if (this.canUnpackArrayPattern(pattern, arrayRef)) {
+      this.pushUnpackedArrayPattern(pattern, arrayRef);
+      return;
+    }
+    const count = !hasArrayRest(pattern) && pattern.elements.length;
+    const toArray = this.toArray(arrayRef, count);
+    if (core.types.isIdentifier(toArray)) {
+      arrayRef = toArray;
+    } else {
+      arrayRef = this.scope.generateUidIdentifierBasedOnNode(arrayRef);
+      this.arrayRefSet.add(arrayRef.name);
+      this.nodes.push(this.buildVariableDeclaration(arrayRef, toArray));
+    }
+    for (let i = 0; i < pattern.elements.length; i++) {
+      const elem = pattern.elements[i];
+      if (!elem) continue;
+      let elemRef;
+      if (core.types.isRestElement(elem)) {
+        elemRef = this.toArray(arrayRef);
+        elemRef = core.types.callExpression(core.types.memberExpression(elemRef, core.types.identifier("slice")), [core.types.numericLiteral(i)]);
+        this.push(elem.argument, elemRef);
+      } else {
+        elemRef = core.types.memberExpression(arrayRef, core.types.numericLiteral(i), true);
+        this.push(elem, elemRef);
+      }
+    }
+  }
+  init(pattern, ref) {
+    if (!core.types.isArrayExpression(ref) && !core.types.isMemberExpression(ref)) {
+      const memo = this.scope.maybeGenerateMemoised(ref, true);
+      if (memo) {
+        this.nodes.push(this.buildVariableDeclaration(memo, core.types.cloneNode(ref)));
+        ref = memo;
+      }
+    }
+    this.push(pattern, ref);
+    return this.nodes;
+  }
+}
+function buildObjectExcludingKeys(excludedKeys, objRef, scope, addHelper, objectRestNoSymbols, useBuiltIns) {
+  const keys = [];
+  let allLiteral = true;
+  let hasTemplateLiteral = false;
+  for (let i = 0; i < excludedKeys.length; i++) {
+    const prop = excludedKeys[i];
+    const key = prop.key;
+    if (core.types.isIdentifier(key) && !prop.computed) {
+      keys.push(core.types.stringLiteral(key.name));
+    } else if (core.types.isTemplateLiteral(key)) {
+      keys.push(core.types.cloneNode(key));
+      hasTemplateLiteral = true;
+    } else if (core.types.isLiteral(key)) {
+      keys.push(core.types.stringLiteral(String(key.value)));
+    } else if (core.types.isPrivateName(key)) ; else {
+      keys.push(core.types.cloneNode(key));
+      allLiteral = false;
+    }
+  }
+  let value;
+  if (keys.length === 0) {
+    const extendsHelper = useBuiltIns ? core.types.memberExpression(core.types.identifier("Object"), core.types.identifier("assign")) : addHelper("extends");
+    value = core.types.callExpression(extendsHelper, [core.types.objectExpression([]), core.types.sequenceExpression([core.types.callExpression(addHelper("objectDestructuringEmpty"), [core.types.cloneNode(objRef)]), core.types.cloneNode(objRef)])]);
+  } else {
+    let keyExpression = core.types.arrayExpression(keys);
+    if (!allLiteral) {
+      keyExpression = core.types.callExpression(core.types.memberExpression(keyExpression, core.types.identifier("map")), [addHelper("toPropertyKey")]);
+    } else if (!hasTemplateLiteral && !core.types.isProgram(scope.block)) {
+      const programScope = scope.getProgramParent();
+      const id = programScope.generateUidIdentifier("excluded");
+      programScope.push({
+        id,
+        init: keyExpression,
+        kind: "const"
+      });
+      keyExpression = core.types.cloneNode(id);
+    }
+    value = core.types.callExpression(addHelper(`objectWithoutProperties${objectRestNoSymbols ? "Loose" : ""}`), [core.types.cloneNode(objRef), keyExpression]);
+  }
+  return value;
+}
+function convertVariableDeclaration(path, addHelper, arrayLikeIsIterable, iterableIsArray, objectRestNoSymbols, useBuiltIns) {
+  const {
+    node,
+    scope
+  } = path;
+  const nodeKind = node.kind;
+  const nodeLoc = node.loc;
+  const nodes = [];
+  for (let i = 0; i < node.declarations.length; i++) {
+    const declar = node.declarations[i];
+    const patternId = declar.init;
+    const pattern = declar.id;
+    const destructuring = new DestructuringTransformer({
+      blockHoist: node._blockHoist,
+      nodes: nodes,
+      scope: scope,
+      kind: node.kind,
+      iterableIsArray,
+      arrayLikeIsIterable,
+      useBuiltIns,
+      objectRestNoSymbols,
+      addHelper
+    });
+    if (core.types.isPattern(pattern)) {
+      destructuring.init(pattern, patternId);
+      if (+i !== node.declarations.length - 1) {
+        core.types.inherits(nodes[nodes.length - 1], declar);
+      }
+    } else {
+      nodes.push(core.types.inherits(destructuring.buildVariableAssignment(pattern, patternId), declar));
+    }
+  }
+  let tail = null;
+  let nodesOut = [];
+  for (const node of nodes) {
+    if (core.types.isVariableDeclaration(node)) {
+      if (tail !== null) {
+        tail.declarations.push(...node.declarations);
+        continue;
+      } else {
+        node.kind = nodeKind;
+        tail = node;
+      }
+    } else {
+      tail = null;
+    }
+    if (!node.loc) {
+      node.loc = nodeLoc;
+    }
+    nodesOut.push(node);
+  }
+  if (nodesOut.length === 2 && core.types.isVariableDeclaration(nodesOut[0]) && core.types.isExpressionStatement(nodesOut[1]) && core.types.isCallExpression(nodesOut[1].expression) && nodesOut[0].declarations.length === 1) {
+    const expr = nodesOut[1].expression;
+    expr.arguments = [nodesOut[0].declarations[0].init];
+    nodesOut = [expr];
+  } else {
+    if (core.types.isForStatement(path.parent, {
+      init: node
+    }) && !nodesOut.some(v => core.types.isVariableDeclaration(v))) {
+      for (let i = 0; i < nodesOut.length; i++) {
+        const node = nodesOut[i];
+        if (core.types.isExpressionStatement(node)) {
+          nodesOut[i] = node.expression;
+        }
+      }
+    }
+  }
+  if (nodesOut.length === 1) {
+    path.replaceWith(nodesOut[0]);
+  } else {
+    path.replaceWithMultiple(nodesOut);
+  }
+  scope.crawl();
+}
+function convertAssignmentExpression(path, addHelper, arrayLikeIsIterable, iterableIsArray, objectRestNoSymbols, useBuiltIns) {
+  const {
+    node,
+    scope,
+    parentPath
+  } = path;
+  const nodes = [];
+  const destructuring = new DestructuringTransformer({
+    operator: node.operator,
+    scope: scope,
+    nodes: nodes,
+    arrayLikeIsIterable,
+    iterableIsArray,
+    objectRestNoSymbols,
+    useBuiltIns,
+    addHelper
+  });
+  let ref;
+  if (!parentPath.isExpressionStatement() && !parentPath.isSequenceExpression() || path.isCompletionRecord()) {
+    ref = scope.generateUidIdentifierBasedOnNode(node.right, "ref");
+    nodes.push(core.types.variableDeclaration("var", [core.types.variableDeclarator(ref, node.right)]));
+    if (core.types.isArrayExpression(node.right)) {
+      destructuring.arrayRefSet.add(ref.name);
+    }
+  }
+  destructuring.init(node.left, ref || node.right);
+  if (ref) {
+    if (parentPath.isArrowFunctionExpression()) {
+      path.replaceWith(core.types.blockStatement([]));
+      nodes.push(core.types.returnStatement(core.types.cloneNode(ref)));
+    } else {
+      nodes.push(core.types.expressionStatement(core.types.cloneNode(ref)));
+    }
+  }
+  path.replaceWithMultiple(nodes);
+  scope.crawl();
+}
+
+function variableDeclarationHasPattern(node) {
+  for (const declar of node.declarations) {
+    if (core.types.isPattern(declar.id)) {
+      return true;
+    }
+  }
+  return false;
+}
+var index = helperPluginUtils.declare((api, options) => {
+  var _ref, _api$assumption, _ref2, _options$allowArrayLi, _ref3, _api$assumption2;
+  api.assertVersion(7);
+  const {
+    useBuiltIns = false
+  } = options;
+  const iterableIsArray = (_ref = (_api$assumption = api.assumption("iterableIsArray")) != null ? _api$assumption : options.loose) != null ? _ref : false;
+  const arrayLikeIsIterable = (_ref2 = (_options$allowArrayLi = options.allowArrayLike) != null ? _options$allowArrayLi : api.assumption("arrayLikeIsIterable")) != null ? _ref2 : false;
+  const objectRestNoSymbols = (_ref3 = (_api$assumption2 = api.assumption("objectRestNoSymbols")) != null ? _api$assumption2 : options.loose) != null ? _ref3 : false;
+  return {
+    name: "transform-destructuring",
+    visitor: {
+      ExportNamedDeclaration(path) {
+        const declaration = path.get("declaration");
+        if (!declaration.isVariableDeclaration()) return;
+        if (!variableDeclarationHasPattern(declaration.node)) return;
+        const specifiers = [];
+        for (const name of Object.keys(path.getOuterBindingIdentifiers())) {
+          specifiers.push(core.types.exportSpecifier(core.types.identifier(name), core.types.identifier(name)));
+        }
+        path.replaceWith(declaration.node);
+        path.insertAfter(core.types.exportNamedDeclaration(null, specifiers));
+        path.scope.crawl();
+      },
+      ForXStatement(path) {
+        const {
+          node,
+          scope
+        } = path;
+        const left = node.left;
+        if (core.types.isPattern(left)) {
+          const temp = scope.generateUidIdentifier("ref");
+          node.left = core.types.variableDeclaration("var", [core.types.variableDeclarator(temp)]);
+          path.ensureBlock();
+          const statementBody = path.node.body.body;
+          const nodes = [];
+          if (statementBody.length === 0 && path.isCompletionRecord()) {
+            nodes.unshift(core.types.expressionStatement(scope.buildUndefinedNode()));
+          }
+          nodes.unshift(core.types.expressionStatement(core.types.assignmentExpression("=", left, core.types.cloneNode(temp))));
+          unshiftForXStatementBody(path, nodes);
+          scope.crawl();
+          return;
+        }
+        if (!core.types.isVariableDeclaration(left)) return;
+        const pattern = left.declarations[0].id;
+        if (!core.types.isPattern(pattern)) return;
+        const key = scope.generateUidIdentifier("ref");
+        node.left = core.types.variableDeclaration(left.kind, [core.types.variableDeclarator(key, null)]);
+        const nodes = [];
+        const destructuring = new DestructuringTransformer({
+          kind: left.kind,
+          scope: scope,
+          nodes: nodes,
+          arrayLikeIsIterable,
+          iterableIsArray,
+          objectRestNoSymbols,
+          useBuiltIns,
+          addHelper: name => this.addHelper(name)
+        });
+        destructuring.init(pattern, key);
+        unshiftForXStatementBody(path, nodes);
+        scope.crawl();
+      },
+      CatchClause({
+        node,
+        scope
+      }) {
+        const pattern = node.param;
+        if (!core.types.isPattern(pattern)) return;
+        const ref = scope.generateUidIdentifier("ref");
+        node.param = ref;
+        const nodes = [];
+        const destructuring = new DestructuringTransformer({
+          kind: "let",
+          scope: scope,
+          nodes: nodes,
+          arrayLikeIsIterable,
+          iterableIsArray,
+          objectRestNoSymbols,
+          useBuiltIns,
+          addHelper: name => this.addHelper(name)
+        });
+        destructuring.init(pattern, ref);
+        node.body.body = [...nodes, ...node.body.body];
+        scope.crawl();
+      },
+      AssignmentExpression(path, state) {
+        if (!core.types.isPattern(path.node.left)) return;
+        convertAssignmentExpression(path, name => state.addHelper(name), arrayLikeIsIterable, iterableIsArray, objectRestNoSymbols, useBuiltIns);
+      },
+      VariableDeclaration(path, state) {
+        const {
+          node,
+          parent
+        } = path;
+        if (core.types.isForXStatement(parent)) return;
+        if (!parent || !path.container) return;
+        if (!variableDeclarationHasPattern(node)) return;
+        convertVariableDeclaration(path, name => state.addHelper(name), arrayLikeIsIterable, iterableIsArray, objectRestNoSymbols, useBuiltIns);
+      }
+    }
+  };
+});
+
+exports.buildObjectExcludingKeys = buildObjectExcludingKeys;
+exports.default = index;
+exports.unshiftForXStatementBody = unshiftForXStatementBody;
+//# sourceMappingURL=index.js.map

node_modules/@babel/plugin-transform-destructuring/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@babel/plugin-transform-destructuring",
+  "version": "7.25.9",
+  "description": "Compile ES2015 destructuring to ES5",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-plugin-transform-destructuring"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-plugin-transform-destructuring",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "^7.25.9"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.9",
+    "@babel/helper-plugin-test-runner": "^7.25.9",
+    "@babel/traverse": "^7.25.9"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}

node_modules/@babel/plugin-transform-dotall-regex/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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-transform-dotall-regex/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-dotall-regex
+
+> Compile regular expressions using the `s` (`dotAll`) flag to ES5.
+
+See our website [@babel/plugin-transform-dotall-regex](https://babeljs.io/docs/babel-plugin-transform-dotall-regex) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-dotall-regex
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-dotall-regex --dev
+```

node_modules/@babel/plugin-transform-dotall-regex/lib/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helperCreateRegexpFeaturesPlugin = require("@babel/helper-create-regexp-features-plugin");
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+var _default = exports.default = (0, _helperPluginUtils.declare)(api => {
+  api.assertVersion("^7.0.0-0 || >8.0.0-alpha <8.0.0-beta");
+  return (0, _helperCreateRegexpFeaturesPlugin.createRegExpFeaturePlugin)({
+    name: "transform-dotall-regex",
+    feature: "dotAllFlag"
+  });
+});
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/plugin-transform-dotall-regex/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_helperCreateRegexpFeaturesPlugin","require","_helperPluginUtils","_default","exports","default","declare","api","assertVersion","createRegExpFeaturePlugin","name","feature"],"sources":["../src/index.ts"],"sourcesContent":["/* eslint-disable @babel/development/plugin-name */\nimport { createRegExpFeaturePlugin } from \"@babel/helper-create-regexp-features-plugin\";\nimport { declare } from \"@babel/helper-plugin-utils\";\n\nexport default declare(api => {\n  api.assertVersion(REQUIRED_VERSION(7));\n\n  return createRegExpFeaturePlugin({\n    name: \"transform-dotall-regex\",\n    feature: \"dotAllFlag\",\n  });\n});\n"],"mappings":";;;;;;AACA,IAAAA,iCAAA,GAAAC,OAAA;AACA,IAAAC,kBAAA,GAAAD,OAAA;AAAqD,IAAAE,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAEtC,IAAAC,0BAAO,EAACC,GAAG,IAAI;EAC5BA,GAAG,CAACC,aAAa,uCAAoB,CAAC;EAEtC,OAAO,IAAAC,2DAAyB,EAAC;IAC/BC,IAAI,EAAE,wBAAwB;IAC9BC,OAAO,EAAE;EACX,CAAC,CAAC;AACJ,CAAC,CAAC","ignoreList":[]}

node_modules/@babel/plugin-transform-dotall-regex/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@babel/plugin-transform-dotall-regex",
+  "version": "7.25.9",
+  "description": "Compile regular expressions using the `s` (`dotAll`) flag to ES5.",
+  "homepage": "https://babel.dev/docs/en/next/babel-plugin-transform-dotall-regex",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "keywords": [
+    "babel-plugin",
+    "regex",
+    "regexp",
+    "regular expressions",
+    "dotall"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-plugin-transform-dotall-regex"
+  },
+  "bugs": "https://github.com/babel/babel/issues",
+  "dependencies": {
+    "@babel/helper-create-regexp-features-plugin": "^7.25.9",
+    "@babel/helper-plugin-utils": "^7.25.9"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.9",
+    "@babel/helper-plugin-test-runner": "^7.25.9"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}

node_modules/@babel/plugin-transform-duplicate-keys/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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-transform-duplicate-keys/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-duplicate-keys
+
+> Compile objects with duplicate keys to valid strict ES5
+
+See our website [@babel/plugin-transform-duplicate-keys](https://babeljs.io/docs/babel-plugin-transform-duplicate-keys) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-duplicate-keys
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-duplicate-keys --dev
+```

node_modules/@babel/plugin-transform-duplicate-keys/lib/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+var _core = require("@babel/core");
+function getName(key) {
+  if (_core.types.isIdentifier(key)) {
+    return key.name;
+  }
+  return key.value.toString();
+}
+var _default = exports.default = (0, _helperPluginUtils.declare)(api => {
+  api.assertVersion(7);
+  return {
+    name: "transform-duplicate-keys",
+    visitor: {
+      ObjectExpression(path) {
+        const {
+          node
+        } = path;
+        const plainProps = node.properties.filter(prop => !_core.types.isSpreadElement(prop) && !prop.computed);
+        const alreadySeenData = Object.create(null);
+        const alreadySeenGetters = Object.create(null);
+        const alreadySeenSetters = Object.create(null);
+        for (const prop of plainProps) {
+          const name = getName(prop.key);
+          let isDuplicate = false;
+          switch (prop.kind) {
+            case "get":
+              if (alreadySeenData[name] || alreadySeenGetters[name]) {
+                isDuplicate = true;
+              }
+              alreadySeenGetters[name] = true;
+              break;
+            case "set":
+              if (alreadySeenData[name] || alreadySeenSetters[name]) {
+                isDuplicate = true;
+              }
+              alreadySeenSetters[name] = true;
+              break;
+            default:
+              if (alreadySeenData[name] || alreadySeenGetters[name] || alreadySeenSetters[name]) {
+                isDuplicate = true;
+              }
+              alreadySeenData[name] = true;
+          }
+          if (isDuplicate) {
+            prop.computed = true;
+            prop.key = _core.types.stringLiteral(name);
+          }
+        }
+      }
+    }
+  };
+});
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/plugin-transform-duplicate-keys/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@babel/plugin-transform-duplicate-keys",
+  "version": "7.25.9",
+  "description": "Compile objects with duplicate keys to valid strict ES5",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-plugin-transform-duplicate-keys"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-plugin-transform-duplicate-keys",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "^7.25.9"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.9",
+    "@babel/helper-plugin-test-runner": "^7.25.9"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}

node_modules/@babel/plugin-transform-duplicate-named-capturing-groups-regex/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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-transform-duplicate-named-capturing-groups-regex/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-duplicate-named-capturing-groups-regex
+
+> Compile regular expressions using duplicate named groups to index-based groups.
+
+See our website [@babel/plugin-transform-duplicate-named-capturing-groups-regex](https://babeljs.io/docs/babel-plugin-transform-duplicate-named-capturing-groups-regex) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-duplicate-named-capturing-groups-regex
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-duplicate-named-capturing-groups-regex --dev
+```

node_modules/@babel/plugin-transform-duplicate-named-capturing-groups-regex/lib/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helperCreateRegexpFeaturesPlugin = require("@babel/helper-create-regexp-features-plugin");
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+var _default = exports.default = (0, _helperPluginUtils.declare)((api, options) => {
+  api.assertVersion("^7.19.0 || >8.0.0-alpha <8.0.0-beta");
+  const {
+    runtime
+  } = options;
+  if (runtime !== undefined && typeof runtime !== "boolean") {
+    throw new Error("The 'runtime' option must be boolean");
+  }
+  return (0, _helperCreateRegexpFeaturesPlugin.createRegExpFeaturePlugin)({
+    name: "transform-duplicate-named-capturing-groups-regex",
+    feature: "duplicateNamedCaptureGroups",
+    options: {
+      runtime
+    }
+  });
+});
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/plugin-transform-duplicate-named-capturing-groups-regex/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_helperCreateRegexpFeaturesPlugin","require","_helperPluginUtils","_default","exports","default","declare","api","options","assertVersion","runtime","undefined","Error","createRegExpFeaturePlugin","name","feature"],"sources":["../src/index.ts"],"sourcesContent":["/* eslint-disable @babel/development/plugin-name */\nimport { createRegExpFeaturePlugin } from \"@babel/helper-create-regexp-features-plugin\";\nimport { declare } from \"@babel/helper-plugin-utils\";\n\nexport interface Options {\n  runtime?: boolean;\n}\n\nexport default declare((api, options: Options) => {\n  api.assertVersion(REQUIRED_VERSION(\"^7.19.0\"));\n\n  const { runtime } = options;\n  if (runtime !== undefined && typeof runtime !== \"boolean\") {\n    throw new Error(\"The 'runtime' option must be boolean\");\n  }\n\n  return createRegExpFeaturePlugin({\n    name: \"transform-duplicate-named-capturing-groups-regex\",\n    feature: \"duplicateNamedCaptureGroups\",\n    options: { runtime },\n  });\n});\n"],"mappings":";;;;;;AACA,IAAAA,iCAAA,GAAAC,OAAA;AACA,IAAAC,kBAAA,GAAAD,OAAA;AAAqD,IAAAE,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAMtC,IAAAC,0BAAO,EAAC,CAACC,GAAG,EAAEC,OAAgB,KAAK;EAChDD,GAAG,CAACE,aAAa,sCAA4B,CAAC;EAE9C,MAAM;IAAEC;EAAQ,CAAC,GAAGF,OAAO;EAC3B,IAAIE,OAAO,KAAKC,SAAS,IAAI,OAAOD,OAAO,KAAK,SAAS,EAAE;IACzD,MAAM,IAAIE,KAAK,CAAC,sCAAsC,CAAC;EACzD;EAEA,OAAO,IAAAC,2DAAyB,EAAC;IAC/BC,IAAI,EAAE,kDAAkD;IACxDC,OAAO,EAAE,6BAA6B;IACtCP,OAAO,EAAE;MAAEE;IAAQ;EACrB,CAAC,CAAC;AACJ,CAAC,CAAC","ignoreList":[]}

node_modules/@babel/plugin-transform-duplicate-named-capturing-groups-regex/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@babel/plugin-transform-duplicate-named-capturing-groups-regex",
+  "version": "7.25.9",
+  "description": "Compile regular expressions using duplicate named groups to index-based groups.",
+  "homepage": "https://babel.dev/docs/en/next/babel-plugin-transform-duplicate-named-capturing-groups-regex",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "keywords": [
+    "babel-plugin",
+    "regex",
+    "regexp",
+    "regular expressions"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-plugin-transform-duplicate-named-capturing-groups-regex"
+  },
+  "bugs": "https://github.com/babel/babel/issues",
+  "dependencies": {
+    "@babel/helper-create-regexp-features-plugin": "^7.25.9",
+    "@babel/helper-plugin-utils": "^7.25.9"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.9",
+    "@babel/helper-plugin-test-runner": "^7.25.9",
+    "core-js": "^3.30.2"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "type": "commonjs"
+}

node_modules/@babel/plugin-transform-dynamic-import/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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-transform-dynamic-import/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-dynamic-import
+
+> Transform import() expressions
+
+See our website [@babel/plugin-transform-dynamic-import](https://babeljs.io/docs/babel-plugin-transform-dynamic-import) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-dynamic-import
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-dynamic-import --dev
+```

node_modules/@babel/plugin-transform-dynamic-import/lib/index.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+const SUPPORTED_MODULES = new Set(["commonjs", "amd", "systemjs"]);
+const MODULES_NOT_FOUND = `\
+@babel/plugin-transform-dynamic-import depends on a modules
+transform plugin. Supported plugins are:
+ - @babel/plugin-transform-modules-commonjs ^7.4.0
+ - @babel/plugin-transform-modules-amd ^7.4.0
+ - @babel/plugin-transform-modules-systemjs ^7.4.0
+
+If you are using Webpack or Rollup and thus don't want
+Babel to transpile your imports and exports, you can use
+the @babel/plugin-syntax-dynamic-import plugin and let your
+bundler handle dynamic imports.
+`;
+var _default = exports.default = (0, _helperPluginUtils.declare)(api => {
+  api.assertVersion(7);
+  return {
+    name: "transform-dynamic-import",
+    manipulateOptions: (_, parser) => parser.plugins.push("dynamicImport"),
+    pre() {
+      this.file.set("@babel/plugin-proposal-dynamic-import", "7.25.9");
+    },
+    visitor: {
+      Program() {
+        const modules = this.file.get("@babel/plugin-transform-modules-*");
+        if (!SUPPORTED_MODULES.has(modules)) {
+          throw new Error(MODULES_NOT_FOUND);
+        }
+      }
+    }
+  };
+});
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/plugin-transform-dynamic-import/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@babel/plugin-transform-dynamic-import",
+  "version": "7.25.9",
+  "description": "Transform import() expressions",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-plugin-transform-dynamic-import"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "^7.25.9"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.9",
+    "@babel/helper-plugin-test-runner": "^7.25.9"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}

node_modules/@babel/plugin-transform-exponentiation-operator/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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-transform-exponentiation-operator/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-exponentiation-operator
+
+> Compile exponentiation operator to ES5
+
+See our website [@babel/plugin-transform-exponentiation-operator](https://babeljs.io/docs/babel-plugin-transform-exponentiation-operator) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-exponentiation-operator
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-exponentiation-operator --dev
+```

node_modules/@babel/plugin-transform-exponentiation-operator/lib/index.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+var _default = exports.default = (0, _helperPluginUtils.declare)(api => {
+  api.assertVersion("^7.0.0-0 || >8.0.0-alpha <8.0.0-beta");
+  const {
+    types: t,
+    template
+  } = api;
+  function build(left, right) {
+    return t.callExpression(t.memberExpression(t.identifier("Math"), t.identifier("pow")), [left, right]);
+  }
+  function maybeMemoize(node, scope) {
+    if (scope.isStatic(node)) {
+      return {
+        assign: node,
+        ref: t.cloneNode(node)
+      };
+    }
+    if (scope.path.isPattern()) {
+      return null;
+    }
+    const id = scope.generateUidIdentifierBasedOnNode(node);
+    scope.push({
+      id
+    });
+    return {
+      assign: t.assignmentExpression("=", t.cloneNode(id), node),
+      ref: t.cloneNode(id)
+    };
+  }
+  return {
+    name: "transform-exponentiation-operator",
+    visitor: {
+      AssignmentExpression(path) {
+        const {
+          node,
+          scope
+        } = path;
+        if (node.operator !== "**=") return;
+        if (t.isMemberExpression(node.left)) {
+          let member1;
+          let member2;
+          const object = maybeMemoize(node.left.object, scope);
+          if (!object) {
+            path.replaceWith(template.expression.ast`(() => ${path.node})()`);
+            return;
+          }
+          const {
+            property,
+            computed
+          } = node.left;
+          if (computed) {
+            const prop = maybeMemoize(property, scope);
+            member1 = t.memberExpression(object.assign, prop.assign, true);
+            member2 = t.memberExpression(object.ref, prop.ref, true);
+          } else {
+            member1 = t.memberExpression(object.assign, property, false);
+            member2 = t.memberExpression(object.ref, t.cloneNode(property), false);
+          }
+          path.replaceWith(t.assignmentExpression("=", member1, build(member2, node.right)));
+        } else {
+          path.replaceWith(t.assignmentExpression("=", node.left, build(t.cloneNode(node.left), node.right)));
+        }
+      },
+      BinaryExpression(path) {
+        const {
+          node
+        } = path;
+        if (node.operator === "**") {
+          path.replaceWith(build(node.left, node.right));
+        }
+      }
+    }
+  };
+});
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/plugin-transform-exponentiation-operator/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@babel/plugin-transform-exponentiation-operator",
+  "version": "7.26.3",
+  "description": "Compile exponentiation operator to ES5",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-plugin-transform-exponentiation-operator"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-plugin-transform-exponentiation-operator",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "^7.25.9"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.26.0",
+    "@babel/helper-plugin-test-runner": "^7.25.9"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}

node_modules/@babel/plugin-transform-export-namespace-from/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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-transform-export-namespace-from/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-export-namespace-from
+
+> Compile export namespace to ES2015
+
+See our website [@babel/plugin-transform-export-namespace-from](https://babeljs.io/docs/babel-plugin-transform-export-namespace-from) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-export-namespace-from
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-export-namespace-from --dev
+```

node_modules/@babel/plugin-transform-export-namespace-from/lib/index.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+var _core = require("@babel/core");
+var _default = exports.default = (0, _helperPluginUtils.declare)(api => {
+  api.assertVersion(7);
+  return {
+    name: "transform-export-namespace-from",
+    manipulateOptions: (_, parser) => parser.plugins.push("exportNamespaceFrom"),
+    visitor: {
+      ExportNamedDeclaration(path) {
+        var _exported$name;
+        const {
+          node,
+          scope
+        } = path;
+        const {
+          specifiers
+        } = node;
+        const index = _core.types.isExportDefaultSpecifier(specifiers[0]) ? 1 : 0;
+        if (!_core.types.isExportNamespaceSpecifier(specifiers[index])) return;
+        const nodes = [];
+        if (index === 1) {
+          nodes.push(_core.types.exportNamedDeclaration(null, [specifiers.shift()], node.source));
+        }
+        const specifier = specifiers.shift();
+        const {
+          exported
+        } = specifier;
+        const uid = scope.generateUidIdentifier((_exported$name = exported.name) != null ? _exported$name : exported.value);
+        nodes.push(_core.types.importDeclaration([_core.types.importNamespaceSpecifier(uid)], _core.types.cloneNode(node.source)), _core.types.exportNamedDeclaration(null, [_core.types.exportSpecifier(_core.types.cloneNode(uid), exported)]));
+        if (node.specifiers.length >= 1) {
+          nodes.push(node);
+        }
+        const [importDeclaration] = path.replaceWithMultiple(nodes);
+        path.scope.registerDeclaration(importDeclaration);
+      }
+    }
+  };
+});
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/plugin-transform-export-namespace-from/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@babel/plugin-transform-export-namespace-from",
+  "version": "7.25.9",
+  "description": "Compile export namespace to ES2015",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-plugin-transform-export-namespace-from"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "^7.25.9"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.9",
+    "@babel/helper-plugin-test-runner": "^7.25.9"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-plugin-transform-export-namespace-from",
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}

node_modules/@babel/plugin-transform-for-of/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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-transform-for-of/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-for-of
+
+> Compile ES2015 for...of to ES5
+
+See our website [@babel/plugin-transform-for-of](https://babeljs.io/docs/babel-plugin-transform-for-of) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-for-of
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-for-of --dev
+```

node_modules/@babel/plugin-transform-for-of/lib/index.js

@@ -0,0 +1,194 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+var _core = require("@babel/core");
+var _noHelperImplementation = require("./no-helper-implementation.js");
+var _helperSkipTransparentExpressionWrappers = require("@babel/helper-skip-transparent-expression-wrappers");
+function buildLoopBody(path, declar, newBody) {
+  let block;
+  const bodyPath = path.get("body");
+  const body = newBody != null ? newBody : bodyPath.node;
+  if (_core.types.isBlockStatement(body) && Object.keys(path.getBindingIdentifiers()).some(id => bodyPath.scope.hasOwnBinding(id))) {
+    block = _core.types.blockStatement([declar, body]);
+  } else {
+    block = _core.types.toBlock(body);
+    block.body.unshift(declar);
+  }
+  return block;
+}
+var _default = exports.default = (0, _helperPluginUtils.declare)((api, options) => {
+  var _options$assumeArray, _options$allowArrayLi, _api$assumption;
+  api.assertVersion(7);
+  {
+    const {
+      assumeArray,
+      allowArrayLike,
+      loose
+    } = options;
+    if (loose === true && assumeArray === true) {
+      throw new Error(`The loose and assumeArray options cannot be used together in @babel/plugin-transform-for-of`);
+    }
+    if (assumeArray === true && allowArrayLike === true) {
+      throw new Error(`The assumeArray and allowArrayLike options cannot be used together in @babel/plugin-transform-for-of`);
+    }
+    {
+      if (allowArrayLike && /^7\.\d\./.test(api.version)) {
+        throw new Error(`The allowArrayLike is only supported when using @babel/core@^7.10.0`);
+      }
+    }
+  }
+  const iterableIsArray = (_options$assumeArray = options.assumeArray) != null ? _options$assumeArray : !options.loose && api.assumption("iterableIsArray");
+  const arrayLikeIsIterable = (_options$allowArrayLi = options.allowArrayLike) != null ? _options$allowArrayLi : api.assumption("arrayLikeIsIterable");
+  const skipIteratorClosing = (_api$assumption = api.assumption("skipForOfIteratorClosing")) != null ? _api$assumption : options.loose;
+  if (iterableIsArray && arrayLikeIsIterable) {
+    throw new Error(`The "iterableIsArray" and "arrayLikeIsIterable" assumptions are not compatible.`);
+  }
+  if (iterableIsArray) {
+    return {
+      name: "transform-for-of",
+      visitor: {
+        ForOfStatement(path) {
+          const {
+            scope
+          } = path;
+          const {
+            left,
+            await: isAwait
+          } = path.node;
+          if (isAwait) {
+            return;
+          }
+          const right = (0, _helperSkipTransparentExpressionWrappers.skipTransparentExprWrapperNodes)(path.node.right);
+          const i = scope.generateUidIdentifier("i");
+          let array = scope.maybeGenerateMemoised(right, true);
+          if (!array && _core.types.isIdentifier(right) && path.get("body").scope.hasOwnBinding(right.name)) {
+            array = scope.generateUidIdentifier("arr");
+          }
+          const inits = [_core.types.variableDeclarator(i, _core.types.numericLiteral(0))];
+          if (array) {
+            inits.push(_core.types.variableDeclarator(array, right));
+          } else {
+            array = right;
+          }
+          const item = _core.types.memberExpression(_core.types.cloneNode(array), _core.types.cloneNode(i), true);
+          let assignment;
+          if (_core.types.isVariableDeclaration(left)) {
+            assignment = left;
+            assignment.declarations[0].init = item;
+          } else {
+            assignment = _core.types.expressionStatement(_core.types.assignmentExpression("=", left, item));
+          }
+          path.replaceWith(_core.types.forStatement(_core.types.variableDeclaration("let", inits), _core.types.binaryExpression("<", _core.types.cloneNode(i), _core.types.memberExpression(_core.types.cloneNode(array), _core.types.identifier("length"))), _core.types.updateExpression("++", _core.types.cloneNode(i)), buildLoopBody(path, assignment)));
+        }
+      }
+    };
+  }
+  const buildForOfArray = (0, _core.template)`
+    for (var KEY = 0, NAME = ARR; KEY < NAME.length; KEY++) BODY;
+  `;
+  const buildForOfNoIteratorClosing = _core.template.statements`
+    for (var ITERATOR_HELPER = CREATE_ITERATOR_HELPER(OBJECT, ARRAY_LIKE_IS_ITERABLE), STEP_KEY;
+        !(STEP_KEY = ITERATOR_HELPER()).done;) BODY;
+  `;
+  const buildForOf = _core.template.statements`
+    var ITERATOR_HELPER = CREATE_ITERATOR_HELPER(OBJECT, ARRAY_LIKE_IS_ITERABLE), STEP_KEY;
+    try {
+      for (ITERATOR_HELPER.s(); !(STEP_KEY = ITERATOR_HELPER.n()).done;) BODY;
+    } catch (err) {
+      ITERATOR_HELPER.e(err);
+    } finally {
+      ITERATOR_HELPER.f();
+    }
+  `;
+  const builder = skipIteratorClosing ? {
+    build: buildForOfNoIteratorClosing,
+    helper: "createForOfIteratorHelperLoose",
+    getContainer: nodes => nodes
+  } : {
+    build: buildForOf,
+    helper: "createForOfIteratorHelper",
+    getContainer: nodes => nodes[1].block.body
+  };
+  function _ForOfStatementArray(path) {
+    const {
+      node,
+      scope
+    } = path;
+    const right = scope.generateUidIdentifierBasedOnNode(node.right, "arr");
+    const iterationKey = scope.generateUidIdentifier("i");
+    const loop = buildForOfArray({
+      BODY: node.body,
+      KEY: iterationKey,
+      NAME: right,
+      ARR: node.right
+    });
+    _core.types.inherits(loop, node);
+    const iterationValue = _core.types.memberExpression(_core.types.cloneNode(right), _core.types.cloneNode(iterationKey), true);
+    let declar;
+    const left = node.left;
+    if (_core.types.isVariableDeclaration(left)) {
+      left.declarations[0].init = iterationValue;
+      declar = left;
+    } else {
+      declar = _core.types.expressionStatement(_core.types.assignmentExpression("=", left, iterationValue));
+    }
+    loop.body = buildLoopBody(path, declar, loop.body);
+    return loop;
+  }
+  return {
+    name: "transform-for-of",
+    visitor: {
+      ForOfStatement(path, state) {
+        const right = path.get("right");
+        if (right.isArrayExpression() || right.isGenericType("Array") || _core.types.isArrayTypeAnnotation(right.getTypeAnnotation())) {
+          path.replaceWith(_ForOfStatementArray(path));
+          return;
+        }
+        {
+          if (!state.availableHelper(builder.helper)) {
+            (0, _noHelperImplementation.default)(skipIteratorClosing, path, state);
+            return;
+          }
+        }
+        const {
+          node,
+          parent,
+          scope
+        } = path;
+        const left = node.left;
+        let declar;
+        const stepKey = scope.generateUid("step");
+        const stepValue = _core.types.memberExpression(_core.types.identifier(stepKey), _core.types.identifier("value"));
+        if (_core.types.isVariableDeclaration(left)) {
+          declar = _core.types.variableDeclaration(left.kind, [_core.types.variableDeclarator(left.declarations[0].id, stepValue)]);
+        } else {
+          declar = _core.types.expressionStatement(_core.types.assignmentExpression("=", left, stepValue));
+        }
+        const nodes = builder.build({
+          CREATE_ITERATOR_HELPER: state.addHelper(builder.helper),
+          ITERATOR_HELPER: scope.generateUidIdentifier("iterator"),
+          ARRAY_LIKE_IS_ITERABLE: arrayLikeIsIterable ? _core.types.booleanLiteral(true) : null,
+          STEP_KEY: _core.types.identifier(stepKey),
+          OBJECT: node.right,
+          BODY: buildLoopBody(path, declar)
+        });
+        const container = builder.getContainer(nodes);
+        _core.types.inherits(container[0], node);
+        _core.types.inherits(container[0].body, node.body);
+        if (_core.types.isLabeledStatement(parent)) {
+          container[0] = _core.types.labeledStatement(parent.label, container[0]);
+          path.parentPath.replaceWithMultiple(nodes);
+          path.skip();
+        } else {
+          path.replaceWithMultiple(nodes);
+        }
+      }
+    }
+  };
+});
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/plugin-transform-for-of/lib/no-helper-implementation.js

@@ -0,0 +1,153 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformWithoutHelper;
+var _core = require("@babel/core");
+function transformWithoutHelper(loose, path, state) {
+  const pushComputedProps = loose ? pushComputedPropsLoose : pushComputedPropsSpec;
+  const {
+    node
+  } = path;
+  const build = pushComputedProps(path, state);
+  const declar = build.declar;
+  const loop = build.loop;
+  const block = loop.body;
+  path.ensureBlock();
+  if (declar) {
+    block.body.push(declar);
+  }
+  block.body.push(...node.body.body);
+  _core.types.inherits(loop, node);
+  _core.types.inherits(loop.body, node.body);
+  if (build.replaceParent) {
+    path.parentPath.replaceWithMultiple(build.node);
+    path.remove();
+  } else {
+    path.replaceWithMultiple(build.node);
+  }
+}
+const buildForOfLoose = _core.template.statement(`
+  for (var LOOP_OBJECT = OBJECT,
+          IS_ARRAY = Array.isArray(LOOP_OBJECT),
+          INDEX = 0,
+          LOOP_OBJECT = IS_ARRAY ? LOOP_OBJECT : LOOP_OBJECT[Symbol.iterator]();;) {
+    INTERMEDIATE;
+    if (IS_ARRAY) {
+      if (INDEX >= LOOP_OBJECT.length) break;
+      ID = LOOP_OBJECT[INDEX++];
+    } else {
+      INDEX = LOOP_OBJECT.next();
+      if (INDEX.done) break;
+      ID = INDEX.value;
+    }
+  }
+`);
+const buildForOf = _core.template.statements(`
+  var ITERATOR_COMPLETION = true;
+  var ITERATOR_HAD_ERROR_KEY = false;
+  var ITERATOR_ERROR_KEY = undefined;
+  try {
+    for (
+      var ITERATOR_KEY = OBJECT[Symbol.iterator](), STEP_KEY;
+      !(ITERATOR_COMPLETION = (STEP_KEY = ITERATOR_KEY.next()).done);
+      ITERATOR_COMPLETION = true
+    ) {}
+  } catch (err) {
+    ITERATOR_HAD_ERROR_KEY = true;
+    ITERATOR_ERROR_KEY = err;
+  } finally {
+    try {
+      if (!ITERATOR_COMPLETION && ITERATOR_KEY.return != null) {
+        ITERATOR_KEY.return();
+      }
+    } finally {
+      if (ITERATOR_HAD_ERROR_KEY) {
+        throw ITERATOR_ERROR_KEY;
+      }
+    }
+  }
+`);
+function pushComputedPropsLoose(path, state) {
+  const {
+    node,
+    scope,
+    parent
+  } = path;
+  const {
+    left
+  } = node;
+  let declar, id, intermediate;
+  if (_core.types.isIdentifier(left) || _core.types.isPattern(left) || _core.types.isMemberExpression(left)) {
+    id = left;
+    intermediate = null;
+  } else if (_core.types.isVariableDeclaration(left)) {
+    id = scope.generateUidIdentifier("ref");
+    declar = _core.types.variableDeclaration(left.kind, [_core.types.variableDeclarator(left.declarations[0].id, _core.types.identifier(id.name))]);
+    intermediate = _core.types.variableDeclaration("var", [_core.types.variableDeclarator(_core.types.identifier(id.name))]);
+  } else {
+    throw state.buildCodeFrameError(left, `Unknown node type ${left.type} in ForStatement`);
+  }
+  const iteratorKey = scope.generateUidIdentifier("iterator");
+  const isArrayKey = scope.generateUidIdentifier("isArray");
+  const loop = buildForOfLoose({
+    LOOP_OBJECT: iteratorKey,
+    IS_ARRAY: isArrayKey,
+    OBJECT: node.right,
+    INDEX: scope.generateUidIdentifier("i"),
+    ID: id,
+    INTERMEDIATE: intermediate
+  });
+  const isLabeledParent = _core.types.isLabeledStatement(parent);
+  let labeled;
+  if (isLabeledParent) {
+    labeled = _core.types.labeledStatement(parent.label, loop);
+  }
+  return {
+    replaceParent: isLabeledParent,
+    declar: declar,
+    node: labeled || loop,
+    loop: loop
+  };
+}
+function pushComputedPropsSpec(path, state) {
+  const {
+    node,
+    scope,
+    parent
+  } = path;
+  const left = node.left;
+  let declar;
+  const stepKey = scope.generateUid("step");
+  const stepValue = _core.types.memberExpression(_core.types.identifier(stepKey), _core.types.identifier("value"));
+  if (_core.types.isIdentifier(left) || _core.types.isPattern(left) || _core.types.isMemberExpression(left)) {
+    declar = _core.types.expressionStatement(_core.types.assignmentExpression("=", left, stepValue));
+  } else if (_core.types.isVariableDeclaration(left)) {
+    declar = _core.types.variableDeclaration(left.kind, [_core.types.variableDeclarator(left.declarations[0].id, stepValue)]);
+  } else {
+    throw state.buildCodeFrameError(left, `Unknown node type ${left.type} in ForStatement`);
+  }
+  const template = buildForOf({
+    ITERATOR_HAD_ERROR_KEY: scope.generateUidIdentifier("didIteratorError"),
+    ITERATOR_COMPLETION: scope.generateUidIdentifier("iteratorNormalCompletion"),
+    ITERATOR_ERROR_KEY: scope.generateUidIdentifier("iteratorError"),
+    ITERATOR_KEY: scope.generateUidIdentifier("iterator"),
+    STEP_KEY: _core.types.identifier(stepKey),
+    OBJECT: node.right
+  });
+  const isLabeledParent = _core.types.isLabeledStatement(parent);
+  const tryBody = template[3].block.body;
+  const loop = tryBody[0];
+  if (isLabeledParent) {
+    tryBody[0] = _core.types.labeledStatement(parent.label, loop);
+  }
+  return {
+    replaceParent: isLabeledParent,
+    declar: declar,
+    loop: loop,
+    node: template
+  };
+}
+
+//# sourceMappingURL=no-helper-implementation.js.map

node_modules/@babel/plugin-transform-for-of/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@babel/plugin-transform-for-of",
+  "version": "7.25.9",
+  "description": "Compile ES2015 for...of to ES5",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-plugin-transform-for-of"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-plugin-transform-for-of",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "^7.25.9",
+    "@babel/helper-skip-transparent-expression-wrappers": "^7.25.9"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.9",
+    "@babel/helper-plugin-test-runner": "^7.25.9"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}

node_modules/@babel/plugin-transform-function-name/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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-transform-function-name/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-function-name
+
+> Apply ES2015 function.name semantics to all functions
+
+See our website [@babel/plugin-transform-function-name](https://babeljs.io/docs/babel-plugin-transform-function-name) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-function-name
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-function-name --dev
+```

node_modules/@babel/plugin-transform-function-name/lib/index.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helperCompilationTargets = require("@babel/helper-compilation-targets");
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+var _default = exports.default = (0, _helperPluginUtils.declare)(api => {
+  api.assertVersion(7);
+  const supportUnicodeId = !(0, _helperCompilationTargets.isRequired)("transform-unicode-escapes", api.targets());
+  return {
+    name: "transform-function-name",
+    visitor: {
+      FunctionExpression: {
+        exit(path) {
+          if (path.key !== "value" && !path.parentPath.isObjectProperty()) {
+            {
+              var _path$ensureFunctionN;
+              (_path$ensureFunctionN = path.ensureFunctionName) != null ? _path$ensureFunctionN : path.ensureFunctionName = require("@babel/traverse").NodePath.prototype.ensureFunctionName;
+            }
+            path.ensureFunctionName(supportUnicodeId);
+          }
+        }
+      },
+      ObjectProperty(path) {
+        const value = path.get("value");
+        if (value.isFunction()) {
+          {
+            var _value$ensureFunction;
+            (_value$ensureFunction = value.ensureFunctionName) != null ? _value$ensureFunction : value.ensureFunctionName = require("@babel/traverse").NodePath.prototype.ensureFunctionName;
+          }
+          value.ensureFunctionName(supportUnicodeId);
+        }
+      }
+    }
+  };
+});
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/plugin-transform-function-name/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@babel/plugin-transform-function-name",
+  "version": "7.25.9",
+  "description": "Apply ES2015 function.name semantics to all functions",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-plugin-transform-function-name"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-plugin-transform-function-name",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-compilation-targets": "^7.25.9",
+    "@babel/helper-plugin-utils": "^7.25.9",
+    "@babel/traverse": "^7.25.9"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.9",
+    "@babel/helper-plugin-test-runner": "^7.25.9"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}

node_modules/@babel/plugin-transform-json-strings/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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-transform-json-strings/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-json-strings
+
+> Escape U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR in JS strings
+
+See our website [@babel/plugin-transform-json-strings](https://babeljs.io/docs/babel-plugin-transform-json-strings) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-json-strings
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-json-strings --dev
+```

node_modules/@babel/plugin-transform-json-strings/lib/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+var _default = exports.default = (0, _helperPluginUtils.declare)(api => {
+  api.assertVersion("^7.0.0-0 || >8.0.0-alpha <8.0.0-beta");
+  const regex = /(\\*)([\u2028\u2029])/g;
+  function replace(match, escapes, separator) {
+    const isEscaped = escapes.length % 2 === 1;
+    if (isEscaped) return match;
+    return `${escapes}\\u${separator.charCodeAt(0).toString(16)}`;
+  }
+  return {
+    name: "transform-json-strings",
+    manipulateOptions: (_, parser) => parser.plugins.push("jsonStrings"),
+    visitor: {
+      "DirectiveLiteral|StringLiteral"({
+        node
+      }) {
+        const {
+          extra
+        } = node;
+        if (!(extra != null && extra.raw)) return;
+        extra.raw = extra.raw.replace(regex, replace);
+      }
+    }
+  };
+});
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/plugin-transform-json-strings/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@babel/plugin-transform-json-strings",
+  "version": "7.25.9",
+  "description": "Escape U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR in JS strings",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-plugin-transform-json-strings"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-plugin-transform-json-strings",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "^7.25.9"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.9",
+    "@babel/helper-plugin-test-runner": "^7.25.9"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}

node_modules/@babel/plugin-transform-literals/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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-transform-literals/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-literals
+
+> Compile ES2015 unicode string and number literals to ES5
+
+See our website [@babel/plugin-transform-literals](https://babeljs.io/docs/babel-plugin-transform-literals) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-literals
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-literals --dev
+```

node_modules/@babel/plugin-transform-literals/lib/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+var _default = exports.default = (0, _helperPluginUtils.declare)(api => {
+  api.assertVersion(7);
+  return {
+    name: "transform-literals",
+    visitor: {
+      NumericLiteral({
+        node
+      }) {
+        if (node.extra && /^0[ob]/i.test(node.extra.raw)) {
+          node.extra = undefined;
+        }
+      },
+      StringLiteral({
+        node
+      }) {
+        if (node.extra && /\\u/i.test(node.extra.raw)) {
+          node.extra = undefined;
+        }
+      }
+    }
+  };
+});
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/plugin-transform-literals/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_helperPluginUtils","require","_default","exports","default","declare","api","assertVersion","name","visitor","NumericLiteral","node","extra","test","raw","undefined","StringLiteral"],"sources":["../src/index.ts"],"sourcesContent":["import { declare } from \"@babel/helper-plugin-utils\";\n\nexport default declare(api => {\n  api.assertVersion(REQUIRED_VERSION(7));\n\n  return {\n    name: \"transform-literals\",\n\n    visitor: {\n      NumericLiteral({ node }) {\n        // number octal like 0b10 or 0o70\n        // @ts-expect-error Add node.extra typings\n        if (node.extra && /^0[ob]/i.test(node.extra.raw)) {\n          node.extra = undefined;\n        }\n      },\n\n      StringLiteral({ node }) {\n        // unicode escape\n        // @ts-expect-error Add node.extra typings\n        if (node.extra && /\\\\u/i.test(node.extra.raw)) {\n          node.extra = undefined;\n        }\n      },\n    },\n  };\n});\n"],"mappings":";;;;;;AAAA,IAAAA,kBAAA,GAAAC,OAAA;AAAqD,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAEtC,IAAAC,0BAAO,EAACC,GAAG,IAAI;EAC5BA,GAAG,CAACC,aAAa,CAAkB,CAAE,CAAC;EAEtC,OAAO;IACLC,IAAI,EAAE,oBAAoB;IAE1BC,OAAO,EAAE;MACPC,cAAcA,CAAC;QAAEC;MAAK,CAAC,EAAE;QAGvB,IAAIA,IAAI,CAACC,KAAK,IAAI,SAAS,CAACC,IAAI,CAACF,IAAI,CAACC,KAAK,CAACE,GAAG,CAAC,EAAE;UAChDH,IAAI,CAACC,KAAK,GAAGG,SAAS;QACxB;MACF,CAAC;MAEDC,aAAaA,CAAC;QAAEL;MAAK,CAAC,EAAE;QAGtB,IAAIA,IAAI,CAACC,KAAK,IAAI,MAAM,CAACC,IAAI,CAACF,IAAI,CAACC,KAAK,CAACE,GAAG,CAAC,EAAE;UAC7CH,IAAI,CAACC,KAAK,GAAGG,SAAS;QACxB;MACF;IACF;EACF,CAAC;AACH,CAAC,CAAC","ignoreList":[]}

node_modules/@babel/plugin-transform-literals/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@babel/plugin-transform-literals",
+  "version": "7.25.9",
+  "description": "Compile ES2015 unicode string and number literals to ES5",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-plugin-transform-literals"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-plugin-transform-literals",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "^7.25.9"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.9",
+    "@babel/helper-plugin-test-runner": "^7.25.9"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}

node_modules/@babel/plugin-transform-logical-assignment-operators/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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-transform-logical-assignment-operators/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-logical-assignment-operators
+
+> Transforms logical assignment operators into short-circuited assignments
+
+See our website [@babel/plugin-transform-logical-assignment-operators](https://babeljs.io/docs/babel-plugin-transform-logical-assignment-operators) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-logical-assignment-operators
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-logical-assignment-operators --dev
+```

node_modules/@babel/plugin-transform-logical-assignment-operators/lib/index.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+var _core = require("@babel/core");
+var _default = exports.default = (0, _helperPluginUtils.declare)(api => {
+  api.assertVersion("^7.0.0-0 || >8.0.0-alpha <8.0.0-beta");
+  return {
+    name: "transform-logical-assignment-operators",
+    manipulateOptions: (_, parser) => parser.plugins.push("logicalAssignment"),
+    visitor: {
+      AssignmentExpression(path) {
+        const {
+          node,
+          scope
+        } = path;
+        const {
+          operator,
+          left,
+          right
+        } = node;
+        const operatorTrunc = operator.slice(0, -1);
+        if (!_core.types.LOGICAL_OPERATORS.includes(operatorTrunc)) {
+          return;
+        }
+        const lhs = _core.types.cloneNode(left);
+        if (_core.types.isMemberExpression(left)) {
+          const {
+            object,
+            property,
+            computed
+          } = left;
+          const memo = scope.maybeGenerateMemoised(object);
+          if (memo) {
+            left.object = memo;
+            lhs.object = _core.types.assignmentExpression("=", _core.types.cloneNode(memo), object);
+          }
+          if (computed) {
+            const memo = scope.maybeGenerateMemoised(property);
+            if (memo) {
+              left.property = memo;
+              lhs.property = _core.types.assignmentExpression("=", _core.types.cloneNode(memo), property);
+            }
+          }
+        }
+        path.replaceWith(_core.types.logicalExpression(operatorTrunc, lhs, _core.types.assignmentExpression("=", left, right)));
+      }
+    }
+  };
+});
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/plugin-transform-logical-assignment-operators/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@babel/plugin-transform-logical-assignment-operators",
+  "version": "7.25.9",
+  "description": "Transforms logical assignment operators into short-circuited assignments",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-plugin-transform-logical-assignment-operators"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "^7.25.9"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.9",
+    "@babel/helper-plugin-test-runner": "^7.25.9",
+    "@babel/plugin-transform-nullish-coalescing-operator": "^7.25.9"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-plugin-transform-logical-assignment-operators",
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}

node_modules/@babel/plugin-transform-member-expression-literals/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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-transform-member-expression-literals/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-member-expression-literals
+
+> Ensure that reserved words are quoted in property accesses
+
+See our website [@babel/plugin-transform-member-expression-literals](https://babeljs.io/docs/babel-plugin-transform-member-expression-literals) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-member-expression-literals
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-member-expression-literals --dev
+```

node_modules/@babel/plugin-transform-member-expression-literals/lib/index.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+var _core = require("@babel/core");
+var _default = exports.default = (0, _helperPluginUtils.declare)(api => {
+  api.assertVersion(7);
+  return {
+    name: "transform-member-expression-literals",
+    visitor: {
+      MemberExpression: {
+        exit({
+          node
+        }) {
+          const prop = node.property;
+          if (!node.computed && _core.types.isIdentifier(prop) && !_core.types.isValidES3Identifier(prop.name)) {
+            node.property = _core.types.stringLiteral(prop.name);
+            node.computed = true;
+          }
+        }
+      }
+    }
+  };
+});
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/plugin-transform-member-expression-literals/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_helperPluginUtils","require","_core","_default","exports","default","declare","api","assertVersion","name","visitor","MemberExpression","exit","node","prop","property","computed","t","isIdentifier","isValidES3Identifier","stringLiteral"],"sources":["../src/index.ts"],"sourcesContent":["import { declare } from \"@babel/helper-plugin-utils\";\nimport { types as t } from \"@babel/core\";\n\nexport default declare(api => {\n  api.assertVersion(REQUIRED_VERSION(7));\n\n  return {\n    name: \"transform-member-expression-literals\",\n\n    visitor: {\n      MemberExpression: {\n        exit({ node }) {\n          const prop = node.property;\n          if (\n            !node.computed &&\n            t.isIdentifier(prop) &&\n            !t.isValidES3Identifier(prop.name)\n          ) {\n            // foo.default -> foo[\"default\"]\n            node.property = t.stringLiteral(prop.name);\n            node.computed = true;\n          }\n        },\n      },\n    },\n  };\n});\n"],"mappings":";;;;;;AAAA,IAAAA,kBAAA,GAAAC,OAAA;AACA,IAAAC,KAAA,GAAAD,OAAA;AAAyC,IAAAE,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAE1B,IAAAC,0BAAO,EAACC,GAAG,IAAI;EAC5BA,GAAG,CAACC,aAAa,CAAkB,CAAE,CAAC;EAEtC,OAAO;IACLC,IAAI,EAAE,sCAAsC;IAE5CC,OAAO,EAAE;MACPC,gBAAgB,EAAE;QAChBC,IAAIA,CAAC;UAAEC;QAAK,CAAC,EAAE;UACb,MAAMC,IAAI,GAAGD,IAAI,CAACE,QAAQ;UAC1B,IACE,CAACF,IAAI,CAACG,QAAQ,IACdC,WAAC,CAACC,YAAY,CAACJ,IAAI,CAAC,IACpB,CAACG,WAAC,CAACE,oBAAoB,CAACL,IAAI,CAACL,IAAI,CAAC,EAClC;YAEAI,IAAI,CAACE,QAAQ,GAAGE,WAAC,CAACG,aAAa,CAACN,IAAI,CAACL,IAAI,CAAC;YAC1CI,IAAI,CAACG,QAAQ,GAAG,IAAI;UACtB;QACF;MACF;IACF;EACF,CAAC;AACH,CAAC,CAAC","ignoreList":[]}

node_modules/@babel/plugin-transform-member-expression-literals/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@babel/plugin-transform-member-expression-literals",
+  "version": "7.25.9",
+  "description": "Ensure that reserved words are quoted in property accesses",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-plugin-transform-member-expression-literals"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-plugin-transform-member-expression-literals",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "^7.25.9"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.9",
+    "@babel/helper-plugin-test-runner": "^7.25.9"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}

node_modules/@babel/plugin-transform-modules-amd/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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-transform-modules-amd/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-modules-amd
+
+> This plugin transforms ES2015 modules to AMD
+
+See our website [@babel/plugin-transform-modules-amd](https://babeljs.io/docs/babel-plugin-transform-modules-amd) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-modules-amd
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-modules-amd --dev
+```

node_modules/@babel/plugin-transform-modules-amd/lib/index.js

@@ -0,0 +1,144 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+var _helperModuleTransforms = require("@babel/helper-module-transforms");
+var _core = require("@babel/core");
+const buildWrapper = _core.template.statement(`
+  define(MODULE_NAME, AMD_ARGUMENTS, function(IMPORT_NAMES) {
+  })
+`);
+const buildAnonymousWrapper = _core.template.statement(`
+  define(["require"], function(REQUIRE) {
+  })
+`);
+function injectWrapper(path, wrapper) {
+  const {
+    body,
+    directives
+  } = path.node;
+  path.node.directives = [];
+  path.node.body = [];
+  const amdFactoryCall = path.pushContainer("body", wrapper)[0].get("expression");
+  const amdFactoryCallArgs = amdFactoryCall.get("arguments");
+  const amdFactory = amdFactoryCallArgs[amdFactoryCallArgs.length - 1].get("body");
+  amdFactory.pushContainer("directives", directives);
+  amdFactory.pushContainer("body", body);
+}
+var _default = exports.default = (0, _helperPluginUtils.declare)((api, options) => {
+  var _api$assumption, _api$assumption2;
+  api.assertVersion(7);
+  const {
+    allowTopLevelThis,
+    strict,
+    strictMode,
+    importInterop,
+    noInterop
+  } = options;
+  const constantReexports = (_api$assumption = api.assumption("constantReexports")) != null ? _api$assumption : options.loose;
+  const enumerableModuleMeta = (_api$assumption2 = api.assumption("enumerableModuleMeta")) != null ? _api$assumption2 : options.loose;
+  return {
+    name: "transform-modules-amd",
+    pre() {
+      this.file.set("@babel/plugin-transform-modules-*", "amd");
+    },
+    visitor: {
+      ["CallExpression" + (api.types.importExpression ? "|ImportExpression" : "")](path, state) {
+        if (!this.file.has("@babel/plugin-proposal-dynamic-import")) return;
+        if (path.isCallExpression() && !path.get("callee").isImport()) return;
+        let {
+          requireId,
+          resolveId,
+          rejectId
+        } = state;
+        if (!requireId) {
+          requireId = path.scope.generateUidIdentifier("require");
+          state.requireId = requireId;
+        }
+        if (!resolveId || !rejectId) {
+          resolveId = path.scope.generateUidIdentifier("resolve");
+          rejectId = path.scope.generateUidIdentifier("reject");
+          state.resolveId = resolveId;
+          state.rejectId = rejectId;
+        }
+        let result = _core.types.identifier("imported");
+        if (!noInterop) {
+          result = (0, _helperModuleTransforms.wrapInterop)(this.file.path, result, "namespace");
+        }
+        path.replaceWith((0, _helperModuleTransforms.buildDynamicImport)(path.node, false, false, specifier => _core.template.expression.ast`
+              new Promise((${resolveId}, ${rejectId}) =>
+                ${requireId}(
+                  [${specifier}],
+                  imported => ${_core.types.cloneNode(resolveId)}(${result}),
+                  ${_core.types.cloneNode(rejectId)}
+                )
+              )
+            `));
+      },
+      Program: {
+        exit(path, {
+          requireId
+        }) {
+          if (!(0, _helperModuleTransforms.isModule)(path)) {
+            if (requireId) {
+              injectWrapper(path, buildAnonymousWrapper({
+                REQUIRE: _core.types.cloneNode(requireId)
+              }));
+            }
+            return;
+          }
+          const amdArgs = [];
+          const importNames = [];
+          if (requireId) {
+            amdArgs.push(_core.types.stringLiteral("require"));
+            importNames.push(_core.types.cloneNode(requireId));
+          }
+          let moduleName = (0, _helperModuleTransforms.getModuleName)(this.file.opts, options);
+          if (moduleName) moduleName = _core.types.stringLiteral(moduleName);
+          const {
+            meta,
+            headers
+          } = (0, _helperModuleTransforms.rewriteModuleStatementsAndPrepareHeader)(path, {
+            enumerableModuleMeta,
+            constantReexports,
+            strict,
+            strictMode,
+            allowTopLevelThis,
+            importInterop,
+            noInterop,
+            filename: this.file.opts.filename
+          });
+          if ((0, _helperModuleTransforms.hasExports)(meta)) {
+            amdArgs.push(_core.types.stringLiteral("exports"));
+            importNames.push(_core.types.identifier(meta.exportName));
+          }
+          for (const [source, metadata] of meta.source) {
+            amdArgs.push(_core.types.stringLiteral(source));
+            importNames.push(_core.types.identifier(metadata.name));
+            if (!(0, _helperModuleTransforms.isSideEffectImport)(metadata)) {
+              const interop = (0, _helperModuleTransforms.wrapInterop)(path, _core.types.identifier(metadata.name), metadata.interop);
+              if (interop) {
+                const header = _core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.identifier(metadata.name), interop));
+                header.loc = metadata.loc;
+                headers.push(header);
+              }
+            }
+            headers.push(...(0, _helperModuleTransforms.buildNamespaceInitStatements)(meta, metadata, constantReexports));
+          }
+          (0, _helperModuleTransforms.ensureStatementsHoisted)(headers);
+          path.unshiftContainer("body", headers);
+          injectWrapper(path, buildWrapper({
+            MODULE_NAME: moduleName,
+            AMD_ARGUMENTS: _core.types.arrayExpression(amdArgs),
+            IMPORT_NAMES: importNames
+          }));
+        }
+      }
+    }
+  };
+});
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/plugin-transform-modules-amd/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@babel/plugin-transform-modules-amd",
+  "version": "7.25.9",
+  "description": "This plugin transforms ES2015 modules to AMD",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-plugin-transform-modules-amd"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-plugin-transform-modules-amd",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/helper-module-transforms": "^7.25.9",
+    "@babel/helper-plugin-utils": "^7.25.9"
+  },
+  "keywords": [
+    "babel-plugin"
+  ],
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.9",
+    "@babel/helper-plugin-test-runner": "^7.25.9",
+    "@babel/plugin-external-helpers": "^7.25.9"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}

node_modules/@babel/plugin-transform-modules-commonjs/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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-transform-modules-commonjs/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-modules-commonjs
+
+> This plugin transforms ES2015 modules to CommonJS
+
+See our website [@babel/plugin-transform-modules-commonjs](https://babeljs.io/docs/babel-plugin-transform-modules-commonjs) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-modules-commonjs
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-modules-commonjs --dev
+```

node_modules/@babel/plugin-transform-modules-commonjs/lib/dynamic-import.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformDynamicImport = transformDynamicImport;
+var _core = require("@babel/core");
+var _helperModuleTransforms = require("@babel/helper-module-transforms");
+const requireNoInterop = source => _core.template.expression.ast`require(${source})`;
+const requireInterop = (source, file) => _core.types.callExpression(file.addHelper("interopRequireWildcard"), [requireNoInterop(source)]);
+function transformDynamicImport(path, noInterop, file) {
+  const buildRequire = noInterop ? requireNoInterop : requireInterop;
+  path.replaceWith((0, _helperModuleTransforms.buildDynamicImport)(path.node, true, false, specifier => buildRequire(specifier, file)));
+}
+
+//# sourceMappingURL=dynamic-import.js.map

node_modules/@babel/plugin-transform-modules-commonjs/lib/dynamic-import.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_core","require","_helperModuleTransforms","requireNoInterop","source","template","expression","ast","requireInterop","file","t","callExpression","addHelper","transformDynamicImport","path","noInterop","buildRequire","replaceWith","buildDynamicImport","node","specifier"],"sources":["../src/dynamic-import.ts"],"sourcesContent":["// Heavily inspired by\n// https://github.com/airbnb/babel-plugin-dynamic-import-node/blob/master/src/utils.js\n\nimport type { File, NodePath } from \"@babel/core\";\nimport { types as t, template } from \"@babel/core\";\nimport { buildDynamicImport } from \"@babel/helper-module-transforms\";\n\nconst requireNoInterop = (source: t.Expression) =>\n  template.expression.ast`require(${source})`;\n\nconst requireInterop = (source: t.Expression, file: File) =>\n  t.callExpression(file.addHelper(\"interopRequireWildcard\"), [\n    requireNoInterop(source),\n  ]);\n\nexport function transformDynamicImport(\n  path: NodePath<t.CallExpression | t.ImportExpression>,\n  noInterop: boolean,\n  file: File,\n) {\n  const buildRequire = noInterop ? requireNoInterop : requireInterop;\n\n  path.replaceWith(\n    buildDynamicImport(path.node, true, false, specifier =>\n      buildRequire(specifier, file),\n    ),\n  );\n}\n"],"mappings":";;;;;;AAIA,IAAAA,KAAA,GAAAC,OAAA;AACA,IAAAC,uBAAA,GAAAD,OAAA;AAEA,MAAME,gBAAgB,GAAIC,MAAoB,IAC5CC,cAAQ,CAACC,UAAU,CAACC,GAAG,WAAWH,MAAM,GAAG;AAE7C,MAAMI,cAAc,GAAGA,CAACJ,MAAoB,EAAEK,IAAU,KACtDC,WAAC,CAACC,cAAc,CAACF,IAAI,CAACG,SAAS,CAAC,wBAAwB,CAAC,EAAE,CACzDT,gBAAgB,CAACC,MAAM,CAAC,CACzB,CAAC;AAEG,SAASS,sBAAsBA,CACpCC,IAAqD,EACrDC,SAAkB,EAClBN,IAAU,EACV;EACA,MAAMO,YAAY,GAAGD,SAAS,GAAGZ,gBAAgB,GAAGK,cAAc;EAElEM,IAAI,CAACG,WAAW,CACd,IAAAC,0CAAkB,EAACJ,IAAI,CAACK,IAAI,EAAE,IAAI,EAAE,KAAK,EAAEC,SAAS,IAClDJ,YAAY,CAACI,SAAS,EAAEX,IAAI,CAC9B,CACF,CAAC;AACH","ignoreList":[]}

node_modules/@babel/plugin-transform-modules-commonjs/lib/hooks.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defineCommonJSHook = defineCommonJSHook;
+exports.makeInvokers = makeInvokers;
+const commonJSHooksKey = "@babel/plugin-transform-modules-commonjs/customWrapperPlugin";
+function defineCommonJSHook(file, hook) {
+  let hooks = file.get(commonJSHooksKey);
+  if (!hooks) file.set(commonJSHooksKey, hooks = []);
+  hooks.push(hook);
+}
+function findMap(arr, cb) {
+  if (arr) {
+    for (const el of arr) {
+      const res = cb(el);
+      if (res != null) return res;
+    }
+  }
+}
+function makeInvokers(file) {
+  const hooks = file.get(commonJSHooksKey);
+  return {
+    getWrapperPayload(...args) {
+      return findMap(hooks, hook => hook.getWrapperPayload == null ? void 0 : hook.getWrapperPayload(...args));
+    },
+    wrapReference(...args) {
+      return findMap(hooks, hook => hook.wrapReference == null ? void 0 : hook.wrapReference(...args));
+    },
+    buildRequireWrapper(...args) {
+      return findMap(hooks, hook => hook.buildRequireWrapper == null ? void 0 : hook.buildRequireWrapper(...args));
+    }
+  };
+}
+
+//# sourceMappingURL=hooks.js.map

node_modules/@babel/plugin-transform-modules-commonjs/lib/index.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+Object.defineProperty(exports, "defineCommonJSHook", {
+  enumerable: true,
+  get: function () {
+    return _hooks.defineCommonJSHook;
+  }
+});
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+var _helperModuleTransforms = require("@babel/helper-module-transforms");
+var _core = require("@babel/core");
+var _dynamicImport = require("./dynamic-import.js");
+var _lazy = require("./lazy.js");
+var _hooks = require("./hooks.js");
+var _default = exports.default = (0, _helperPluginUtils.declare)((api, options) => {
+  var _api$assumption, _api$assumption2, _api$assumption3;
+  api.assertVersion(7);
+  const {
+    strictNamespace = false,
+    mjsStrictNamespace = strictNamespace,
+    allowTopLevelThis,
+    strict,
+    strictMode,
+    noInterop,
+    importInterop,
+    lazy = false,
+    allowCommonJSExports = true,
+    loose = false
+  } = options;
+  const constantReexports = (_api$assumption = api.assumption("constantReexports")) != null ? _api$assumption : loose;
+  const enumerableModuleMeta = (_api$assumption2 = api.assumption("enumerableModuleMeta")) != null ? _api$assumption2 : loose;
+  const noIncompleteNsImportDetection = (_api$assumption3 = api.assumption("noIncompleteNsImportDetection")) != null ? _api$assumption3 : false;
+  if (typeof lazy !== "boolean" && typeof lazy !== "function" && (!Array.isArray(lazy) || !lazy.every(item => typeof item === "string"))) {
+    throw new Error(`.lazy must be a boolean, array of strings, or a function`);
+  }
+  if (typeof strictNamespace !== "boolean") {
+    throw new Error(`.strictNamespace must be a boolean, or undefined`);
+  }
+  if (typeof mjsStrictNamespace !== "boolean") {
+    throw new Error(`.mjsStrictNamespace must be a boolean, or undefined`);
+  }
+  const getAssertion = localName => _core.template.expression.ast`
+    (function(){
+      throw new Error(
+        "The CommonJS '" + "${localName}" + "' variable is not available in ES6 modules." +
+        "Consider setting setting sourceType:script or sourceType:unambiguous in your " +
+        "Babel config for this file.");
+    })()
+  `;
+  const moduleExportsVisitor = {
+    ReferencedIdentifier(path) {
+      const localName = path.node.name;
+      if (localName !== "module" && localName !== "exports") return;
+      const localBinding = path.scope.getBinding(localName);
+      const rootBinding = this.scope.getBinding(localName);
+      if (rootBinding !== localBinding || path.parentPath.isObjectProperty({
+        value

node_modules/@babel/plugin-transform-modules-systemjs/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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-transform-modules-systemjs/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-modules-systemjs
+
+> This plugin transforms ES2015 modules to SystemJS
+
+See our website [@babel/plugin-transform-modules-systemjs](https://babeljs.io/docs/babel-plugin-transform-modules-systemjs) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-modules-systemjs
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-modules-systemjs --dev
+```

node_modules/@babel/plugin-transform-modules-systemjs/lib/index.js

@@ -0,0 +1,406 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getExportSpecifierName = getExportSpecifierName;
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+var _core = require("@babel/core");
+var _helperModuleTransforms = require("@babel/helper-module-transforms");
+var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
+const buildTemplate = _core.template.statement(`
+  SYSTEM_REGISTER(MODULE_NAME, SOURCES, function (EXPORT_IDENTIFIER, CONTEXT_IDENTIFIER) {
+    "use strict";
+    BEFORE_BODY;
+    return {
+      setters: SETTERS,
+      execute: EXECUTE,
+    };
+  });
+`);
+const buildExportAll = _core.template.statement(`
+  for (var KEY in TARGET) {
+    if (KEY !== "default" && KEY !== "__esModule") EXPORT_OBJ[KEY] = TARGET[KEY];
+  }
+`);
+const MISSING_PLUGIN_WARNING = `\
+WARNING: Dynamic import() transformation must be enabled using the
+         @babel/plugin-transform-dynamic-import plugin. Babel 8 will
+         no longer transform import() without using that plugin.
+`;
+const MISSING_PLUGIN_ERROR = `\
+ERROR: Dynamic import() transformation must be enabled using the
+       @babel/plugin-transform-dynamic-import plugin. Babel 8
+       no longer transforms import() without using that plugin.
+`;
+function getExportSpecifierName(node, stringSpecifiers) {
+  if (node.type === "Identifier") {
+    return node.name;
+  } else if (node.type === "StringLiteral") {
+    const stringValue = node.value;
+    if (!(0, _helperValidatorIdentifier.isIdentifierName)(stringValue)) {
+      stringSpecifiers.add(stringValue);
+    }
+    return stringValue;
+  } else {
+    throw new Error(`Expected export specifier to be either Identifier or StringLiteral, got ${node.type}`);
+  }
+}
+function constructExportCall(path, exportIdent, exportNames, exportValues, exportStarTarget, stringSpecifiers) {
+  const statements = [];
+  if (!exportStarTarget) {
+    if (exportNames.length === 1) {
+      statements.push(_core.types.expressionStatement(_core.types.callExpression(exportIdent, [_core.types.stringLiteral(exportNames[0]), exportValues[0]])));
+    } else {
+      const objectProperties = [];
+      for (let i = 0; i < exportNames.length; i++) {
+        const exportName = exportNames[i];
+        const exportValue = exportValues[i];
+        objectProperties.push(_core.types.objectProperty(stringSpecifiers.has(exportName) ? _core.types.stringLiteral(exportName) : _core.types.identifier(exportName), exportValue));
+      }
+      statements.push(_core.types.expressionStatement(_core.types.callExpression(exportIdent, [_core.types.objectExpression(objectProperties)])));
+    }
+  } else {
+    const exportObj = path.scope.generateUid("exportObj");
+    statements.push(_core.types.variableDeclaration("var", [_core.types.variableDeclarator(_core.types.identifier(exportObj), _core.types.objectExpression([]))]));
+    statements.push(buildExportAll({
+      KEY: path.scope.generateUidIdentifier("key"),
+      EXPORT_OBJ: _core.types.identifier(exportObj),
+      TARGET: exportStarTarget
+    }));
+    for (let i = 0; i < exportNames.length; i++) {
+      const exportName = exportNames[i];
+      const exportValue = exportValues[i];
+      statements.push(_core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.memberExpression(_core.types.identifier(exportObj), _core.types.identifier(exportName)), exportValue)));
+    }
+    statements.push(_core.types.expressionStatement(_core.types.callExpression(exportIdent, [_core.types.identifier(exportObj)])));
+  }
+  return statements;
+}
+var _default = exports.default = (0, _helperPluginUtils.declare)((api, options) => {
+  api.assertVersion(7);
+  const {
+    systemGlobal = "System",
+    allowTopLevelThis = false
+  } = options;
+  const reassignmentVisited = new WeakSet();
+  const reassignmentVisitor = {
+    "AssignmentExpression|UpdateExpression"(path) {
+      if (reassignmentVisited.has(path.node)) return;
+      reassignmentVisited.add(path.node);
+      const arg = path.isAssignmentExpression() ? path.get("left") : path.get("argument");
+      if (arg.isObjectPattern() || arg.isArrayPattern()) {
+        const exprs = [path.node];
+        for (const name of Object.keys(arg.getBindingIdentifiers())) {
+          if (this.scope.getBinding(name) !== path.scope.getBinding(name)) {
+            return;
+          }
+          const exportedNames = this.exports[name];
+          if (!exportedNames) continue;
+          for (const exportedName of exportedNames) {
+            exprs.push(this.buildCall(exportedName, _core.types.identifier(name)).expression);
+          }
+        }
+        path.replaceWith(_core.types.sequenceExpression(exprs));
+        return;
+      }
+      if (!arg.isIdentifier()) return;
+      const name = arg.node.name;
+      if (this.scope.getBinding(name) !== path.scope.getBinding(name)) return;
+      const exportedNames = this.exports[name];
+      if (!exportedNames) return;
+      let node = path.node;
+      const isPostUpdateExpression = _core.types.isUpdateExpression(node, {
+        prefix: false
+      });
+      if (isPostUpdateExpression) {
+        node = _core.types.binaryExpression(node.operator[0], _core.types.unaryExpression("+", _core.types.cloneNode(node.argument)), _core.types.numericLiteral(1));
+      }
+      for (const exportedName of exportedNames) {
+        node = this.buildCall(exportedName, node).expression;
+      }
+      if (isPostUpdateExpression) {
+        node = _core.types.sequenceExpression([node, path.node]);
+      }
+      path.replaceWith(node);
+    }
+  };
+  return {
+    name: "transform-modules-systemjs",
+    pre() {
+      this.file.set("@babel/plugin-transform-modules-*", "systemjs");
+    },
+    visitor: {
+      ["CallExpression" + (api.types.importExpression ? "|ImportExpression" : "")](path, state) {
+        if (path.isCallExpression() && !_core.types.isImport(path.node.callee)) return;
+        if (path.isCallExpression()) {
+          if (!this.file.has("@babel/plugin-proposal-dynamic-import")) {
+            {
+              console.warn(MISSING_PLUGIN_WARNING);
+            }
+          }
+        } else {
+          if (!this.file.has("@babel/plugin-proposal-dynamic-import")) {
+            throw new Error(MISSING_PLUGIN_ERROR);
+          }
+        }
+        path.replaceWith((0, _helperModuleTransforms.buildDynamicImport)(path.node, false, true, specifier => _core.types.callExpression(_core.types.memberExpression(_core.types.identifier(state.contextIdent), _core.types.identifier("import")), [specifier])));
+      },
+      MetaProperty(path, state) {
+        if (path.node.meta.name === "import" && path.node.property.name === "meta") {
+          path.replaceWith(_core.types.memberExpression(_core.types.identifier(state.contextIdent), _core.types.identifier("meta")));
+        }
+      },
+      ReferencedIdentifier(path, state) {
+        if (path.node.name === "__moduleName" && !path.scope.hasBinding("__moduleName")) {
+          path.replaceWith(_core.types.memberExpression(_core.types.identifier(state.contextIdent), _core.types.identifier("id")));
+        }
+      },
+      Program: {
+        enter(path, state) {
+          state.contextIdent = path.scope.generateUid("context");
+          state.stringSpecifiers = new Set();
+          if (!allowTopLevelThis) {
+            (0, _helperModuleTransforms.rewriteThis)(path);
+          }
+        },
+        exit(path, state) {
+          const scope = path.scope;
+          const exportIdent = scope.generateUid("export");
+          const {
+            contextIdent,
+            stringSpecifiers
+          } = state;
+          const exportMap = Object.create(null);
+          const modules = [];
+          const beforeBody = [];
+          const setters = [];
+          const sources = [];
+          const variableIds = [];
+          const removedPaths = [];
+          function addExportName(key, val) {
+            exportMap[key] = exportMap[key] || [];
+            exportMap[key].push(val);
+          }
+          function pushModule(source, key, specifiers) {
+            let module;
+            modules.forEach(function (m) {
+              if (m.key === source) {
+                module = m;
+              }
+            });
+            if (!module) {
+              modules.push(module = {
+                key: source,
+                imports: [],
+                exports: []
+              });
+            }
+            module[key] = module[key].concat(specifiers);
+          }
+          function buildExportCall(name, val) {
+            return _core.types.expressionStatement(_core.types.callExpression(_core.types.identifier(exportIdent), [_core.types.stringLiteral(name), val]));
+          }
+          const exportNames = [];
+          const exportValues = [];
+          const body = path.get("body");
+          for (const path of body) {
+            if (path.isFunctionDeclaration()) {
+              beforeBody.push(path.node);
+              removedPaths.push(path);
+            } else if (path.isClassDeclaration()) {
+              variableIds.push(_core.types.cloneNode(path.node.id));
+              path.replaceWith(_core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.cloneNode(path.node.id), _core.types.toExpression(path.node))));
+            } else if (path.isVariableDeclaration()) {
+              path.node.kind = "var";
+            } else if (path.isImportDeclaration()) {
+              const source = path.node.source.value;
+              pushModule(source, "imports", path.node.specifiers);
+              for (const name of Object.keys(path.getBindingIdentifiers())) {
+                scope.removeBinding(name);
+                variableIds.push(_core.types.identifier(name));
+              }
+              path.remove();
+            } else if (path.isExportAllDeclaration()) {
+              pushModule(path.node.source.value, "exports", path.node);
+              path.remove();
+            } else if (path.isExportDefaultDeclaration()) {
+              const declar = path.node.declaration;
+              if (_core.types.isClassDeclaration(declar)) {
+                const id = declar.id;
+                if (id) {
+                  exportNames.push("default");
+                  exportValues.push(scope.buildUndefinedNode());
+                  variableIds.push(_core.types.cloneNode(id));
+                  addExportName(id.name, "default");
+                  path.replaceWith(_core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.cloneNode(id), _core.types.toExpression(declar))));
+                } else {
+                  exportNames.push("default");
+                  exportValues.push(_core.types.toExpression(declar));
+                  removedPaths.push(path);
+                }
+              } else if (_core.types.isFunctionDeclaration(declar)) {
+                const id = declar.id;
+                if (id) {
+                  beforeBody.push(declar);
+                  exportNames.push("default");
+                  exportValues.push(_core.types.cloneNode(id));
+                  addExportName(id.name, "default");
+                } else {
+                  exportNames.push("default");
+                  exportValues.push(_core.types.toExpression(declar));
+                }
+                removedPaths.push(path);
+              } else {
+                path.replaceWith(buildExportCall("default", declar));
+              }
+            } else if (path.isExportNamedDeclaration()) {
+              const declar = path.node.declaration;
+              if (declar) {
+                path.replaceWith(declar);
+                if (_core.types.isFunction(declar)) {
+                  const name = declar.id.name;
+                  addExportName(name, name);
+                  beforeBody.push(declar);
+                  exportNames.push(name);
+                  exportValues.push(_core.types.cloneNode(declar.id));
+                  removedPaths.push(path);
+                } else if (_core.types.isClass(declar)) {
+                  const name = declar.id.name;
+                  exportNames.push(name);
+                  exportValues.push(scope.buildUndefinedNode());
+                  variableIds.push(_core.types.cloneNode(declar.id));
+                  path.replaceWith(_core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.cloneNode(declar.id), _core.types.toExpression(declar))));
+                  addExportName(name, name);
+                } else {
+                  if (_core.types.isVariableDeclaration(declar)) {
+                    declar.kind = "var";
+                  }
+                  for (const name of Object.keys(_core.types.getBindingIdentifiers(declar))) {
+                    addExportName(name, name);
+                  }
+                }
+              } else {
+                const specifiers = path.node.specifiers;
+                if (specifiers != null && specifiers.length) {
+                  if (path.node.source) {
+                    pushModule(path.node.source.value, "exports", specifiers);
+                    path.remove();
+                  } else {
+                    const nodes = [];
+                    for (const specifier of specifiers) {
+                      const {
+                        local,
+                        exported
+                      } = specifier;
+                      const binding = scope.getBinding(local.name);
+                      const exportedName = getExportSpecifierName(exported, stringSpecifiers);
+                      if (binding && _core.types.isFunctionDeclaration(binding.path.node)) {
+                        exportNames.push(exportedName);
+                        exportValues.push(_core.types.cloneNode(local));
+                      } else if (!binding) {
+                        nodes.push(buildExportCall(exportedName, local));
+                      }
+                      addExportName(local.name, exportedName);
+                    }
+                    path.replaceWithMultiple(nodes);
+                  }
+                } else {
+                  path.remove();
+                }
+              }
+            }
+          }
+          modules.forEach(function (specifiers) {
+            const setterBody = [];
+            const target = scope.generateUid(specifiers.key);
+            for (let specifier of specifiers.imports) {
+              if (_core.types.isImportNamespaceSpecifier(specifier)) {
+                setterBody.push(_core.types.expressionStatement(_core.types.assignmentExpression("=", specifier.local, _core.types.identifier(target))));
+              } else if (_core.types.isImportDefaultSpecifier(specifier)) {
+                specifier = _core.types.importSpecifier(specifier.local, _core.types.identifier("default"));
+              }
+              if (_core.types.isImportSpecifier(specifier)) {
+                const {
+                  imported
+                } = specifier;
+                setterBody.push(_core.types.expressionStatement(_core.types.assignmentExpression("=", specifier.local, _core.types.memberExpression(_core.types.identifier(target), specifier.imported, imported.type === "StringLiteral"))));
+              }
+            }
+            if (specifiers.exports.length) {
+              const exportNames = [];
+              const exportValues = [];
+              let hasExportStar = false;
+              for (const node of specifiers.exports) {
+                if (_core.types.isExportAllDeclaration(node)) {
+                  hasExportStar = true;
+                } else if (_core.types.isExportSpecifier(node)) {
+                  const exportedName = getExportSpecifierName(node.exported, stringSpecifiers);
+                  exportNames.push(exportedName);
+                  exportValues.push(_core.types.memberExpression(_core.types.identifier(target), node.local, _core.types.isStringLiteral(node.local)));
+                } else {}
+              }
+              setterBody.push(...constructExportCall(path, _core.types.identifier(exportIdent), exportNames, exportValues, hasExportStar ? _core.types.identifier(target) : null, stringSpecifiers));
+            }
+            sources.push(_core.types.stringLiteral(specifiers.key));
+            setters.push(_core.types.functionExpression(null, [_core.types.identifier(target)], _core.types.blockStatement(setterBody)));
+          });
+          let moduleName = (0, _helperModuleTransforms.getModuleName)(this.file.opts, options);
+          if (moduleName) moduleName = _core.types.stringLiteral(moduleName);
+          {
+            var _path$scope, _path$scope$hoistVari;
+            (_path$scope$hoistVari = (_path$scope = path.scope).hoistVariables) != null ? _path$scope$hoistVari : _path$scope.hoistVariables = require("@babel/traverse").Scope.prototype.hoistVariables;
+          }
+          path.scope.hoistVariables((id, hasInit) => {
+            variableIds.push(id);
+            if (!hasInit && id.name in exportMap) {
+              for (const exported of exportMap[id.name]) {
+                exportNames.push(exported);
+                exportValues.push(_core.types.buildUndefinedNode());
+              }
+            }
+          });
+          if (variableIds.length) {
+            beforeBody.unshift(_core.types.variableDeclaration("var", variableIds.map(id => _core.types.variableDeclarator(id))));
+          }
+          if (exportNames.length) {
+            beforeBody.push(...constructExportCall(path, _core.types.identifier(exportIdent), exportNames, exportValues, null, stringSpecifiers));
+          }
+          path.traverse(reassignmentVisitor, {
+            exports: exportMap,
+            buildCall: buildExportCall,
+            scope
+          });
+          for (const path of removedPaths) {
+            path.remove();
+          }
+          let hasTLA = false;
+          path.traverse({
+            AwaitExpression(path) {
+              hasTLA = true;
+              path.stop();
+            },
+            Function(path) {
+              path.skip();
+            },
+            noScope: true
+          });
+          path.node.body = [buildTemplate({
+            SYSTEM_REGISTER: _core.types.memberExpression(_core.types.identifier(systemGlobal), _core.types.identifier("register")),
+            BEFORE_BODY: beforeBody,
+            MODULE_NAME: moduleName,
+            SETTERS: _core.types.arrayExpression(setters),
+            EXECUTE: _core.types.functionExpression(null, [], _core.types.blockStatement(path.node.body), false, hasTLA),
+            SOURCES: _core.types.arrayExpression(sources),
+            EXPORT_IDENTIFIER: _core.types.identifier(exportIdent),
+            CONTEXT_IDENTIFIER: _core.types.identifier(contextIdent)
+          })];
+          path.requeue(path.get("body.0"));
+        }
+      }
+    }
+  };
+});
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/plugin-transform-modules-systemjs/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@babel/plugin-transform-modules-systemjs",
+  "version": "7.25.9",
+  "description": "This plugin transforms ES2015 modules to SystemJS",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-plugin-transform-modules-systemjs"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/helper-module-transforms": "^7.25.9",
+    "@babel/helper-plugin-utils": "^7.25.9",
+    "@babel/helper-validator-identifier": "^7.25.9",
+    "@babel/traverse": "^7.25.9"
+  },
+  "keywords": [
+    "babel-plugin"
+  ],
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.9",
+    "@babel/helper-plugin-test-runner": "^7.25.9",
+    "@babel/helper-transform-fixture-test-runner": "^7.25.9",
+    "core-js": "^3.35.0"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-plugin-transform-modules-systemjs",
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}

node_modules/@babel/plugin-transform-modules-umd/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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-transform-modules-umd/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-modules-umd
+
+> This plugin transforms ES2015 modules to UMD
+
+See our website [@babel/plugin-transform-modules-umd](https://babeljs.io/docs/babel-plugin-transform-modules-umd) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-modules-umd
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-modules-umd --dev
+```

node_modules/@babel/plugin-transform-modules-umd/lib/index.js

@@ -0,0 +1,156 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+var _path = require("path");
+var _helperModuleTransforms = require("@babel/helper-module-transforms");
+var _core = require("@babel/core");
+const buildPrerequisiteAssignment = (0, _core.template)(`
+  GLOBAL_REFERENCE = GLOBAL_REFERENCE || {}
+`);
+const buildWrapper = (0, _core.template)(`
+  (function (global, factory) {
+    if (typeof define === "function" && define.amd) {
+      define(MODULE_NAME, AMD_ARGUMENTS, factory);
+    } else if (typeof exports !== "undefined") {
+      factory(COMMONJS_ARGUMENTS);
+    } else {
+      var mod = { exports: {} };
+      factory(BROWSER_ARGUMENTS);
+
+      GLOBAL_TO_ASSIGN;
+    }
+  })(
+    typeof globalThis !== "undefined" ? globalThis
+      : typeof self !== "undefined" ? self
+      : this,
+    function(IMPORT_NAMES) {
+  })
+`);
+var _default = exports.default = (0, _helperPluginUtils.declare)((api, options) => {
+  var _api$assumption, _api$assumption2;
+  api.assertVersion(7);
+  const {
+    globals,
+    exactGlobals,
+    allowTopLevelThis,
+    strict,
+    strictMode,
+    noInterop,
+    importInterop
+  } = options;
+  const constantReexports = (_api$assumption = api.assumption("constantReexports")) != null ? _api$assumption : options.loose;
+  const enumerableModuleMeta = (_api$assumption2 = api.assumption("enumerableModuleMeta")) != null ? _api$assumption2 : options.loose;
+  function buildBrowserInit(browserGlobals, exactGlobals, filename, moduleName) {
+    const moduleNameOrBasename = moduleName ? moduleName.value : (0, _path.basename)(filename, (0, _path.extname)(filename));
+    let globalToAssign = _core.types.memberExpression(_core.types.identifier("global"), _core.types.identifier(_core.types.toIdentifier(moduleNameOrBasename)));
+    let initAssignments = [];
+    if (exactGlobals) {
+      const globalName = browserGlobals[moduleNameOrBasename];
+      if (globalName) {
+        initAssignments = [];
+        const members = globalName.split(".");
+        globalToAssign = members.slice(1).reduce((accum, curr) => {
+          initAssignments.push(buildPrerequisiteAssignment({
+            GLOBAL_REFERENCE: _core.types.cloneNode(accum)
+          }));
+          return _core.types.memberExpression(accum, _core.types.identifier(curr));
+        }, _core.types.memberExpression(_core.types.identifier("global"), _core.types.identifier(members[0])));
+      }
+    }
+    initAssignments.push(_core.types.expressionStatement(_core.types.assignmentExpression("=", globalToAssign, _core.types.memberExpression(_core.types.identifier("mod"), _core.types.identifier("exports")))));
+    return initAssignments;
+  }
+  function buildBrowserArg(browserGlobals, exactGlobals, source) {
+    let memberExpression;
+    if (exactGlobals) {
+      const globalRef = browserGlobals[source];
+      if (globalRef) {
+        memberExpression = globalRef.split(".").reduce((accum, curr) => _core.types.memberExpression(accum, _core.types.identifier(curr)), _core.types.identifier("global"));
+      } else {
+        memberExpression = _core.types.memberExpression(_core.types.identifier("global"), _core.types.identifier(_core.types.toIdentifier(source)));
+      }
+    } else {
+      const requireName = (0, _path.basename)(source, (0, _path.extname)(source));
+      const globalName = browserGlobals[requireName] || requireName;
+      memberExpression = _core.types.memberExpression(_core.types.identifier("global"), _core.types.identifier(_core.types.toIdentifier(globalName)));
+    }
+    return memberExpression;
+  }
+  return {
+    name: "transform-modules-umd",
+    visitor: {
+      Program: {
+        exit(path) {
+          if (!(0, _helperModuleTransforms.isModule)(path)) return;
+          const browserGlobals = globals || {};
+          const moduleName = (0, _helperModuleTransforms.getModuleName)(this.file.opts, options);
+          let moduleNameLiteral;
+          if (moduleName) moduleNameLiteral = _core.types.stringLiteral(moduleName);
+          const {
+            meta,
+            headers
+          } = (0, _helperModuleTransforms.rewriteModuleStatementsAndPrepareHeader)(path, {
+            constantReexports,
+            enumerableModuleMeta,
+            strict,
+            strictMode,
+            allowTopLevelThis,
+            noInterop,
+            importInterop,
+            filename: this.file.opts.filename
+          });
+          const amdArgs = [];
+          const commonjsArgs = [];
+          const browserArgs = [];
+          const importNames = [];
+          if ((0, _helperModuleTransforms.hasExports)(meta)) {
+            amdArgs.push(_core.types.stringLiteral("exports"));
+            commonjsArgs.push(_core.types.identifier("exports"));
+            browserArgs.push(_core.types.memberExpression(_core.types.identifier("mod"), _core.types.identifier("exports")));
+            importNames.push(_core.types.identifier(meta.exportName));
+          }
+          for (const [source, metadata] of meta.source) {
+            amdArgs.push(_core.types.stringLiteral(source));
+            commonjsArgs.push(_core.types.callExpression(_core.types.identifier("require"), [_core.types.stringLiteral(source)]));
+            browserArgs.push(buildBrowserArg(browserGlobals, exactGlobals, source));
+            importNames.push(_core.types.identifier(metadata.name));
+            if (!(0, _helperModuleTransforms.isSideEffectImport)(metadata)) {
+              const interop = (0, _helperModuleTransforms.wrapInterop)(path, _core.types.identifier(metadata.name), metadata.interop);
+              if (interop) {
+                const header = _core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.identifier(metadata.name), interop));
+                header.loc = meta.loc;
+                headers.push(header);
+              }
+            }
+            headers.push(...(0, _helperModuleTransforms.buildNamespaceInitStatements)(meta, metadata, constantReexports));
+          }
+          (0, _helperModuleTransforms.ensureStatementsHoisted)(headers);
+          path.unshiftContainer("body", headers);
+          const {
+            body,
+            directives
+          } = path.node;
+          path.node.directives = [];
+          path.node.body = [];
+          const umdWrapper = path.pushContainer("body", [buildWrapper({
+            MODULE_NAME: moduleNameLiteral,
+            AMD_ARGUMENTS: _core.types.arrayExpression(amdArgs),
+            COMMONJS_ARGUMENTS: commonjsArgs,
+            BROWSER_ARGUMENTS: browserArgs,
+            IMPORT_NAMES: importNames,
+            GLOBAL_TO_ASSIGN: buildBrowserInit(browserGlobals, exactGlobals, this.filename || "unknown", moduleNameLiteral)
+          })])[0];
+          const umdFactory = umdWrapper.get("expression.arguments")[1].get("body");
+          umdFactory.pushContainer("directives", directives);
+          umdFactory.pushContainer("body", body);
+        }
+      }
+    }
+  };
+});
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/plugin-transform-modules-umd/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@babel/plugin-transform-modules-umd",
+  "version": "7.25.9",
+  "description": "This plugin transforms ES2015 modules to UMD",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-plugin-transform-modules-umd"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-plugin-transform-modules-umd",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/helper-module-transforms": "^7.25.9",
+    "@babel/helper-plugin-utils": "^7.25.9"
+  },
+  "keywords": [
+    "babel-plugin"
+  ],
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.9",
+    "@babel/helper-plugin-test-runner": "^7.25.9",
+    "@babel/plugin-external-helpers": "^7.25.9"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}

node_modules/@babel/plugin-transform-named-capturing-groups-regex/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie 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-transform-named-capturing-groups-regex/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-named-capturing-groups-regex
+
+> Compile regular expressions using named groups to ES5.
+
+See our website [@babel/plugin-transform-named-capturing-groups-regex](https://babeljs.io/docs/babel-plugin-transform-named-capturing-groups-regex) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-named-capturing-groups-regex
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-named-capturing-groups-regex --dev
+```