first commit

app_vue/node_modules/@babel/helper-create-class-features-plugin/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.

app_vue/node_modules/@babel/helper-create-class-features-plugin/README.md

@@ -0,0 +1,19 @@
+# @babel/helper-create-class-features-plugin
+
+> Compile class public and private fields, private methods and decorators to ES6
+
+See our website [@babel/helper-create-class-features-plugin](https://babeljs.io/docs/babel-helper-create-class-features-plugin) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-create-class-features-plugin
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-create-class-features-plugin
+```

app_vue/node_modules/@babel/helper-create-class-features-plugin/lib/decorators-2018-09.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildDecoratedClass = buildDecoratedClass;
+var _core = require("@babel/core");
+var _helperReplaceSupers = require("@babel/helper-replace-supers");
+;
+function prop(key, value) {
+  if (!value) return null;
+  return _core.types.objectProperty(_core.types.identifier(key), value);
+}
+function method(key, body) {
+  return _core.types.objectMethod("method", _core.types.identifier(key), [], _core.types.blockStatement(body));
+}
+function takeDecorators(node) {
+  let result;
+  if (node.decorators && node.decorators.length > 0) {
+    result = _core.types.arrayExpression(node.decorators.map(decorator => decorator.expression));
+  }
+  node.decorators = undefined;
+  return result;
+}
+function getKey(node) {
+  if (node.computed) {
+    return node.key;
+  } else if (_core.types.isIdentifier(node.key)) {
+    return _core.types.stringLiteral(node.key.name);
+  } else {
+    return _core.types.stringLiteral(String(node.key.value));
+  }
+}
+function extractElementDescriptor(file, classRef, superRef, path) {
+  const isMethod = path.isClassMethod();
+  if (path.isPrivate()) {
+    throw path.buildCodeFrameError(`Private ${isMethod ? "methods" : "fields"} in decorated classes are not supported yet.`);
+  }
+  if (path.node.type === "ClassAccessorProperty") {
+    throw path.buildCodeFrameError(`Accessor properties are not supported in 2018-09 decorator transform, please specify { "version": "2021-12" } instead.`);
+  }
+  if (path.node.type === "StaticBlock") {
+    throw path.buildCodeFrameError(`Static blocks are not supported in 2018-09 decorator transform, please specify { "version": "2021-12" } instead.`);
+  }
+  const {
+    node,
+    scope
+  } = path;
+  if (!path.isTSDeclareMethod()) {
+    new _helperReplaceSupers.default({
+      methodPath: path,
+      objectRef: classRef,
+      superRef,
+      file,
+      refToPreserve: classRef
+    }).replace();
+  }
+  const properties = [prop("kind", _core.types.stringLiteral(_core.types.isClassMethod(node) ? node.kind : "field")), prop("decorators", takeDecorators(node)), prop("static", node.static && _core.types.booleanLiteral(true)), prop("key", getKey(node))].filter(Boolean);
+  if (isMethod) {
+    {
+      var _path$ensureFunctionN;
+      (_path$ensureFunctionN = path.ensureFunctionName) != null ? _path$ensureFunctionN : path.ensureFunctionName = require("@babel/traverse").NodePath.prototype.ensureFunctionName;
+    }
+    path.ensureFunctionName(false);
+    properties.push(prop("value", _core.types.toExpression(path.node)));
+  } else if (_core.types.isClassProperty(node) && node.value) {
+    properties.push(method("value", _core.template.statements.ast`return ${node.value}`));
+  } else {
+    properties.push(prop("value", scope.buildUndefinedNode()));
+  }
+  path.remove();
+  return _core.types.objectExpression(properties);
+}
+function addDecorateHelper(file) {
+  return file.addHelper("decorate");
+}
+function buildDecoratedClass(ref, path, elements, file) {
+  const {
+    node,
+    scope
+  } = path;
+  const initializeId = scope.generateUidIdentifier("initialize");
+  const isDeclaration = node.id && path.isDeclaration();
+  const isStrict = path.isInStrictMode();
+  const {
+    superClass
+  } = node;
+  node.type = "ClassDeclaration";
+  if (!node.id) node.id = _core.types.cloneNode(ref);
+  let superId;
+  if (superClass) {
+    superId = scope.generateUidIdentifierBasedOnNode(node.superClass, "super");
+    node.superClass = superId;
+  }
+  const classDecorators = takeDecorators(node);
+  const definitions = _core.types.arrayExpression(elements.filter(element => !element.node.abstract && element.node.type !== "TSIndexSignature").map(path => extractElementDescriptor(file, node.id, superId, path)));
+  const wrapperCall = _core.template.expression.ast`
+    ${addDecorateHelper(file)}(
+      ${classDecorators || _core.types.nullLiteral()},
+      function (${initializeId}, ${superClass ? _core.types.cloneNode(superId) : null}) {
+        ${node}
+        return { F: ${_core.types.cloneNode(node.id)}, d: ${definitions} };
+      },
+      ${superClass}
+    )
+  `;
+  if (!isStrict) {
+    wrapperCall.arguments[1].body.directives.push(_core.types.directive(_core.types.directiveLiteral("use strict")));
+  }
+  let replacement = wrapperCall;
+  let classPathDesc = "arguments.1.body.body.0";
+  if (isDeclaration) {
+    replacement = _core.template.statement.ast`let ${ref} = ${wrapperCall}`;
+    classPathDesc = "declarations.0.init." + classPathDesc;
+  }
+  return {
+    instanceNodes: [_core.template.statement.ast`
+        ${_core.types.cloneNode(initializeId)}(this)
+      `],
+    wrapClass(path) {
+      path.replaceWith(replacement);
+      return path.get(classPathDesc);
+    }
+  };
+}
+
+//# sourceMappingURL=decorators-2018-09.js.map

app_vue/node_modules/@babel/helper-create-class-features-plugin/lib/features.js

@@ -0,0 +1,147 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FEATURES = void 0;
+exports.enableFeature = enableFeature;
+exports.isLoose = isLoose;
+exports.shouldTransform = shouldTransform;
+var _decorators = require("./decorators.js");
+const FEATURES = exports.FEATURES = Object.freeze({
+  fields: 1 << 1,
+  privateMethods: 1 << 2,
+  decorators: 1 << 3,
+  privateIn: 1 << 4,
+  staticBlocks: 1 << 5
+});
+const featuresSameLoose = new Map([[FEATURES.fields, "@babel/plugin-transform-class-properties"], [FEATURES.privateMethods, "@babel/plugin-transform-private-methods"], [FEATURES.privateIn, "@babel/plugin-transform-private-property-in-object"]]);
+const featuresKey = "@babel/plugin-class-features/featuresKey";
+const looseKey = "@babel/plugin-class-features/looseKey";
+{
+  var looseLowPriorityKey = "@babel/plugin-class-features/looseLowPriorityKey/#__internal__@babel/preset-env__please-overwrite-loose-instead-of-throwing";
+}
+{
+  var canIgnoreLoose = function (file, feature) {
+    return !!(file.get(looseLowPriorityKey) & feature);
+  };
+}
+function enableFeature(file, feature, loose) {
+  if (!hasFeature(file, feature) || canIgnoreLoose(file, feature)) {
+    file.set(featuresKey, file.get(featuresKey) | feature);
+    if (loose === "#__internal__@babel/preset-env__prefer-true-but-false-is-ok-if-it-prevents-an-error") {
+      setLoose(file, feature, true);
+      file.set(looseLowPriorityKey, file.get(looseLowPriorityKey) | feature);
+    } else if (loose === "#__internal__@babel/preset-env__prefer-false-but-true-is-ok-if-it-prevents-an-error") {
+      setLoose(file, feature, false);
+      file.set(looseLowPriorityKey, file.get(looseLowPriorityKey) | feature);
+    } else {
+      setLoose(file, feature, loose);
+    }
+  }
+  let resolvedLoose;
+  for (const [mask, name] of featuresSameLoose) {
+    if (!hasFeature(file, mask)) continue;
+    {
+      if (canIgnoreLoose(file, mask)) continue;
+    }
+    const loose = isLoose(file, mask);
+    if (resolvedLoose === !loose) {
+      throw new Error("'loose' mode configuration must be the same for @babel/plugin-transform-class-properties, " + "@babel/plugin-transform-private-methods and " + "@babel/plugin-transform-private-property-in-object (when they are enabled)." + "\n\n" + getBabelShowConfigForHint(file));
+    } else {
+      resolvedLoose = loose;
+      {
+        var higherPriorityPluginName = name;
+      }
+    }
+  }
+  if (resolvedLoose !== undefined) {
+    for (const [mask, name] of featuresSameLoose) {
+      if (hasFeature(file, mask) && isLoose(file, mask) !== resolvedLoose) {
+        setLoose(file, mask, resolvedLoose);
+        console.warn(`Though the "loose" option was set to "${!resolvedLoose}" in your @babel/preset-env ` + `config, it will not be used for ${name} since the "loose" mode option was set to ` + `"${resolvedLoose}" for ${higherPriorityPluginName}.\nThe "loose" option must be the ` + `same for @babel/plugin-transform-class-properties, @babel/plugin-transform-private-methods ` + `and @babel/plugin-transform-private-property-in-object (when they are enabled): you can ` + `silence this warning by explicitly adding\n` + `\t["${name}", { "loose": ${resolvedLoose} }]\n` + `to the "plugins" section of your Babel config.` + "\n\n" + getBabelShowConfigForHint(file));
+      }
+    }
+  }
+}
+function getBabelShowConfigForHint(file) {
+  let {
+    filename
+  } = file.opts;
+  if (!filename || filename === "unknown") {
+    filename = "[name of the input file]";
+  }
+  return `\
+If you already set the same 'loose' mode for these plugins in your config, it's possible that they \
+are enabled multiple times with different options.
+You can re-run Babel with the BABEL_SHOW_CONFIG_FOR environment variable to show the loaded \
+configuration:
+\tnpx cross-env BABEL_SHOW_CONFIG_FOR=${filename} <your build command>
+See https://babeljs.io/docs/configuration#print-effective-configs for more info.`;
+}
+function hasFeature(file, feature) {
+  return !!(file.get(featuresKey) & feature);
+}
+function isLoose(file, feature) {
+  return !!(file.get(looseKey) & feature);
+}
+function setLoose(file, feature, loose) {
+  if (loose) file.set(looseKey, file.get(looseKey) | feature);else file.set(looseKey, file.get(looseKey) & ~feature);
+  {
+    file.set(looseLowPriorityKey, file.get(looseLowPriorityKey) & ~feature);
+  }
+}
+function shouldTransform(path, file) {
+  let decoratorPath = null;
+  let publicFieldPath = null;
+  let privateFieldPath = null;
+  let privateMethodPath = null;
+  let staticBlockPath = null;
+  if ((0, _decorators.hasOwnDecorators)(path.node)) {
+    decoratorPath = path.get("decorators.0");
+  }
+  for (const el of path.get("body.body")) {
+    if (!decoratorPath && (0, _decorators.hasOwnDecorators)(el.node)) {
+      decoratorPath = el.get("decorators.0");
+    }
+    if (!publicFieldPath && el.isClassProperty()) {
+      publicFieldPath = el;
+    }
+    if (!privateFieldPath && el.isClassPrivateProperty()) {
+      privateFieldPath = el;
+    }
+    if (!privateMethodPath && el.isClassPrivateMethod != null && el.isClassPrivateMethod()) {
+      privateMethodPath = el;
+    }
+    if (!staticBlockPath && el.isStaticBlock != null && el.isStaticBlock()) {
+      staticBlockPath = el;
+    }
+  }
+  if (decoratorPath && privateFieldPath) {
+    throw privateFieldPath.buildCodeFrameError("Private fields in decorated classes are not supported yet.");
+  }
+  if (decoratorPath && privateMethodPath) {
+    throw privateMethodPath.buildCodeFrameError("Private methods in decorated classes are not supported yet.");
+  }
+  if (decoratorPath && !hasFeature(file, FEATURES.decorators)) {
+    throw path.buildCodeFrameError("Decorators are not enabled." + "\nIf you are using " + '["@babel/plugin-proposal-decorators", { "version": "legacy" }], ' + 'make sure it comes *before* "@babel/plugin-transform-class-properties" ' + "and enable loose mode, like so:\n" + '\t["@babel/plugin-proposal-decorators", { "version": "legacy" }]\n' + '\t["@babel/plugin-transform-class-properties", { "loose": true }]');
+  }
+  if (privateMethodPath && !hasFeature(file, FEATURES.privateMethods)) {
+    throw privateMethodPath.buildCodeFrameError("Class private methods are not enabled. " + "Please add `@babel/plugin-transform-private-methods` to your configuration.");
+  }
+  if ((publicFieldPath || privateFieldPath) && !hasFeature(file, FEATURES.fields) && !hasFeature(file, FEATURES.privateMethods)) {
+    throw path.buildCodeFrameError("Class fields are not enabled. " + "Please add `@babel/plugin-transform-class-properties` to your configuration.");
+  }
+  if (staticBlockPath && !hasFeature(file, FEATURES.staticBlocks)) {
+    throw path.buildCodeFrameError("Static class blocks are not enabled. " + "Please add `@babel/plugin-transform-class-static-block` to your configuration.");
+  }
+  if (decoratorPath || privateMethodPath || staticBlockPath) {
+    return true;
+  }
+  if ((publicFieldPath || privateFieldPath) && hasFeature(file, FEATURES.fields)) {
+    return true;
+  }
+  return false;
+}
+
+//# sourceMappingURL=features.js.map

app_vue/node_modules/@babel/helper-create-class-features-plugin/lib/index.js

@@ -0,0 +1,249 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "FEATURES", {
+  enumerable: true,
+  get: function () {
+    return _features.FEATURES;
+  }
+});
+Object.defineProperty(exports, "buildCheckInRHS", {
+  enumerable: true,
+  get: function () {
+    return _fields.buildCheckInRHS;
+  }
+});
+exports.createClassFeaturePlugin = createClassFeaturePlugin;
+Object.defineProperty(exports, "enableFeature", {
+  enumerable: true,
+  get: function () {
+    return _features.enableFeature;
+  }
+});
+Object.defineProperty(exports, "injectInitialization", {
+  enumerable: true,
+  get: function () {
+    return _misc.injectInitialization;
+  }
+});
+var _core = require("@babel/core");
+var _semver = require("semver");
+var _fields = require("./fields.js");
+var _decorators = require("./decorators.js");
+var _decorators2 = require("./decorators-2018-09.js");
+var _misc = require("./misc.js");
+var _features = require("./features.js");
+var _typescript = require("./typescript.js");
+const versionKey = "@babel/plugin-class-features/version";
+function createClassFeaturePlugin({
+  name,
+  feature,
+  loose,
+  manipulateOptions,
+  api,
+  inherits,
+  decoratorVersion
+}) {
+  var _api$assumption;
+  if (feature & _features.FEATURES.decorators) {
+    {
+      if (decoratorVersion === "2023-11" || decoratorVersion === "2023-05" || decoratorVersion === "2023-01" || decoratorVersion === "2022-03" || decoratorVersion === "2021-12") {
+        return (0, _decorators.default)(api, {
+          loose
+        }, decoratorVersion, inherits);
+      }
+    }
+  }
+  {
+    api != null ? api : api = {
+      assumption: () => void 0
+    };
+  }
+  const setPublicClassFields = api.assumption("setPublicClassFields");
+  const privateFieldsAsSymbols = api.assumption("privateFieldsAsSymbols");
+  const privateFieldsAsProperties = api.assumption("privateFieldsAsProperties");
+  const noUninitializedPrivateFieldAccess = (_api$assumption = api.assumption("noUninitializedPrivateFieldAccess")) != null ? _api$assumption : false;
+  const constantSuper = api.assumption("constantSuper");
+  const noDocumentAll = api.assumption("noDocumentAll");
+  if (privateFieldsAsProperties && privateFieldsAsSymbols) {
+    throw new Error(`Cannot enable both the "privateFieldsAsProperties" and ` + `"privateFieldsAsSymbols" assumptions as the same time.`);
+  }
+  const privateFieldsAsSymbolsOrProperties = privateFieldsAsProperties || privateFieldsAsSymbols;
+  if (loose === true) {
+    const explicit = [];
+    if (setPublicClassFields !== undefined) {
+      explicit.push(`"setPublicClassFields"`);
+    }
+    if (privateFieldsAsProperties !== undefined) {
+      explicit.push(`"privateFieldsAsProperties"`);
+    }
+    if (privateFieldsAsSymbols !== undefined) {
+      explicit.push(`"privateFieldsAsSymbols"`);
+    }
+    if (explicit.length !== 0) {
+      console.warn(`[${name}]: You are using the "loose: true" option and you are` + ` explicitly setting a value for the ${explicit.join(" and ")}` + ` assumption${explicit.length > 1 ? "s" : ""}. The "loose" option` + ` can cause incompatibilities with the other class features` + ` plugins, so it's recommended that you replace it with the` + ` following top-level option:\n` + `\t"assumptions": {\n` + `\t\t"setPublicClassFields": true,\n` + `\t\t"privateFieldsAsSymbols": true\n` + `\t}`);
+    }
+  }
+  return {
+    name,
+    manipulateOptions,
+    inherits,
+    pre(file) {
+      (0, _features.enableFeature)(file, feature, loose);
+      {
+        if (typeof file.get(versionKey) === "number") {
+          file.set(versionKey, "7.27.1");
+          return;
+        }
+      }
+      if (!file.get(versionKey) || _semver.lt(file.get(versionKey), "7.27.1")) {
+        file.set(versionKey, "7.27.1");
+      }
+    },
+    visitor: {
+      Class(path, {
+        file
+      }) {
+        if (file.get(versionKey) !== "7.27.1") return;
+        if (!(0, _features.shouldTransform)(path, file)) return;
+        const pathIsClassDeclaration = path.isClassDeclaration();
+        if (pathIsClassDeclaration) (0, _typescript.assertFieldTransformed)(path);
+        const loose = (0, _features.isLoose)(file, feature);
+        let constructor;
+        const isDecorated = (0, _decorators.hasDecorators)(path.node);
+        const props = [];
+        const elements = [];
+        const computedPaths = [];
+        const privateNames = new Set();
+        const body = path.get("body");
+        for (const path of body.get("body")) {
+          if ((path.isClassProperty() || path.isClassMethod()) && path.node.computed) {
+            computedPaths.push(path);
+          }
+          if (path.isPrivate()) {
+            const {
+              name
+            } = path.node.key.id;
+            const getName = `get ${name}`;
+            const setName = `set ${name}`;
+            if (path.isClassPrivateMethod()) {
+              if (path.node.kind === "get") {
+                if (privateNames.has(getName) || privateNames.has(name) && !privateNames.has(setName)) {
+                  throw path.buildCodeFrameError("Duplicate private field");
+                }
+                privateNames.add(getName).add(name);
+              } else if (path.node.kind === "set") {
+                if (privateNames.has(setName) || privateNames.has(name) && !privateNames.has(getName)) {
+                  throw path.buildCodeFrameError("Duplicate private field");
+                }
+                privateNames.add(setName).add(name);
+              }
+            } else {
+              if (privateNames.has(name) && !privateNames.has(getName) && !privateNames.has(setName) || privateNames.has(name) && (privateNames.has(getName) || privateNames.has(setName))) {
+                throw path.buildCodeFrameError("Duplicate private field");
+              }
+              privateNames.add(name);
+            }
+          }
+          if (path.isClassMethod({
+            kind: "constructor"
+          })) {
+            constructor = path;
+          } else {
+            elements.push(path);
+            if (path.isProperty() || path.isPrivate() || path.isStaticBlock != null && path.isStaticBlock()) {
+              props.push(path);
+            }
+          }
+        }
+        {
+          if (!props.length && !isDecorated) return;
+        }
+        const innerBinding = path.node.id;
+        let ref;
+        if (!innerBinding || !pathIsClassDeclaration) {
+          {
+            var _path$ensureFunctionN;
+            (_path$ensureFunctionN = path.ensureFunctionName) != null ? _path$ensureFunctionN : path.ensureFunctionName = require("@babel/traverse").NodePath.prototype.ensureFunctionName;
+          }
+          path.ensureFunctionName(false);
+          ref = path.scope.generateUidIdentifier((innerBinding == null ? void 0 : innerBinding.name) || "Class");
+        }
+        const classRefForDefine = ref != null ? ref : _core.types.cloneNode(innerBinding);
+        const privateNamesMap = (0, _fields.buildPrivateNamesMap)(classRefForDefine.name, privateFieldsAsSymbolsOrProperties != null ? privateFieldsAsSymbolsOrProperties : loose, props, file);
+        const privateNamesNodes = (0, _fields.buildPrivateNamesNodes)(privateNamesMap, privateFieldsAsProperties != null ? privateFieldsAsProperties : loose, privateFieldsAsSymbols != null ? privateFieldsAsSymbols : false, file);
+        (0, _fields.transformPrivateNamesUsage)(classRefForDefine, path, privateNamesMap, {
+          privateFieldsAsProperties: privateFieldsAsSymbolsOrProperties != null ? privateFieldsAsSymbolsOrProperties : loose,
+          noUninitializedPrivateFieldAccess,
+          noDocumentAll,
+          innerBinding
+        }, file);
+        let keysNodes, staticNodes, instanceNodes, lastInstanceNodeReturnsThis, pureStaticNodes, classBindingNode, wrapClass;
+        {
+          if (isDecorated) {
+            staticNodes = pureStaticNodes = keysNodes = [];
+            ({
+              instanceNodes,
+              wrapClass
+            } = (0, _decorators2.buildDecoratedClass)(classRefForDefine, path, elements, file));
+          } else {
+            keysNodes = (0, _misc.extractComputedKeys)(path, computedPaths, file);
+            ({
+              staticNodes,
+              pureStaticNodes,
+              instanceNodes,
+              lastInstanceNodeReturnsThis,
+              classBindingNode,
+              wrapClass
+            } = (0, _fields.buildFieldsInitNodes)(ref, path.node.superClass, props, privateNamesMap, file, setPublicClassFields != null ? setPublicClassFields : loose, privateFieldsAsSymbolsOrProperties != null ? privateFieldsAsSymbolsOrProperties : loose, noUninitializedPrivateFieldAccess, constantSuper != null ? constantSuper : loose, innerBinding));
+          }
+        }
+        if (instanceNodes.length > 0) {
+          (0, _misc.injectInitialization)(path, constructor, instanceNodes, (referenceVisitor, state) => {
+            {
+              if (isDecorated) return;
+            }
+            for (const prop of props) {
+              if (_core.types.isStaticBlock != null && _core.types.isStaticBlock(prop.node) || prop.node.static) continue;
+              prop.traverse(referenceVisitor, state);
+            }
+          }, lastInstanceNodeReturnsThis);
+        }
+        const wrappedPath = wrapClass(path);
+        wrappedPath.insertBefore([...privateNamesNodes, ...keysNodes]);
+        if (staticNodes.length > 0) {
+          wrappedPath.insertAfter(staticNodes);
+        }
+        if (pureStaticNodes.length > 0) {
+          wrappedPath.find(parent => parent.isStatement() || parent.isDeclaration()).insertAfter(pureStaticNodes);
+        }
+        if (classBindingNode != null && pathIsClassDeclaration) {
+          wrappedPath.insertAfter(classBindingNode);
+        }
+      },
+      ExportDefaultDeclaration(path, {
+        file
+      }) {
+        {
+          if (file.get(versionKey) !== "7.27.1") return;
+          const decl = path.get("declaration");
+          if (decl.isClassDeclaration() && (0, _decorators.hasDecorators)(decl.node)) {
+            if (decl.node.id) {
+              {
+                var _path$splitExportDecl;
+                (_path$splitExportDecl = path.splitExportDeclaration) != null ? _path$splitExportDecl : path.splitExportDeclaration = require("@babel/traverse").NodePath.prototype.splitExportDeclaration;
+              }
+              path.splitExportDeclaration();
+            } else {
+              decl.node.type = "ClassExpression";
+            }
+          }
+        }
+      }
+    }
+  };
+}
+
+//# sourceMappingURL=index.js.map

app_vue/node_modules/@babel/helper-create-class-features-plugin/lib/misc.js

@@ -0,0 +1,136 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractComputedKeys = extractComputedKeys;
+exports.injectInitialization = injectInitialization;
+exports.memoiseComputedKey = memoiseComputedKey;
+var _core = require("@babel/core");
+var _traverse = require("@babel/traverse");
+const findBareSupers = _traverse.visitors.environmentVisitor({
+  Super(path) {
+    const {
+      node,
+      parentPath
+    } = path;
+    if (parentPath.isCallExpression({
+      callee: node
+    })) {
+      this.push(parentPath);
+    }
+  }
+});
+const referenceVisitor = {
+  "TSTypeAnnotation|TypeAnnotation"(path) {
+    path.skip();
+  },
+  ReferencedIdentifier(path, {
+    scope
+  }) {
+    if (scope.hasOwnBinding(path.node.name)) {
+      scope.rename(path.node.name);
+      path.skip();
+    }
+  }
+};
+function handleClassTDZ(path, state) {
+  if (state.classBinding && state.classBinding === path.scope.getBinding(path.node.name)) {
+    const classNameTDZError = state.file.addHelper("classNameTDZError");
+    const throwNode = _core.types.callExpression(classNameTDZError, [_core.types.stringLiteral(path.node.name)]);
+    path.replaceWith(_core.types.sequenceExpression([throwNode, path.node]));
+    path.skip();
+  }
+}
+const classFieldDefinitionEvaluationTDZVisitor = {
+  ReferencedIdentifier: handleClassTDZ,
+  "TSTypeAnnotation|TypeAnnotation"(path) {
+    path.skip();
+  }
+};
+function injectInitialization(path, constructor, nodes, renamer, lastReturnsThis) {
+  if (!nodes.length) return;
+  const isDerived = !!path.node.superClass;
+  if (!constructor) {
+    const newConstructor = _core.types.classMethod("constructor", _core.types.identifier("constructor"), [], _core.types.blockStatement([]));
+    if (isDerived) {
+      newConstructor.params = [_core.types.restElement(_core.types.identifier("args"))];
+      newConstructor.body.body.push(_core.template.statement.ast`super(...args)`);
+    }
+    [constructor] = path.get("body").unshiftContainer("body", newConstructor);
+  }
+  if (renamer) {
+    renamer(referenceVisitor, {
+      scope: constructor.scope
+    });
+  }
+  if (isDerived) {
+    const bareSupers = [];
+    constructor.traverse(findBareSupers, bareSupers);
+    let isFirst = true;
+    for (const bareSuper of bareSupers) {
+      if (isFirst) {
+        isFirst = false;
+      } else {
+        nodes = nodes.map(n => _core.types.cloneNode(n));
+      }
+      if (!bareSuper.parentPath.isExpressionStatement()) {
+        const allNodes = [bareSuper.node, ...nodes.map(n => _core.types.toExpression(n))];
+        if (!lastReturnsThis) allNodes.push(_core.types.thisExpression());
+        bareSuper.replaceWith(_core.types.sequenceExpression(allNodes));
+      } else {
+        bareSuper.insertAfter(nodes);
+      }
+    }
+  } else {
+    constructor.get("body").unshiftContainer("body", nodes);
+  }
+}
+function memoiseComputedKey(keyNode, scope, hint) {
+  const isUidReference = _core.types.isIdentifier(keyNode) && scope.hasUid(keyNode.name);
+  if (isUidReference) {
+    return;
+  }
+  const isMemoiseAssignment = _core.types.isAssignmentExpression(keyNode, {
+    operator: "="
+  }) && _core.types.isIdentifier(keyNode.left) && scope.hasUid(keyNode.left.name);
+  if (isMemoiseAssignment) {
+    return _core.types.cloneNode(keyNode);
+  } else {
+    const ident = _core.types.identifier(hint);
+    scope.push({
+      id: ident,
+      kind: "let"
+    });
+    return _core.types.assignmentExpression("=", _core.types.cloneNode(ident), keyNode);
+  }
+}
+function extractComputedKeys(path, computedPaths, file) {
+  const {
+    scope
+  } = path;
+  const declarations = [];
+  const state = {
+    classBinding: path.node.id && scope.getBinding(path.node.id.name),
+    file
+  };
+  for (const computedPath of computedPaths) {
+    const computedKey = computedPath.get("key");
+    if (computedKey.isReferencedIdentifier()) {
+      handleClassTDZ(computedKey, state);
+    } else {
+      computedKey.traverse(classFieldDefinitionEvaluationTDZVisitor, state);
+    }
+    const computedNode = computedPath.node;
+    if (!computedKey.isConstantExpression()) {
+      const assignment = memoiseComputedKey(computedKey.node, scope, scope.generateUidBasedOnNode(computedKey.node));
+      if (assignment) {
+        declarations.push(_core.types.expressionStatement(assignment));
+        computedNode.key = _core.types.cloneNode(assignment.left);
+      }
+    }
+  }
+  return declarations;
+}
+
+//# sourceMappingURL=misc.js.map

app_vue/node_modules/@babel/helper-create-class-features-plugin/lib/typescript.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertFieldTransformed = assertFieldTransformed;
+function assertFieldTransformed(path) {
+  if (path.node.declare || false) {
+    throw path.buildCodeFrameError(`TypeScript 'declare' fields must first be transformed by ` + `@babel/plugin-transform-typescript.\n` + `If you have already enabled that plugin (or '@babel/preset-typescript'), make sure ` + `that it runs before any plugin related to additional class features:\n` + ` - @babel/plugin-transform-class-properties\n` + ` - @babel/plugin-transform-private-methods\n` + ` - @babel/plugin-proposal-decorators`);
+  }
+}
+
+//# sourceMappingURL=typescript.js.map

app_vue/node_modules/@babel/helper-create-class-features-plugin/lib/typescript.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["assertFieldTransformed","path","node","declare","buildCodeFrameError"],"sources":["../src/typescript.ts"],"sourcesContent":["import type { NodePath, types as t } from \"@babel/core\";\n\nexport function assertFieldTransformed(\n  path: NodePath<t.ClassProperty | t.ClassDeclaration>,\n) {\n  if (\n    path.node.declare ||\n    (process.env.BABEL_8_BREAKING\n      ? path.isClassProperty({ definite: true })\n      : false)\n  ) {\n    throw path.buildCodeFrameError(\n      `TypeScript 'declare' fields must first be transformed by ` +\n        `@babel/plugin-transform-typescript.\\n` +\n        `If you have already enabled that plugin (or '@babel/preset-typescript'), make sure ` +\n        `that it runs before any plugin related to additional class features:\\n` +\n        ` - @babel/plugin-transform-class-properties\\n` +\n        ` - @babel/plugin-transform-private-methods\\n` +\n        ` - @babel/plugin-proposal-decorators`,\n    );\n  }\n}\n"],"mappings":";;;;;;AAEO,SAASA,sBAAsBA,CACpCC,IAAoD,EACpD;EACA,IACEA,IAAI,CAACC,IAAI,CAACC,OAAO,IAGb,KAAM,EACV;IACA,MAAMF,IAAI,CAACG,mBAAmB,CAC5B,2DAA2D,GACzD,uCAAuC,GACvC,qFAAqF,GACrF,wEAAwE,GACxE,+CAA+C,GAC/C,8CAA8C,GAC9C,sCACJ,CAAC;EACH;AACF","ignoreList":[]}

app_vue/node_modules/@babel/helper-create-class-features-plugin/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@babel/helper-create-class-features-plugin",
+  "version": "7.27.1",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "license": "MIT",
+  "description": "Compile class public and private fields, private methods and decorators to ES6",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-create-class-features-plugin"
+  },
+  "main": "./lib/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "babel",
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-annotate-as-pure": "^7.27.1",
+    "@babel/helper-member-expression-to-functions": "^7.27.1",
+    "@babel/helper-optimise-call-expression": "^7.27.1",
+    "@babel/helper-replace-supers": "^7.27.1",
+    "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1",
+    "@babel/traverse": "^7.27.1",
+    "semver": "^6.3.1"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.27.1",
+    "@babel/helper-plugin-test-runner": "^7.27.1",
+    "@babel/preset-env": "^7.27.1",
+    "@types/charcodes": "^0.2.0",
+    "charcodes": "^0.2.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "type": "commonjs"
+}