first commit

app_vue/node_modules/@babel/plugin-transform-regenerator/lib/index.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+var _visit = require("./regenerator/visit.js");
+var _default = exports.default = (0, _helperPluginUtils.declare)(({
+  types: t,
+  traverse,
+  assertVersion
+}) => {
+  assertVersion(7);
+  return {
+    name: "transform-regenerator",
+    visitor: traverse.visitors.merge([(0, _visit.getVisitor)(t), {
+      CallExpression(path) {
+        var _this$availableHelper;
+        if (!((_this$availableHelper = this.availableHelper) != null && _this$availableHelper.call(this, "regeneratorRuntime"))) {
+          return;
+        }
+        const callee = path.get("callee");
+        if (!callee.isMemberExpression()) return;
+        const obj = callee.get("object");
+        if (obj.isIdentifier({
+          name: "regeneratorRuntime"
+        })) {
+          const helper = this.addHelper("regeneratorRuntime");
+          if (t.isArrowFunctionExpression(helper)) {
+            obj.replaceWith(helper.body);
+            return;
+          }
+          obj.replaceWith(t.callExpression(helper, []));
+        }
+      }
+    }])
+  };
+});
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_helperPluginUtils","require","_visit","_default","exports","default","declare","types","t","traverse","assertVersion","name","visitor","visitors","merge","getVisitor","CallExpression","path","_this$availableHelper","availableHelper","call","callee","get","isMemberExpression","obj","isIdentifier","helper","addHelper","isArrowFunctionExpression","replaceWith","body","callExpression"],"sources":["../src/index.ts"],"sourcesContent":["import { declare } from \"@babel/helper-plugin-utils\";\nimport type { types as t } from \"@babel/core\";\nimport { getVisitor } from \"./regenerator/visit.ts\";\n\nexport default declare(({ types: t, traverse, assertVersion }) => {\n  assertVersion(REQUIRED_VERSION(7));\n\n  return {\n    name: \"transform-regenerator\",\n\n    visitor: process.env.BABEL_8_BREAKING\n      ? getVisitor(t)\n      : traverse.visitors.merge([\n          getVisitor(t),\n          {\n            // We visit CallExpression so that we always transform\n            // regeneratorRuntime.*() before babel-plugin-polyfill-regenerator.\n            CallExpression(path) {\n              if (!this.availableHelper?.(\"regeneratorRuntime\")) {\n                // When using an older @babel/helpers version, fallback\n                // to the old behavior.\n                return;\n              }\n\n              const callee = path.get(\"callee\");\n              if (!callee.isMemberExpression()) return;\n\n              const obj = callee.get(\"object\");\n              if (obj.isIdentifier({ name: \"regeneratorRuntime\" })) {\n                const helper = this.addHelper(\"regeneratorRuntime\") as\n                  | t.Identifier\n                  | t.ArrowFunctionExpression;\n\n                if (\n                  // It's necessary to avoid the IIFE when using older Babel versions.\n                  t.isArrowFunctionExpression(helper)\n                ) {\n                  obj.replaceWith(helper.body);\n                  return;\n                }\n\n                obj.replaceWith(t.callExpression(helper, []));\n              }\n            },\n          },\n        ]),\n  };\n});\n"],"mappings":";;;;;;AAAA,IAAAA,kBAAA,GAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAD,OAAA;AAAoD,IAAAE,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAErC,IAAAC,0BAAO,EAAC,CAAC;EAAEC,KAAK,EAAEC,CAAC;EAAEC,QAAQ;EAAEC;AAAc,CAAC,KAAK;EAChEA,aAAa,CAAkB,CAAE,CAAC;EAElC,OAAO;IACLC,IAAI,EAAE,uBAAuB;IAE7BC,OAAO,EAEHH,QAAQ,CAACI,QAAQ,CAACC,KAAK,CAAC,CACtB,IAAAC,iBAAU,EAACP,CAAC,CAAC,EACb;MAGEQ,cAAcA,CAACC,IAAI,EAAE;QAAA,IAAAC,qBAAA;QACnB,IAAI,GAAAA,qBAAA,GAAC,IAAI,CAACC,eAAe,aAApBD,qBAAA,CAAAE,IAAA,KAAI,EAAmB,oBAAoB,CAAC,GAAE;UAGjD;QACF;QAEA,MAAMC,MAAM,GAAGJ,IAAI,CAACK,GAAG,CAAC,QAAQ,CAAC;QACjC,IAAI,CAACD,MAAM,CAACE,kBAAkB,CAAC,CAAC,EAAE;QAElC,MAAMC,GAAG,GAAGH,MAAM,CAACC,GAAG,CAAC,QAAQ,CAAC;QAChC,IAAIE,GAAG,CAACC,YAAY,CAAC;UAAEd,IAAI,EAAE;QAAqB,CAAC,CAAC,EAAE;UACpD,MAAMe,MAAM,GAAG,IAAI,CAACC,SAAS,CAAC,oBAAoB,CAErB;UAE7B,IAEEnB,CAAC,CAACoB,yBAAyB,CAACF,MAAM,CAAC,EACnC;YACAF,GAAG,CAACK,WAAW,CAACH,MAAM,CAACI,IAAI,CAAC;YAC5B;UACF;UAEAN,GAAG,CAACK,WAAW,CAACrB,CAAC,CAACuB,cAAc,CAACL,MAAM,EAAE,EAAE,CAAC,CAAC;QAC/C;MACF;IACF,CAAC,CACF;EACP,CAAC;AACH,CAAC,CAAC","ignoreList":[]}

app_vue/node_modules/@babel/plugin-transform-regenerator/lib/regenerator/emit.js

@@ -0,0 +1,636 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Emitter = void 0;
+var _assert = require("assert");
+var leap = require("./leap.js");
+var meta = require("./meta.js");
+var util = require("./util.js");
+var _core = require("@babel/core");
+const PENDING_LOCATION = Number.MAX_VALUE;
+function getDeclError(node) {
+  return new Error("all declarations should have been transformed into " + "assignments before the Exploder began its work: " + JSON.stringify(node));
+}
+const catchParamVisitor = {
+  Identifier: function (path, state) {
+    if (path.node.name === state.catchParamName && util.isReference(path)) {
+      util.replaceWithOrRemove(path, state.getSafeParam());
+    }
+  },
+  Scope: function (path, state) {
+    if (path.scope.hasOwnBinding(state.catchParamName)) {
+      path.skip();
+    }
+  }
+};
+class Emitter {
+  constructor(contextId, scope, vars, pluginPass) {
+    this.nextTempId = void 0;
+    this.contextId = void 0;
+    this.index = void 0;
+    this.indexMap = void 0;
+    this.listing = void 0;
+    this.returns = void 0;
+    this.lastReferenceIndex = 0;
+    this.marked = void 0;
+    this.insertedLocs = void 0;
+    this.finalLoc = void 0;
+    this.tryEntries = void 0;
+    this.leapManager = void 0;
+    this.scope = void 0;
+    this.vars = void 0;
+    this.pluginPass = void 0;
+    this.pluginPass = pluginPass;
+    this.scope = scope;
+    this.vars = vars;
+    this.nextTempId = 0;
+    this.contextId = contextId;
+    this.listing = [];
+    this.index = 0;
+    this.indexMap = new Map([[0, 0]]);
+    this.returns = new Set();
+    this.lastReferenceIndex = 0;
+    this.marked = [true];
+    this.insertedLocs = new Set();
+    this.finalLoc = this.loc();
+    this.tryEntries = [];
+    this.leapManager = new leap.LeapManager(this);
+  }
+  loc() {
+    const l = _core.types.numericLiteral(PENDING_LOCATION);
+    this.insertedLocs.add(l);
+    return l;
+  }
+  getInsertedLocs() {
+    return this.insertedLocs;
+  }
+  getContextId() {
+    return _core.types.cloneNode(this.contextId);
+  }
+  getIndex() {
+    if (!this.indexMap.has(this.listing.length)) {
+      this.indexMap.set(this.listing.length, ++this.index);
+    }
+    return this.index;
+  }
+  mark(loc) {
+    if (loc.value === PENDING_LOCATION) {
+      loc.value = this.getIndex();
+    } else {
+      _assert.strictEqual(loc.value, this.index);
+    }
+    this.marked[this.listing.length] = true;
+    if (loc.value > this.lastReferenceIndex) {
+      this.lastReferenceIndex = loc.value;
+    }
+    return loc;
+  }
+  emit(node) {
+    if (_core.types.isExpression(node)) {
+      node = _core.types.expressionStatement(node);
+    }
+    _core.types.assertStatement(node);
+    this.listing.push(node);
+  }
+  emitAssign(lhs, rhs) {
+    this.emit(this.assign(lhs, rhs));
+    return lhs;
+  }
+  assign(lhs, rhs) {
+    return _core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.cloneNode(lhs), rhs));
+  }
+  contextProperty(name) {
+    const computed = name === "catch";
+    return _core.types.memberExpression(this.getContextId(), computed ? _core.types.stringLiteral(name) : _core.types.identifier(name), !!computed);
+  }
+  clearPendingException(tryLoc, assignee) {
+    const catchCall = _core.types.callExpression(this.contextProperty("catch"), [_core.types.cloneNode(tryLoc)]);
+    if (assignee) {
+      this.emitAssign(assignee, catchCall);
+    } else {
+      this.emit(catchCall);
+    }
+  }
+  jump(toLoc) {
+    this.emitAssign(this.contextProperty(util.newHelpersAvailable(this.pluginPass) ? "n" : "next"), toLoc);
+    this.emit(_core.types.breakStatement());
+  }
+  jumpIf(test, toLoc) {
+    this.emit(_core.types.ifStatement(test, _core.types.blockStatement([this.assign(this.contextProperty(util.newHelpersAvailable(this.pluginPass) ? "n" : "next"), toLoc), _core.types.breakStatement()])));
+  }
+  jumpIfNot(test, toLoc) {
+    let negatedTest;
+    if (_core.types.isUnaryExpression(test) && test.operator === "!") {
+      negatedTest = test.argument;
+    } else {
+      negatedTest = _core.types.unaryExpression("!", test);
+    }
+    this.emit(_core.types.ifStatement(negatedTest, _core.types.blockStatement([this.assign(this.contextProperty(util.newHelpersAvailable(this.pluginPass) ? "n" : "next"), toLoc), _core.types.breakStatement()])));
+  }
+  makeContextTempVar() {
+    return this.contextProperty("t" + this.nextTempId++);
+  }
+  makeTempVar() {
+    const id = this.scope.generateUidIdentifier("t");
+    this.vars.push(_core.types.variableDeclarator(id));
+    return _core.types.cloneNode(id);
+  }
+  getContextFunction() {
+    return _core.types.functionExpression(null, [this.getContextId()], _core.types.blockStatement([this.getDispatchLoop()]), false, false);
+  }
+  getDispatchLoop() {
+    const self = this;
+    const cases = [];
+    let current;
+    let alreadyEnded = false;
+    self.listing.forEach(function (stmt, i) {
+      if (self.marked[i]) {
+        cases.push(_core.types.switchCase(_core.types.numericLiteral(self.indexMap.get(i)), current = []));
+        alreadyEnded = false;
+      }
+      if (!alreadyEnded) {
+        current.push(stmt);
+        if (_core.types.isCompletionStatement(stmt)) alreadyEnded = true;
+      }
+    });
+    this.finalLoc.value = this.getIndex();
+    if (util.newHelpersAvailable(this.pluginPass)) {
+      if (this.lastReferenceIndex === this.index || !this.returns.has(this.listing.length)) {
+        cases.push(_core.types.switchCase(this.finalLoc, [_core.types.returnStatement(_core.types.callExpression(this.contextProperty("a"), [_core.types.numericLiteral(2)]))]));
+      }
+    } else {
+      cases.push(_core.types.switchCase(this.finalLoc, []), _core.types.switchCase(_core.types.stringLiteral("end"), [_core.types.returnStatement(_core.types.callExpression(this.contextProperty("stop"), []))]));
+    }
+    return _core.types.whileStatement(_core.types.numericLiteral(1), _core.types.switchStatement(util.newHelpersAvailable(this.pluginPass) ? this.contextProperty("n") : _core.types.assignmentExpression("=", this.contextProperty("prev"), this.contextProperty("next")), cases));
+  }
+  getTryLocsList() {
+    if (this.tryEntries.length === 0) {
+      return null;
+    }
+    let lastLocValue = 0;
+    const arrayExpression = _core.types.arrayExpression(this.tryEntries.map(function (tryEntry) {
+      const thisLocValue = tryEntry.firstLoc.value;
+      _assert.ok(thisLocValue >= lastLocValue, "try entries out of order");
+      lastLocValue = thisLocValue;
+      const ce = tryEntry.catchEntry;
+      const fe = tryEntry.finallyEntry;
+      const locs = [tryEntry.firstLoc, ce ? ce.firstLoc : null];
+      if (fe) {
+        locs[2] = fe.firstLoc;
+        locs[3] = fe.afterLoc;
+      }
+      return _core.types.arrayExpression(locs.map(loc => loc && _core.types.cloneNode(loc)));
+    }));
+    if (util.newHelpersAvailable(this.pluginPass)) {
+      arrayExpression.elements.reverse();
+    }
+    return arrayExpression;
+  }
+  explode(path, ignoreResult) {
+    const node = path.node;
+    const self = this;
+    if (_core.types.isDeclaration(node)) throw getDeclError(node);
+    if (path.isStatement()) return self.explodeStatement(path);
+    if (path.isExpression()) return self.explodeExpression(path, ignoreResult);
+    switch (node.type) {
+      case "VariableDeclarator":
+        throw getDeclError(node);
+      case "ObjectProperty":
+      case "SwitchCase":
+      case "CatchClause":
+        throw new Error(node.type + " nodes should be handled by their parents");
+      default:
+        throw new Error("unknown Node of type " + JSON.stringify(node.type));
+    }
+  }
+  explodeStatement(path, labelId = null) {
+    const stmt = path.node;
+    const self = this;
+    let before, after, head;
+    if (path.isBlockStatement()) {
+      path.get("body").forEach(function (path) {
+        self.explodeStatement(path);
+      });
+      return;
+    }
+    if (!meta.containsLeap(stmt)) {
+      self.emit(stmt);
+      return;
+    }
+    switch (path.type) {
+      case "ExpressionStatement":
+        self.explodeExpression(path.get("expression"), true);
+        break;
+      case "LabeledStatement":
+        after = this.loc();
+        self.leapManager.withEntry(new leap.LabeledEntry(after, path.node.label), function () {
+          self.explodeStatement(path.get("body"), path.node.label);
+        });
+        self.mark(after);
+        break;
+      case "WhileStatement":
+        before = this.loc();
+        after = this.loc();
+        self.mark(before);
+        self.jumpIfNot(self.explodeExpression(path.get("test")), after);
+        self.leapManager.withEntry(new leap.LoopEntry(after, before, labelId), function () {
+          self.explodeStatement(path.get("body"));
+        });
+        self.jump(before);
+        self.mark(after);
+        break;
+      case "DoWhileStatement":
+        const first = this.loc();
+        const test = this.loc();
+        after = this.loc();
+        self.mark(first);
+        self.leapManager.withEntry(new leap.LoopEntry(after, test, labelId), function () {
+          self.explode(path.get("body"));
+        });
+        self.mark(test);
+        self.jumpIf(self.explodeExpression(path.get("test")), first);
+        self.mark(after);
+        break;
+      case "ForStatement":
+        head = this.loc();
+        const update = this.loc();
+        after = this.loc();
+        if (path.node.init) {
+          self.explode(path.get("init"), true);
+        }
+        self.mark(head);
+        if (path.node.test) {
+          self.jumpIfNot(self.explodeExpression(path.get("test")), after);
+        } else {}
+        self.leapManager.withEntry(new leap.LoopEntry(after, update, labelId), function () {
+          self.explodeStatement(path.get("body"));
+        });
+        self.mark(update);
+        if (path.node.update) {
+          self.explode(path.get("update"), true);
+        }
+        self.jump(head);
+        self.mark(after);
+        break;
+      case "TypeCastExpression":
+        return self.explodeExpression(path.get("expression"));
+      case "ForInStatement":
+        head = this.loc();
+        after = this.loc();
+        const keyIterNextFn = self.makeTempVar();
+        const helper = util.newHelpersAvailable(this.pluginPass) ? this.pluginPass.addHelper("regeneratorKeys") : util.runtimeProperty(this.pluginPass, "keys");
+        self.emitAssign(keyIterNextFn, _core.types.callExpression(helper, [self.explodeExpression(path.get("right"))]));
+        self.mark(head);
+        const keyInfoTmpVar = self.makeTempVar();
+        self.jumpIf(_core.types.memberExpression(_core.types.assignmentExpression("=", keyInfoTmpVar, _core.types.callExpression(_core.types.cloneNode(keyIterNextFn), [])), _core.types.identifier("done"), false), after);
+        self.emitAssign(path.node.left, _core.types.memberExpression(_core.types.cloneNode(keyInfoTmpVar), _core.types.identifier("value"), false));
+        self.leapManager.withEntry(new leap.LoopEntry(after, head, labelId), function () {
+          self.explodeStatement(path.get("body"));
+        });
+        self.jump(head);
+        self.mark(after);
+        break;
+      case "BreakStatement":
+        self.emitAbruptCompletion({
+          type: 3,
+          target: self.leapManager.getBreakLoc(path.node.label)
+        });
+        break;
+      case "ContinueStatement":
+        self.emitAbruptCompletion({
+          type: 3,
+          target: self.leapManager.getContinueLoc(path.node.label)
+        });
+        break;
+      case "SwitchStatement":
+        const disc = self.emitAssign(self.makeTempVar(), self.explodeExpression(path.get("discriminant")));
+        after = this.loc();
+        const defaultLoc = this.loc();
+        let condition = defaultLoc;
+        const caseLocs = [];
+        const cases = path.node.cases || [];
+        for (let i = cases.length - 1; i >= 0; --i) {
+          const c = cases[i];
+          if (c.test) {
+            condition = _core.types.conditionalExpression(_core.types.binaryExpression("===", _core.types.cloneNode(disc), c.test), caseLocs[i] = this.loc(), condition);
+          } else {
+            caseLocs[i] = defaultLoc;
+          }
+        }
+        const discriminant = path.get("discriminant");
+        util.replaceWithOrRemove(discriminant, condition);
+        self.jump(self.explodeExpression(discriminant));
+        self.leapManager.withEntry(new leap.SwitchEntry(after), function () {
+          path.get("cases").forEach(function (casePath) {
+            const i = casePath.key;
+            self.mark(caseLocs[i]);
+            casePath.get("consequent").forEach(function (path) {
+              self.explodeStatement(path);
+            });
+          });
+        });
+        self.mark(after);
+        if (defaultLoc.value === PENDING_LOCATION) {
+          self.mark(defaultLoc);
+          _assert.strictEqual(after.value, defaultLoc.value);
+        }
+        break;
+      case "IfStatement":
+        const elseLoc = path.node.alternate && this.loc();
+        after = this.loc();
+        self.jumpIfNot(self.explodeExpression(path.get("test")), elseLoc || after);
+        self.explodeStatement(path.get("consequent"));
+        if (elseLoc) {
+          self.jump(after);
+          self.mark(elseLoc);
+          self.explodeStatement(path.get("alternate"));
+        }
+        self.mark(after);
+        break;
+      case "ReturnStatement":
+        self.emitAbruptCompletion({
+          type: 2,
+          value: self.explodeExpression(path.get("argument"))
+        });
+        break;
+      case "WithStatement":
+        throw new Error("WithStatement not supported in generator functions.");
+      case "TryStatement":
+        after = this.loc();
+        const handler = path.node.handler;
+        const catchLoc = handler && this.loc();
+        const catchEntry = catchLoc && new leap.CatchEntry(catchLoc, handler.param);
+        const finallyLoc = path.node.finalizer && this.loc();
+        const finallyEntry = finallyLoc && new leap.FinallyEntry(finallyLoc, after);
+        const tryEntry = new leap.TryEntry(self.getUnmarkedCurrentLoc(), catchEntry, finallyEntry);
+        self.tryEntries.push(tryEntry);
+        self.updateContextPrevLoc(tryEntry.firstLoc);
+        self.leapManager.withEntry(tryEntry, () => {
+          self.explodeStatement(path.get("block"));
+          if (catchLoc) {
+            const body = path.node.block.body;
+            if (finallyLoc) {
+              self.jump(finallyLoc);
+            } else if (body.length && body[body.length - 1].type === "ReturnStatement") {
+              after = null;
+            } else {
+              self.jump(after);
+            }
+            self.updateContextPrevLoc(self.mark(catchLoc));
+            const bodyPath = path.get("handler.body");
+            const safeParam = self.makeTempVar();
+            if (util.newHelpersAvailable(this.pluginPass)) {
+              this.emitAssign(safeParam, self.contextProperty("v"));
+            } else {
+              self.clearPendingException(tryEntry.firstLoc, safeParam);
+            }
+            bodyPath.traverse(catchParamVisitor, {
+              getSafeParam: () => _core.types.cloneNode(safeParam),
+              catchParamName: handler.param.name
+            });
+            self.leapManager.withEntry(catchEntry, function () {
+              self.explodeStatement(bodyPath);
+            });
+          }
+          if (finallyLoc) {
+            self.updateContextPrevLoc(self.mark(finallyLoc));
+            self.leapManager.withEntry(finallyEntry, function () {
+              self.explodeStatement(path.get("finalizer"));
+            });
+            self.emit(_core.types.returnStatement(_core.types.callExpression(self.contextProperty(util.newHelpersAvailable(this.pluginPass) ? "f" : "finish"), [finallyEntry.firstLoc])));
+          }
+        });
+        if (after) self.mark(after);
+        break;
+      case "ThrowStatement":
+        self.emit(_core.types.throwStatement(self.explodeExpression(path.get("argument"))));
+        break;
+      case "ClassDeclaration":
+        self.emit(self.explodeClass(path));
+        break;
+      default:
+        throw new Error("unknown Statement of type " + JSON.stringify(stmt.type));
+    }
+  }
+  emitAbruptCompletion(record) {
+    const abruptArgs = [util.newHelpersAvailable(this.pluginPass) ? _core.types.numericLiteral(record.type) : _core.types.stringLiteral(record.type === 3 ? "continue" : "return")];
+    if (record.type === 3) {
+      abruptArgs[1] = this.insertedLocs.has(record.target) ? record.target : _core.types.cloneNode(record.target);
+    } else if (record.type === 2) {
+      if (record.value) {
+        abruptArgs[1] = _core.types.cloneNode(record.value);
+      }
+    }
+    this.emit(_core.types.returnStatement(_core.types.callExpression(this.contextProperty(util.newHelpersAvailable(this.pluginPass) ? "a" : "abrupt"), abruptArgs)));
+    if (record.type === 2) {
+      this.returns.add(this.listing.length);
+    }
+  }
+  getUnmarkedCurrentLoc() {
+    return _core.types.numericLiteral(this.getIndex());
+  }
+  updateContextPrevLoc(loc) {
+    if (loc) {
+      if (loc.value === PENDING_LOCATION) {
+        loc.value = this.getIndex();
+      } else {
+        _assert.strictEqual(loc.value, this.index);
+      }
+    } else {
+      loc = this.getUnmarkedCurrentLoc();
+    }
+    this.emitAssign(this.contextProperty(util.newHelpersAvailable(this.pluginPass) ? "p" : "prev"), loc);
+  }
+  explodeViaTempVar(tempVar, childPath, hasLeapingChildren, ignoreChildResult) {
+    _assert.ok(!ignoreChildResult || !tempVar, "Ignoring the result of a child expression but forcing it to " + "be assigned to a temporary variable?");
+    let result = this.explodeExpression(childPath, ignoreChildResult);
+    if (ignoreChildResult) {} else if (tempVar || hasLeapingChildren && !_core.types.isLiteral(result)) {
+      result = this.emitAssign(tempVar || this.makeTempVar(), result);
+    }
+    return result;
+  }
+  explodeExpression(path, ignoreResult) {
+    const expr = path.node;
+    if (!expr) {
+      return expr;
+    }
+    const self = this;
+    let result;
+    let after;
+    function finish(expr) {
+      if (ignoreResult) {
+        self.emit(expr);
+      }
+      return expr;
+    }
+    if (!meta.containsLeap(expr)) {
+      return finish(expr);
+    }
+    const hasLeapingChildren = meta.containsLeap.onlyChildren(expr);
+    switch (path.type) {
+      case "MemberExpression":
+        return finish(_core.types.memberExpression(self.explodeExpression(path.get("object")), path.node.computed ? self.explodeViaTempVar(null, path.get("property"), hasLeapingChildren) : path.node.property, path.node.computed));
+      case "CallExpression":
+        const calleePath = path.get("callee");
+        const argsPath = path.get("arguments");
+        let newCallee;
+        let newArgs;
+        const hasLeapingArgs = argsPath.some(argPath => meta.containsLeap(argPath.node));
+        let injectFirstArg = null;
+        if (_core.types.isMemberExpression(calleePath.node)) {
+          if (hasLeapingArgs) {
+            const newObject = self.explodeViaTempVar(self.makeTempVar(), calleePath.get("object"), hasLeapingChildren);
+            const newProperty = calleePath.node.computed ? self.explodeViaTempVar(null, calleePath.get("property"), hasLeapingChildren) : calleePath.node.property;
+            injectFirstArg = newObject;
+            newCallee = _core.types.memberExpression(_core.types.memberExpression(_core.types.cloneNode(newObject), newProperty, calleePath.node.computed), _core.types.identifier("call"), false);
+          } else {
+            newCallee = self.explodeExpression(calleePath);
+          }
+        } else {
+          newCallee = self.explodeViaTempVar(null, calleePath, hasLeapingChildren);
+          if (_core.types.isMemberExpression(newCallee)) {
+            newCallee = _core.types.sequenceExpression([_core.types.numericLiteral(0), _core.types.cloneNode(newCallee)]);
+          }
+        }
+        if (hasLeapingArgs) {
+          newArgs = argsPath.map(argPath => self.explodeViaTempVar(null, argPath, hasLeapingChildren));
+          if (injectFirstArg) newArgs.unshift(injectFirstArg);
+          newArgs = newArgs.map(arg => _core.types.cloneNode(arg));
+        } else {
+          newArgs = path.node.arguments;
+        }
+        return finish(_core.types.callExpression(newCallee, newArgs));
+      case "NewExpression":
+        return finish(_core.types.newExpression(self.explodeViaTempVar(null, path.get("callee"), hasLeapingChildren), path.get("arguments").map(function (argPath) {
+          return self.explodeViaTempVar(null, argPath, hasLeapingChildren);
+        })));
+      case "ObjectExpression":
+        return finish(_core.types.objectExpression(path.get("properties").map(function (propPath) {
+          if (propPath.isObjectProperty()) {
+            return _core.types.objectProperty(propPath.node.key, self.explodeViaTempVar(null, propPath.get("value"), hasLeapingChildren), propPath.node.computed);
+          } else {
+            return propPath.node;
+          }
+        })));
+      case "ArrayExpression":
+        return finish(_core.types.arrayExpression(path.get("elements").map(function (elemPath) {
+          if (!elemPath.node) {
+            return null;
+          }
+          if (elemPath.isSpreadElement()) {
+            return _core.types.spreadElement(self.explodeViaTempVar(null, elemPath.get("argument"), hasLeapingChildren));
+          } else {
+            return self.explodeViaTempVar(null, elemPath, hasLeapingChildren);
+          }
+        })));
+      case "SequenceExpression":
+        const lastIndex = path.node.expressions.length - 1;
+        path.get("expressions").forEach(function (exprPath) {
+          if (exprPath.key === lastIndex) {
+            result = self.explodeExpression(exprPath, ignoreResult);
+          } else {
+            self.explodeExpression(exprPath, true);
+          }
+        });
+        return result;
+      case "LogicalExpression":
+        after = this.loc();
+        if (!ignoreResult) {
+          result = self.makeTempVar();
+        }
+        const left = self.explodeViaTempVar(result, path.get("left"), hasLeapingChildren);
+        if (path.node.operator === "&&") {
+          self.jumpIfNot(left, after);
+        } else {
+          _assert.strictEqual(path.node.operator, "||");
+          self.jumpIf(left, after);
+        }
+        self.explodeViaTempVar(result, path.get("right"), hasLeapingChildren, ignoreResult);
+        self.mark(after);
+        return result;
+      case "ConditionalExpression":
+        const elseLoc = this.loc();
+        after = this.loc();
+        const test = self.explodeExpression(path.get("test"));
+        self.jumpIfNot(test, elseLoc);
+        if (!ignoreResult) {
+          result = self.makeTempVar();
+        }
+        self.explodeViaTempVar(result, path.get("consequent"), hasLeapingChildren, ignoreResult);
+        self.jump(after);
+        self.mark(elseLoc);
+        self.explodeViaTempVar(result, path.get("alternate"), hasLeapingChildren, ignoreResult);
+        self.mark(after);
+        return result;
+      case "UnaryExpression":
+        return finish(_core.types.unaryExpression(path.node.operator, self.explodeExpression(path.get("argument")), !!path.node.prefix));
+      case "BinaryExpression":
+        return finish(_core.types.binaryExpression(path.node.operator, self.explodeViaTempVar(null, path.get("left"), hasLeapingChildren), self.explodeViaTempVar(null, path.get("right"), hasLeapingChildren)));
+      case "AssignmentExpression":
+        if (path.node.operator === "=") {
+          return finish(_core.types.assignmentExpression(path.node.operator, self.explodeExpression(path.get("left")), self.explodeExpression(path.get("right"))));
+        }
+        const lhs = self.explodeExpression(path.get("left"));
+        const temp = self.emitAssign(self.makeTempVar(), lhs);
+        return finish(_core.types.assignmentExpression("=", _core.types.cloneNode(lhs), _core.types.assignmentExpression(path.node.operator, _core.types.cloneNode(temp), self.explodeExpression(path.get("right")))));
+      case "UpdateExpression":
+        return finish(_core.types.updateExpression(path.node.operator, self.explodeExpression(path.get("argument")), path.node.prefix));
+      case "YieldExpression":
+        after = this.loc();
+        const arg = path.node.argument && self.explodeExpression(path.get("argument"));
+        if (arg && path.node.delegate) {
+          if (util.newHelpersAvailable(this.pluginPass)) {
+            const ret = _core.types.returnStatement(_core.types.callExpression(self.contextProperty("d"), [_core.types.callExpression(this.pluginPass.addHelper("regeneratorValues"), [arg]), after]));
+            ret.loc = expr.loc;
+            self.emit(ret);
+            self.mark(after);
+            return self.contextProperty("v");
+          } else {
+            const result = self.makeContextTempVar();
+            const ret = _core.types.returnStatement(_core.types.callExpression(self.contextProperty("delegateYield"), [arg, _core.types.stringLiteral(result.property.name), after]));
+            ret.loc = expr.loc;
+            self.emit(ret);
+            self.mark(after);
+            return result;
+          }
+        }
+        self.emitAssign(self.contextProperty(util.newHelpersAvailable(this.pluginPass) ? "n" : "next"), after);
+        const ret = _core.types.returnStatement(_core.types.cloneNode(arg) || null);
+        ret.loc = expr.loc;
+        self.emit(ret);
+        self.mark(after);
+        return self.contextProperty(util.newHelpersAvailable(self.pluginPass) ? "v" : "sent");
+      case "ClassExpression":
+        return finish(self.explodeClass(path));
+      default:
+        throw new Error("unknown Expression of type " + JSON.stringify(expr.type));
+    }
+  }
+  explodeClass(path) {
+    const explodingChildren = [];
+    if (path.node.superClass) {
+      explodingChildren.push(path.get("superClass"));
+    }
+    path.get("body.body").forEach(member => {
+      if (member.node.computed) {
+        explodingChildren.push(member.get("key"));
+      }
+    });
+    const hasLeapingChildren = explodingChildren.some(child => meta.containsLeap(child));
+    for (let i = 0; i < explodingChildren.length; i++) {
+      const child = explodingChildren[i];
+      const isLast = i === explodingChildren.length - 1;
+      if (isLast) {
+        child.replaceWith(this.explodeExpression(child));
+      } else {
+        child.replaceWith(this.explodeViaTempVar(null, child, hasLeapingChildren));
+      }
+    }
+    return path.node;
+  }
+}
+exports.Emitter = Emitter;
+
+//# sourceMappingURL=emit.js.map

app_vue/node_modules/@babel/plugin-transform-regenerator/lib/regenerator/hoist.js

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hoist = hoist;
+var util = require("./util.js");
+const hasOwn = Object.prototype.hasOwnProperty;
+function hoist(funPath) {
+  const t = util.getTypes();
+  t.assertFunction(funPath.node);
+  const vars = {};
+  function varDeclToExpr({
+    node: vdec,
+    scope
+  }, includeIdentifiers) {
+    t.assertVariableDeclaration(vdec);
+    const exprs = [];
+    vdec.declarations.forEach(function (dec) {
+      vars[dec.id.name] = t.identifier(dec.id.name);
+      scope.removeBinding(dec.id.name);
+      if (dec.init) {
+        exprs.push(t.assignmentExpression("=", dec.id, dec.init));
+      } else if (includeIdentifiers) {
+        exprs.push(dec.id);
+      }
+    });
+    if (exprs.length === 0) return null;
+    if (exprs.length === 1) return exprs[0];
+    return t.sequenceExpression(exprs);
+  }
+  funPath.get("body").traverse({
+    VariableDeclaration: {
+      exit: function (path) {
+        const expr = varDeclToExpr(path, false);
+        if (expr === null) {
+          path.remove();
+        } else {
+          util.replaceWithOrRemove(path, t.expressionStatement(expr));
+        }
+        path.skip();
+      }
+    },
+    ForStatement: function (path) {
+      const init = path.get("init");
+      if (init.isVariableDeclaration()) {
+        util.replaceWithOrRemove(init, varDeclToExpr(init, false));
+      }
+    },
+    ForXStatement: function (path) {
+      const left = path.get("left");
+      if (left.isVariableDeclaration()) {
+        util.replaceWithOrRemove(left, varDeclToExpr(left, true));
+      }
+    },
+    FunctionDeclaration: function (path) {
+      const node = path.node;
+      vars[node.id.name] = node.id;
+      const assignment = t.expressionStatement(t.assignmentExpression("=", t.clone(node.id), t.functionExpression(path.scope.generateUidIdentifierBasedOnNode(node), node.params, node.body, node.generator, node.expression)));
+      if (path.parentPath.isBlockStatement()) {
+        path.parentPath.unshiftContainer("body", assignment);
+        path.remove();
+      } else {
+        util.replaceWithOrRemove(path, assignment);
+      }
+      path.scope.removeBinding(node.id.name);
+      path.skip();
+    },
+    FunctionExpression: function (path) {
+      path.skip();
+    },
+    ArrowFunctionExpression: function (path) {
+      path.skip();
+    }
+  });
+  const paramNames = {};
+  funPath.get("params").forEach(function (paramPath) {
+    const param = paramPath.node;
+    if (t.isIdentifier(param)) {
+      paramNames[param.name] = param;
+    } else {}
+  });
+  const declarations = [];
+  Object.keys(vars).forEach(function (name) {
+    if (!hasOwn.call(paramNames, name)) {
+      declarations.push(t.variableDeclarator(vars[name], null));
+    }
+  });
+  return declarations;
+}
+
+//# sourceMappingURL=hoist.js.map

app_vue/node_modules/@babel/plugin-transform-regenerator/lib/regenerator/leap.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TryEntry = exports.SwitchEntry = exports.LoopEntry = exports.LeapManager = exports.LabeledEntry = exports.FunctionEntry = exports.FinallyEntry = exports.Entry = exports.CatchEntry = void 0;
+var _assert = require("assert");
+class Entry {}
+exports.Entry = Entry;
+class FunctionEntry extends Entry {
+  constructor(returnLoc) {
+    super();
+    this.returnLoc = void 0;
+    this.returnLoc = returnLoc;
+  }
+}
+exports.FunctionEntry = FunctionEntry;
+class LoopEntry extends Entry {
+  constructor(breakLoc, continueLoc, label = null) {
+    super();
+    this.breakLoc = void 0;
+    this.continueLoc = void 0;
+    this.label = void 0;
+    this.breakLoc = breakLoc;
+    this.continueLoc = continueLoc;
+    this.label = label;
+  }
+}
+exports.LoopEntry = LoopEntry;
+class SwitchEntry extends Entry {
+  constructor(breakLoc) {
+    super();
+    this.breakLoc = void 0;
+    this.breakLoc = breakLoc;
+  }
+}
+exports.SwitchEntry = SwitchEntry;
+class TryEntry extends Entry {
+  constructor(firstLoc, catchEntry = null, finallyEntry = null) {
+    super();
+    this.firstLoc = void 0;
+    this.catchEntry = void 0;
+    this.finallyEntry = void 0;
+    _assert.ok(catchEntry || finallyEntry);
+    this.firstLoc = firstLoc;
+    this.catchEntry = catchEntry;
+    this.finallyEntry = finallyEntry;
+  }
+}
+exports.TryEntry = TryEntry;
+class CatchEntry extends Entry {
+  constructor(firstLoc, paramId) {
+    super();
+    this.firstLoc = void 0;
+    this.paramId = void 0;
+    this.firstLoc = firstLoc;
+    this.paramId = paramId;
+  }
+}
+exports.CatchEntry = CatchEntry;
+class FinallyEntry extends Entry {
+  constructor(firstLoc, afterLoc) {
+    super();
+    this.firstLoc = void 0;
+    this.afterLoc = void 0;
+    this.firstLoc = firstLoc;
+    this.afterLoc = afterLoc;
+  }
+}
+exports.FinallyEntry = FinallyEntry;
+class LabeledEntry extends Entry {
+  constructor(breakLoc, label) {
+    super();
+    this.breakLoc = void 0;
+    this.label = void 0;
+    this.breakLoc = breakLoc;
+    this.label = label;
+  }
+}
+exports.LabeledEntry = LabeledEntry;
+class LeapManager {
+  constructor(emitter) {
+    this.emitter = void 0;
+    this.entryStack = void 0;
+    this.emitter = emitter;
+    this.entryStack = [new FunctionEntry(emitter.finalLoc)];
+  }
+  withEntry(entry, callback) {
+    this.entryStack.push(entry);
+    try {
+      callback.call(this.emitter);
+    } finally {
+      const popped = this.entryStack.pop();
+      _assert.strictEqual(popped, entry);
+    }
+  }
+  _findLeapLocation(property, label) {
+    for (let i = this.entryStack.length - 1; i >= 0; --i) {
+      const entry = this.entryStack[i];
+      const loc = entry[property];
+      if (loc) {
+        if (label) {
+          if (entry.label && entry.label.name === label.name) {
+            return loc;
+          }
+        } else if (entry instanceof LabeledEntry) {} else {
+          return loc;
+        }
+      }
+    }
+    return null;
+  }
+  getBreakLoc(label) {
+    return this._findLeapLocation("breakLoc", label);
+  }
+  getContinueLoc(label) {
+    return this._findLeapLocation("continueLoc", label);
+  }
+}
+exports.LeapManager = LeapManager;
+
+//# sourceMappingURL=leap.js.map

app_vue/node_modules/@babel/plugin-transform-regenerator/lib/regenerator/meta.js

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasSideEffects = exports.containsLeap = void 0;
+var _assert = require("assert");
+var _util = require("./util.js");
+const mMap = new WeakMap();
+function m(node) {
+  if (!mMap.has(node)) {
+    mMap.set(node, {});
+  }
+  return mMap.get(node);
+}
+const hasOwn = Object.prototype.hasOwnProperty;
+function makePredicate(propertyName, knownTypes) {
+  function onlyChildren(node) {
+    const t = (0, _util.getTypes)();
+    t.assertNode(node);
+    let result = false;
+    function check(child) {
+      if (result) {} else if (Array.isArray(child)) {
+        child.some(check);
+      } else if (t.isNode(child)) {
+        _assert.strictEqual(result, false);
+        result = predicate(child);
+      }
+      return result;
+    }
+    const keys = t.VISITOR_KEYS[node.type];
+    if (keys) {
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const child = node[key];
+        check(child);
+      }
+    }
+    return result;
+  }
+  function predicate(node) {
+    (0, _util.getTypes)().assertNode(node);
+    const meta = m(node);
+    if (hasOwn.call(meta, propertyName)) return meta[propertyName];
+    if (hasOwn.call(opaqueTypes, node.type)) return meta[propertyName] = false;
+    if (hasOwn.call(knownTypes, node.type)) return meta[propertyName] = true;
+    return meta[propertyName] = onlyChildren(node);
+  }
+  predicate.onlyChildren = onlyChildren;
+  return predicate;
+}
+const opaqueTypes = {
+  FunctionExpression: true,
+  ArrowFunctionExpression: true
+};
+const sideEffectTypes = {
+  CallExpression: true,
+  ForInStatement: true,
+  UnaryExpression: true,
+  BinaryExpression: true,
+  AssignmentExpression: true,
+  UpdateExpression: true,
+  NewExpression: true
+};
+const leapTypes = {
+  YieldExpression: true,
+  BreakStatement: true,
+  ContinueStatement: true,
+  ReturnStatement: true,
+  ThrowStatement: true
+};
+for (const type in leapTypes) {
+  if (hasOwn.call(leapTypes, type)) {
+    sideEffectTypes[type] = leapTypes[type];
+  }
+}
+const hasSideEffects = exports.hasSideEffects = makePredicate("hasSideEffects", sideEffectTypes);
+const containsLeap = exports.containsLeap = makePredicate("containsLeap", leapTypes);
+
+//# sourceMappingURL=meta.js.map

app_vue/node_modules/@babel/plugin-transform-regenerator/lib/regenerator/replaceShorthandObjectMethod.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = replaceShorthandObjectMethod;
+var util = require("./util.js");
+function replaceShorthandObjectMethod(path) {
+  const t = util.getTypes();
+  if (!path.node || !t.isFunction(path.node)) {
+    throw new Error("replaceShorthandObjectMethod can only be called on Function AST node paths.");
+  }
+  if (!t.isObjectMethod(path.node)) {
+    return path;
+  }
+  if (!path.node.generator) {
+    return path;
+  }
+  const parameters = path.node.params.map(function (param) {
+    return t.cloneDeep(param);
+  });
+  const functionExpression = t.functionExpression(null, parameters, t.cloneDeep(path.node.body), path.node.generator, path.node.async);
+  util.replaceWithOrRemove(path, t.objectProperty(t.cloneDeep(path.node.key), functionExpression, path.node.computed, false));
+  return path.get("value");
+}
+
+//# sourceMappingURL=replaceShorthandObjectMethod.js.map

app_vue/node_modules/@babel/plugin-transform-regenerator/lib/regenerator/replaceShorthandObjectMethod.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["util","require","replaceShorthandObjectMethod","path","t","getTypes","node","isFunction","Error","isObjectMethod","generator","parameters","params","map","param","cloneDeep","functionExpression","body","async","replaceWithOrRemove","objectProperty","key","computed","get"],"sources":["../../src/regenerator/replaceShorthandObjectMethod.ts"],"sourcesContent":["import * as util from \"./util.ts\";\n\n// this function converts a shorthand object generator method into a normal\n// (non-shorthand) object property which is a generator function expression. for\n// example, this:\n//\n//  var foo = {\n//    *bar(baz) { return 5; }\n//  }\n//\n// should be replaced with:\n//\n//  var foo = {\n//    bar: function*(baz) { return 5; }\n//  }\n//\n// to do this, it clones the parameter array and the body of the object generator\n// method into a new FunctionExpression.\n//\n// this method can be passed any Function AST node path, and it will return\n// either:\n//   a) the path that was passed in (iff the path did not need to be replaced) or\n//   b) the path of the new FunctionExpression that was created as a replacement\n//     (iff the path did need to be replaced)\n//\n// In either case, though, the caller can count on the fact that the return value\n// is a Function AST node path.\n//\n// If this function is called with an AST node path that is not a Function (or with an\n// argument that isn't an AST node path), it will throw an error.\nexport default function replaceShorthandObjectMethod(path: any) {\n  const t = util.getTypes();\n\n  if (!path.node || !t.isFunction(path.node)) {\n    throw new Error(\n      \"replaceShorthandObjectMethod can only be called on Function AST node paths.\",\n    );\n  }\n\n  // this function only replaces shorthand object methods (called ObjectMethod\n  // in Babel-speak).\n  if (!t.isObjectMethod(path.node)) {\n    return path;\n  }\n\n  // this function only replaces generators.\n  if (!path.node.generator) {\n    return path;\n  }\n\n  const parameters = path.node.params.map(function (param: any) {\n    return t.cloneDeep(param);\n  });\n\n  const functionExpression = t.functionExpression(\n    null, // id\n    parameters, // params\n    t.cloneDeep(path.node.body), // body\n    path.node.generator,\n    path.node.async,\n  );\n\n  util.replaceWithOrRemove(\n    path,\n    t.objectProperty(\n      t.cloneDeep(path.node.key), // key\n      functionExpression, //value\n      path.node.computed, // computed\n      false, // shorthand\n    ),\n  );\n\n  // path now refers to the ObjectProperty AST node path, but we want to return a\n  // Function AST node path for the function expression we created. we know that\n  // the FunctionExpression we just created is the value of the ObjectProperty,\n  // so return the \"value\" path off of this path.\n  return path.get(\"value\");\n}\n"],"mappings":";;;;;;AAAA,IAAAA,IAAA,GAAAC,OAAA;AA8Be,SAASC,4BAA4BA,CAACC,IAAS,EAAE;EAC9D,MAAMC,CAAC,GAAGJ,IAAI,CAACK,QAAQ,CAAC,CAAC;EAEzB,IAAI,CAACF,IAAI,CAACG,IAAI,IAAI,CAACF,CAAC,CAACG,UAAU,CAACJ,IAAI,CAACG,IAAI,CAAC,EAAE;IAC1C,MAAM,IAAIE,KAAK,CACb,6EACF,CAAC;EACH;EAIA,IAAI,CAACJ,CAAC,CAACK,cAAc,CAACN,IAAI,CAACG,IAAI,CAAC,EAAE;IAChC,OAAOH,IAAI;EACb;EAGA,IAAI,CAACA,IAAI,CAACG,IAAI,CAACI,SAAS,EAAE;IACxB,OAAOP,IAAI;EACb;EAEA,MAAMQ,UAAU,GAAGR,IAAI,CAACG,IAAI,CAACM,MAAM,CAACC,GAAG,CAAC,UAAUC,KAAU,EAAE;IAC5D,OAAOV,CAAC,CAACW,SAAS,CAACD,KAAK,CAAC;EAC3B,CAAC,CAAC;EAEF,MAAME,kBAAkB,GAAGZ,CAAC,CAACY,kBAAkB,CAC7C,IAAI,EACJL,UAAU,EACVP,CAAC,CAACW,SAAS,CAACZ,IAAI,CAACG,IAAI,CAACW,IAAI,CAAC,EAC3Bd,IAAI,CAACG,IAAI,CAACI,SAAS,EACnBP,IAAI,CAACG,IAAI,CAACY,KACZ,CAAC;EAEDlB,IAAI,CAACmB,mBAAmB,CACtBhB,IAAI,EACJC,CAAC,CAACgB,cAAc,CACdhB,CAAC,CAACW,SAAS,CAACZ,IAAI,CAACG,IAAI,CAACe,GAAG,CAAC,EAC1BL,kBAAkB,EAClBb,IAAI,CAACG,IAAI,CAACgB,QAAQ,EAClB,KACF,CACF,CAAC;EAMD,OAAOnB,IAAI,CAACoB,GAAG,CAAC,OAAO,CAAC;AAC1B","ignoreList":[]}

app_vue/node_modules/@babel/plugin-transform-regenerator/lib/regenerator/util.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTypes = getTypes;
+exports.isReference = isReference;
+exports.newHelpersAvailable = void 0;
+exports.replaceWithOrRemove = replaceWithOrRemove;
+exports.runtimeProperty = void 0;
+exports.wrapWithTypes = wrapWithTypes;
+let currentTypes = null;
+function wrapWithTypes(types, fn) {
+  return function (...args) {
+    const oldTypes = currentTypes;
+    currentTypes = types;
+    try {
+      return fn.apply(this, args);
+    } finally {
+      currentTypes = oldTypes;
+    }
+  };
+}
+function getTypes() {
+  return currentTypes;
+}
+let newHelpersAvailable = exports.newHelpersAvailable = void 0;
+{
+  exports.newHelpersAvailable = newHelpersAvailable = file => {
+    ;
+    return file.availableHelper("regenerator") && !getTypes().isIdentifier(file.addHelper("regenerator"), {
+      name: "__interal_marker_fallback_regenerator__"
+    });
+  };
+}
+let runtimeProperty = exports.runtimeProperty = void 0;
+{
+  exports.runtimeProperty = runtimeProperty = function (file, name) {
+    const t = getTypes();
+    const helper = file.addHelper("regeneratorRuntime");
+    return t.memberExpression(t.isArrowFunctionExpression(helper) && t.isIdentifier(helper.body) ? helper.body : t.callExpression(helper, []), t.identifier(name), false);
+  };
+}
+function isReference(path) {
+  return path.isReferenced() || path.parentPath.isAssignmentExpression({
+    left: path.node
+  });
+}
+function replaceWithOrRemove(path, replacement) {
+  if (replacement) {
+    path.replaceWith(replacement);
+  } else {
+    path.remove();
+  }
+}
+
+//# sourceMappingURL=util.js.map

app_vue/node_modules/@babel/plugin-transform-regenerator/lib/regenerator/util.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["currentTypes","wrapWithTypes","types","fn","args","oldTypes","apply","getTypes","newHelpersAvailable","exports","file","availableHelper","isIdentifier","addHelper","name","runtimeProperty","t","helper","memberExpression","isArrowFunctionExpression","body","callExpression","identifier","isReference","path","isReferenced","parentPath","isAssignmentExpression","left","node","replaceWithOrRemove","replacement","replaceWith","remove"],"sources":["../../src/regenerator/util.ts"],"sourcesContent":["import type { PluginPass } from \"@babel/core\";\n\nlet currentTypes: any = null;\n\nexport function wrapWithTypes<This, Args extends unknown[]>(\n  types: any,\n  fn: (this: This, ...args: Args) => unknown,\n) {\n  return function (this: This, ...args: Args) {\n    const oldTypes = currentTypes;\n    currentTypes = types;\n    try {\n      return fn.apply(this, args);\n    } finally {\n      currentTypes = oldTypes;\n    }\n  };\n}\n\nexport function getTypes() {\n  return currentTypes;\n}\n\nexport let newHelpersAvailable: (file: PluginPass) => boolean;\nif (!process.env.BABEL_8_BREAKING) {\n  newHelpersAvailable = (file: PluginPass) => {\n    if (!process.env.IS_PUBLISH && process.env.FORCE_OLD_REGENERATOR) {\n      // Only for testing purposes.\n      return false;\n    }\n    return (\n      file.availableHelper(\"regenerator\") &&\n      // At this point, we can safely try to inject the `regenerator` helper.\n      // If this plugin tries to inject any helper, than we are sure that\n      // `regenerator` is one of them.\n      !getTypes().isIdentifier(file.addHelper(\"regenerator\"), {\n        // This is a special marker returned by transform-runtime, which means\n        // \"the version of `@babel/runtime` does not have the helper\".\n        // Normally transform-runtime will fallback to just injecting the\n        // helper inline, but we special handle this case to instead be able\n        // to fallback to the old `regeneratorRuntime` helper\n        name: \"__interal_marker_fallback_regenerator__\",\n      })\n    );\n  };\n}\n\nexport let runtimeProperty: (file: PluginPass, name: any) => any;\nif (!process.env.BABEL_8_BREAKING) {\n  runtimeProperty = function (file, name) {\n    const t = getTypes();\n    const helper = file.addHelper(\"regeneratorRuntime\");\n    return t.memberExpression(\n      // In some cases, `helper` will be (() => regeneratorRuntime).\n      // Se the implementation in transform-runtime for more details.\n      t.isArrowFunctionExpression(helper) &&\n        t.isIdentifier((helper as any).body)\n        ? (helper as any).body\n        : t.callExpression(helper, []),\n      t.identifier(name),\n      false,\n    );\n  };\n}\n\nexport function isReference(path: any) {\n  return (\n    path.isReferenced() ||\n    path.parentPath.isAssignmentExpression({ left: path.node })\n  );\n}\n\nexport function replaceWithOrRemove(path: any, replacement: any) {\n  if (replacement) {\n    path.replaceWith(replacement);\n  } else {\n    path.remove();\n  }\n}\n"],"mappings":";;;;;;;;;;;AAEA,IAAIA,YAAiB,GAAG,IAAI;AAErB,SAASC,aAAaA,CAC3BC,KAAU,EACVC,EAA0C,EAC1C;EACA,OAAO,UAAsB,GAAGC,IAAU,EAAE;IAC1C,MAAMC,QAAQ,GAAGL,YAAY;IAC7BA,YAAY,GAAGE,KAAK;IACpB,IAAI;MACF,OAAOC,EAAE,CAACG,KAAK,CAAC,IAAI,EAAEF,IAAI,CAAC;IAC7B,CAAC,SAAS;MACRJ,YAAY,GAAGK,QAAQ;IACzB;EACF,CAAC;AACH;AAEO,SAASE,QAAQA,CAAA,EAAG;EACzB,OAAOP,YAAY;AACrB;AAEO,IAAIQ,mBAAkD,GAAAC,OAAA,CAAAD,mBAAA;AAC1B;EACjCC,OAAA,CAAAD,mBAAA,GAAAA,mBAAmB,GAAIE,IAAgB,IAAK;IAAA;IAK1C,OACEA,IAAI,CAACC,eAAe,CAAC,aAAa,CAAC,IAInC,CAACJ,QAAQ,CAAC,CAAC,CAACK,YAAY,CAACF,IAAI,CAACG,SAAS,CAAC,aAAa,CAAC,EAAE;MAMtDC,IAAI,EAAE;IACR,CAAC,CAAC;EAEN,CAAC;AACH;AAEO,IAAIC,eAAqD,GAAAN,OAAA,CAAAM,eAAA;AAC7B;EACjCN,OAAA,CAAAM,eAAA,GAAAA,eAAe,GAAG,SAAAA,CAAUL,IAAI,EAAEI,IAAI,EAAE;IACtC,MAAME,CAAC,GAAGT,QAAQ,CAAC,CAAC;IACpB,MAAMU,MAAM,GAAGP,IAAI,CAACG,SAAS,CAAC,oBAAoB,CAAC;IACnD,OAAOG,CAAC,CAACE,gBAAgB,CAGvBF,CAAC,CAACG,yBAAyB,CAACF,MAAM,CAAC,IACjCD,CAAC,CAACJ,YAAY,CAAEK,MAAM,CAASG,IAAI,CAAC,GACjCH,MAAM,CAASG,IAAI,GACpBJ,CAAC,CAACK,cAAc,CAACJ,MAAM,EAAE,EAAE,CAAC,EAChCD,CAAC,CAACM,UAAU,CAACR,IAAI,CAAC,EAClB,KACF,CAAC;EACH,CAAC;AACH;AAEO,SAASS,WAAWA,CAACC,IAAS,EAAE;EACrC,OACEA,IAAI,CAACC,YAAY,CAAC,CAAC,IACnBD,IAAI,CAACE,UAAU,CAACC,sBAAsB,CAAC;IAAEC,IAAI,EAAEJ,IAAI,CAACK;EAAK,CAAC,CAAC;AAE/D;AAEO,SAASC,mBAAmBA,CAACN,IAAS,EAAEO,WAAgB,EAAE;EAC/D,IAAIA,WAAW,EAAE;IACfP,IAAI,CAACQ,WAAW,CAACD,WAAW,CAAC;EAC/B,CAAC,MAAM;IACLP,IAAI,CAACS,MAAM,CAAC,CAAC;EACf;AACF","ignoreList":[]}

app_vue/node_modules/@babel/plugin-transform-regenerator/lib/regenerator/visit.js

@@ -0,0 +1,224 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getVisitor = void 0;
+var _assert = require("assert");
+var _hoist = require("./hoist.js");
+var _emit = require("./emit.js");
+var _replaceShorthandObjectMethod = require("./replaceShorthandObjectMethod.js");
+var util = require("./util.js");
+const getVisitor = t => ({
+  Method(path, state) {
+    const node = path.node;
+    if (!shouldRegenerate(node, state)) return;
+    const container = t.functionExpression(null, [], t.cloneNode(node.body, false), node.generator, node.async);
+    path.get("body").set("body", [t.returnStatement(t.callExpression(container, []))]);
+    node.async = false;
+    node.generator = false;
+    path.get("body.body.0.argument.callee").unwrapFunctionEnvironment();
+  },
+  Function: {
+    exit: util.wrapWithTypes(t, function (path, state) {
+      let node = path.node;
+      if (!shouldRegenerate(node, state)) return;
+      path = (0, _replaceShorthandObjectMethod.default)(path);
+      node = path.node;
+      const contextId = path.scope.generateUidIdentifier("context");
+      const argsId = path.scope.generateUidIdentifier("args");
+      path.ensureBlock();
+      const bodyBlockPath = path.get("body");
+      if (node.async) {
+        bodyBlockPath.traverse(awaitVisitor, this);
+      }
+      bodyBlockPath.traverse(functionSentVisitor, {
+        context: contextId,
+        pluginPass: this
+      });
+      const outerBody = [];
+      const innerBody = [];
+      bodyBlockPath.get("body").forEach(function (childPath) {
+        const node = childPath.node;
+        if (t.isExpressionStatement(node) && t.isStringLiteral(node.expression)) {
+          outerBody.push(node);
+        } else if ((node == null ? void 0 : node._blockHoist) != null) {
+          outerBody.push(node);
+        } else {
+          innerBody.push(node);
+        }
+      });
+      if (outerBody.length > 0) {
+        bodyBlockPath.node.body = innerBody;
+      }
+      const outerFnExpr = getOuterFnExpr(this, path);
+      t.assertIdentifier(node.id);
+      const vars = (0, _hoist.hoist)(path);
+      const context = {
+        usesThis: false,
+        usesArguments: false,
+        getArgsId: () => t.clone(argsId)
+      };
+      path.traverse(argumentsThisVisitor, context);
+      if (context.usesArguments) {
+        vars.push(t.variableDeclarator(t.clone(argsId), t.identifier("arguments")));
+      }
+      const emitter = new _emit.Emitter(contextId, path.scope, vars, this);
+      emitter.explode(path.get("body"));
+      if (vars.length > 0) {
+        outerBody.push(t.variableDeclaration("var", vars));
+      }
+      const wrapArgs = [emitter.getContextFunction()];
+      const tryLocsList = emitter.getTryLocsList();
+      if (node.generator) {
+        wrapArgs.push(outerFnExpr);
+      } else if (context.usesThis || tryLocsList || node.async) {
+        wrapArgs.push(t.nullLiteral());
+      }
+      if (context.usesThis) {
+        wrapArgs.push(t.thisExpression());
+      } else if (tryLocsList || node.async) {
+        wrapArgs.push(t.nullLiteral());
+      }
+      if (tryLocsList) {
+        wrapArgs.push(tryLocsList);
+      } else if (node.async) {
+        wrapArgs.push(t.nullLiteral());
+      }
+      if (node.async) {
+        let currentScope = path.scope;
+        do {
+          if (currentScope.hasOwnBinding("Promise")) currentScope.rename("Promise");
+        } while (currentScope = currentScope.parent);
+        wrapArgs.push(t.identifier("Promise"));
+      }
+      const wrapCall = t.callExpression(util.newHelpersAvailable(this) ? !node.async ? t.memberExpression(t.callExpression(this.addHelper("regenerator"), []), t.identifier("w")) : node.generator ? this.addHelper("regeneratorAsyncGen") : this.addHelper("regeneratorAsync") : util.runtimeProperty(this, node.async ? "async" : "wrap"), wrapArgs);
+      outerBody.push(t.returnStatement(wrapCall));
+      node.body = t.blockStatement(outerBody);
+      path.get("body.body").forEach(p => p.scope.registerDeclaration(p));
+      const oldDirectives = bodyBlockPath.node.directives;
+      if (oldDirectives) {
+        node.body.directives = oldDirectives;
+      }
+      const wasGeneratorFunction = node.generator;
+      if (wasGeneratorFunction) {
+        node.generator = false;
+      }
+      if (node.async) {
+        node.async = false;
+      }
+      if (wasGeneratorFunction && t.isExpression(node)) {
+        util.replaceWithOrRemove(path, t.callExpression(util.newHelpersAvailable(this) ? t.memberExpression(t.callExpression(this.addHelper("regenerator"), []), t.identifier("m")) : util.runtimeProperty(this, "mark"), [node]));
+        path.addComment("leading", "#__PURE__");
+      }
+      const insertedLocs = emitter.getInsertedLocs();
+      path.traverse({
+        NumericLiteral(path) {
+          if (!insertedLocs.has(path.node)) {
+            return;
+          }
+          path.replaceWith(t.numericLiteral(path.node.value));
+        }
+      });
+      path.requeue();
+    })
+  }
+});
+exports.getVisitor = getVisitor;
+function shouldRegenerate(node, state) {
+  if (node.generator) {
+    if (node.async) {
+      return state.opts.asyncGenerators !== false;
+    } else {
+      return state.opts.generators !== false;
+    }
+  } else if (node.async) {
+    return state.opts.async !== false;
+  } else {
+    return false;
+  }
+}
+function getOuterFnExpr(state, funPath) {
+  const t = util.getTypes();
+  const node = funPath.node;
+  t.assertFunction(node);
+  if (!node.id) {
+    node.id = funPath.scope.parent.generateUidIdentifier("callee");
+  }
+  if (node.generator && t.isFunctionDeclaration(node)) {
+    return getMarkedFunctionId(state, funPath);
+  }
+  return t.clone(node.id);
+}
+const markInfo = new WeakMap();
+function getMarkInfo(node) {
+  if (!markInfo.has(node)) {
+    markInfo.set(node, {});
+  }
+  return markInfo.get(node);
+}
+function getMarkedFunctionId(state, funPath) {
+  const t = util.getTypes();
+  const node = funPath.node;
+  t.assertIdentifier(node.id);
+  const blockPath = funPath.findParent(function (path) {
+    return path.isProgram() || path.isBlockStatement();
+  });
+  if (!blockPath) {
+    return node.id;
+  }
+  const block = blockPath.node;
+  _assert.ok(Array.isArray(block.body));
+  const info = getMarkInfo(block);
+  if (!info.decl) {
+    info.decl = t.variableDeclaration("var", []);
+    blockPath.unshiftContainer("body", info.decl);
+    info.declPath = blockPath.get("body.0");
+  }
+  _assert.strictEqual(info.declPath.node, info.decl);
+  const markedId = blockPath.scope.generateUidIdentifier("marked");
+  const markCallExp = t.callExpression(util.newHelpersAvailable(state) ? t.memberExpression(t.callExpression(state.addHelper("regenerator"), []), t.identifier("m")) : util.runtimeProperty(state, "mark"), [t.clone(node.id)]);
+  const index = info.decl.declarations.push(t.variableDeclarator(markedId, markCallExp)) - 1;
+  const markCallExpPath = info.declPath.get("declarations." + index + ".init");
+  _assert.strictEqual(markCallExpPath.node, markCallExp);
+  markCallExpPath.addComment("leading", "#__PURE__");
+  return t.clone(markedId);
+}
+const argumentsThisVisitor = {
+  "FunctionExpression|FunctionDeclaration|Method": function (path) {
+    path.skip();
+  },
+  Identifier: function (path, state) {
+    if (path.node.name === "arguments" && util.isReference(path)) {
+      util.replaceWithOrRemove(path, state.getArgsId());
+      state.usesArguments = true;
+    }
+  },
+  ThisExpression: function (path, state) {
+    state.usesThis = true;
+  }
+};
+const functionSentVisitor = {
+  MetaProperty(path, state) {
+    const {
+      node
+    } = path;
+    if (node.meta.name === "function" && node.property.name === "sent") {
+      const t = util.getTypes();
+      util.replaceWithOrRemove(path, t.memberExpression(t.clone(this.context), t.identifier(util.newHelpersAvailable(state.pluginPass) ? "v" : "_sent")));
+    }
+  }
+};
+const awaitVisitor = {
+  Function: function (path) {
+    path.skip();
+  },
+  AwaitExpression: function (path) {
+    const t = util.getTypes();
+    const argument = path.node.argument;
+    const helper = util.newHelpersAvailable(this) ? this.addHelper("awaitAsyncGenerator") : util.runtimeProperty(this, "awrap");
+    util.replaceWithOrRemove(path, t.yieldExpression(t.callExpression(helper, [argument]), false));
+  }
+};
+
+//# sourceMappingURL=visit.js.map