node: updatemain

1 files changed, 0 insertions, 291 deletions

diff --git a/node_modules/@babel/plugin-transform-block-scoping/lib/loop.js b/node_modules/@babel/plugin-transform-block-scoping/lib/loop.js
deleted file mode 100644
index be02e92c..00000000
--- a/node_modules/@babel/plugin-transform-block-scoping/lib/loop.js
+++ /dev/null
@@ -1,291 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getLoopBodyBindings = getLoopBodyBindings;
-exports.getUsageInBody = getUsageInBody;
-exports.isVarInLoopHead = isVarInLoopHead;
-exports.wrapLoopBody = wrapLoopBody;
-var _core = require("@babel/core");
-const collectLoopBodyBindingsVisitor = {
-  "Expression|Declaration|Loop"(path) {
-    path.skip();
-  },
-  Scope(path, state) {
-    if (path.isFunctionParent()) path.skip();
-    const {
-      bindings
-    } = path.scope;
-    for (const name of Object.keys(bindings)) {
-      const binding = bindings[name];
-      if (binding.kind === "let" || binding.kind === "const" || binding.kind === "hoisted") {
-        state.blockScoped.push(binding);
-      }
-    }
-  }
-};
-function getLoopBodyBindings(loopPath) {
-  const state = {
-    blockScoped: []
-  };
-  loopPath.traverse(collectLoopBodyBindingsVisitor, state);
-  return state.blockScoped;
-}
-function getUsageInBody(binding, loopPath) {
-  const seen = new WeakSet();
-  let capturedInClosure = false;
-  const constantViolations = filterMap(binding.constantViolations, path => {
-    const {
-      inBody,
-      inClosure
-    } = relativeLoopLocation(path, loopPath);
-    if (!inBody) return null;
-    capturedInClosure || (capturedInClosure = inClosure);
-    const id = path.isUpdateExpression() ? path.get("argument") : path.isAssignmentExpression() ? path.get("left") : null;
-    if (id) seen.add(id.node);
-    return id;
-  });
-  const references = filterMap(binding.referencePaths, path => {
-    if (seen.has(path.node)) return null;
-    const {
-      inBody,
-      inClosure
-    } = relativeLoopLocation(path, loopPath);
-    if (!inBody) return null;
-    capturedInClosure || (capturedInClosure = inClosure);
-    return path;
-  });
-  return {
-    capturedInClosure,
-    hasConstantViolations: constantViolations.length > 0,
-    usages: references.concat(constantViolations)
-  };
-}
-function relativeLoopLocation(path, loopPath) {
-  const bodyPath = loopPath.get("body");
-  let inClosure = false;
-  for (let currPath = path; currPath; currPath = currPath.parentPath) {
-    if (currPath.isFunction() || currPath.isClass() || currPath.isMethod()) {
-      inClosure = true;
-    }
-    if (currPath === bodyPath) {
-      return {
-        inBody: true,
-        inClosure
-      };
-    } else if (currPath === loopPath) {
-      return {
-        inBody: false,
-        inClosure
-      };
-    }
-  }
-  throw new Error("Internal Babel error: path is not in loop. Please report this as a bug.");
-}
-const collectCompletionsAndVarsVisitor = {
-  Function(path) {
-    path.skip();
-  },
-  LabeledStatement: {
-    enter({
-      node
-    }, state) {
-      state.labelsStack.push(node.label.name);
-    },
-    exit({
-      node
-    }, state) {
-      const popped = state.labelsStack.pop();
-      if (popped !== node.label.name) {
-        throw new Error("Assertion failure. Please report this bug to Babel.");
-      }
-    }
-  },
-  Loop: {
-    enter(_, state) {
-      state.labellessContinueTargets++;
-      state.labellessBreakTargets++;
-    },
-    exit(_, state) {
-      state.labellessContinueTargets--;
-      state.labellessBreakTargets--;
-    }
-  },
-  SwitchStatement: {
-    enter(_, state) {
-      state.labellessBreakTargets++;
-    },
-    exit(_, state) {
-      state.labellessBreakTargets--;
-    }
-  },
-  "BreakStatement|ContinueStatement"(path, state) {
-    const {
-      label
-    } = path.node;
-    if (label) {
-      if (state.labelsStack.includes(label.name)) return;
-    } else if (path.isBreakStatement() ? state.labellessBreakTargets > 0 : state.labellessContinueTargets > 0) {
-      return;
-    }
-    state.breaksContinues.push(path);
-  },
-  ReturnStatement(path, state) {
-    state.returns.push(path);
-  },
-  VariableDeclaration(path, state) {
-    if (path.parent === state.loopNode && isVarInLoopHead(path)) return;
-    if (path.node.kind === "var") state.vars.push(path);
-  }
-};
-function wrapLoopBody(loopPath, captured, updatedBindingsUsages) {
-  const loopNode = loopPath.node;
-  const state = {
-    breaksContinues: [],
-    returns: [],
-    labelsStack: [],
-    labellessBreakTargets: 0,
-    labellessContinueTargets: 0,
-    vars: [],
-    loopNode
-  };
-  loopPath.traverse(collectCompletionsAndVarsVisitor, state);
-  const callArgs = [];
-  const closureParams = [];
-  const updater = [];
-  for (const [name, updatedUsage] of updatedBindingsUsages) {
-    callArgs.push(_core.types.identifier(name));
-    const innerName = loopPath.scope.generateUid(name);
-    closureParams.push(_core.types.identifier(innerName));
-    updater.push(_core.types.assignmentExpression("=", _core.types.identifier(name), _core.types.identifier(innerName)));
-    for (const path of updatedUsage) path.replaceWith(_core.types.identifier(innerName));
-  }
-  for (const name of captured) {
-    if (updatedBindingsUsages.has(name)) continue;
-    callArgs.push(_core.types.identifier(name));
-    closureParams.push(_core.types.identifier(name));
-  }
-  const id = loopPath.scope.generateUid("loop");
-  const fn = _core.types.functionExpression(null, closureParams, _core.types.toBlock(loopNode.body));
-  let call = _core.types.callExpression(_core.types.identifier(id), callArgs);
-  const fnParent = loopPath.findParent(p => p.isFunction());
-  if (fnParent) {
-    const {
-      async,
-      generator
-    } = fnParent.node;
-    fn.async = async;
-    fn.generator = generator;
-    if (generator) call = _core.types.yieldExpression(call, true);else if (async) call = _core.types.awaitExpression(call);
-  }
-  const updaterNode = updater.length > 0 ? _core.types.expressionStatement(_core.types.sequenceExpression(updater)) : null;
-  if (updaterNode) fn.body.body.push(updaterNode);
-  const [varPath] = loopPath.insertBefore(_core.types.variableDeclaration("var", [_core.types.variableDeclarator(_core.types.identifier(id), fn)]));
-  const bodyStmts = [];
-  const varNames = [];
-  for (const varPath of state.vars) {
-    const assign = [];
-    for (const decl of varPath.node.declarations) {
-      varNames.push(...Object.keys(_core.types.getBindingIdentifiers(decl.id)));
-      if (decl.init) {
-        assign.push(_core.types.assignmentExpression("=", decl.id, decl.init));
-      } else if (_core.types.isForXStatement(varPath.parent, {
-        left: varPath.node
-      })) {
-        assign.push(decl.id);
-      }
-    }
-    if (assign.length > 0) {
-      const replacement = assign.length === 1 ? assign[0] : _core.types.sequenceExpression(assign);
-      varPath.replaceWith(replacement);
-    } else {
-      varPath.remove();
-    }
-  }
-  if (varNames.length) {
-    varPath.pushContainer("declarations", varNames.map(name => _core.types.variableDeclarator(_core.types.identifier(name))));
-  }
-  const labelNum = state.breaksContinues.length;
-  const returnNum = state.returns.length;
-  if (labelNum + returnNum === 0) {
-    bodyStmts.push(_core.types.expressionStatement(call));
-  } else if (labelNum === 1 && returnNum === 0) {
-    for (const path of state.breaksContinues) {
-      const {
-        node
-      } = path;
-      const {
-        type,
-        label
-      } = node;
-      let name = type === "BreakStatement" ? "break" : "continue";
-      if (label) name += " " + label.name;
-      path.replaceWith(_core.types.addComment(_core.types.returnStatement(_core.types.numericLiteral(1)), "trailing", " " + name, true));
-      if (updaterNode) path.insertBefore(_core.types.cloneNode(updaterNode));
-      bodyStmts.push(_core.template.statement.ast`
-        if (${call}) ${node}
-      `);
-    }
-  } else {
-    const completionId = loopPath.scope.generateUid("ret");
-    if (varPath.isVariableDeclaration()) {
-      varPath.pushContainer("declarations", [_core.types.variableDeclarator(_core.types.identifier(completionId))]);
-      bodyStmts.push(_core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.identifier(completionId), call)));
-    } else {
-      bodyStmts.push(_core.types.variableDeclaration("var", [_core.types.variableDeclarator(_core.types.identifier(completionId), call)]));
-    }
-    const injected = [];
-    for (const path of state.breaksContinues) {
-      const {
-        node
-      } = path;
-      const {
-        type,
-        label
-      } = node;
-      let name = type === "BreakStatement" ? "break" : "continue";
-      if (label) name += " " + label.name;
-      let i = injected.indexOf(name);
-      const hasInjected = i !== -1;
-      if (!hasInjected) {
-        injected.push(name);
-        i = injected.length - 1;
-      }
-      path.replaceWith(_core.types.addComment(_core.types.returnStatement(_core.types.numericLiteral(i)), "trailing", " " + name, true));
-      if (updaterNode) path.insertBefore(_core.types.cloneNode(updaterNode));
-      if (hasInjected) continue;
-      bodyStmts.push(_core.template.statement.ast`
-        if (${_core.types.identifier(completionId)} === ${_core.types.numericLiteral(i)}) ${node}
-      `);
-    }
-    if (returnNum) {
-      for (const path of state.returns) {
-        const arg = path.node.argument || path.scope.buildUndefinedNode();
-        path.replaceWith(_core.template.statement.ast`
-          return { v: ${arg} };
-        `);
-      }
-      bodyStmts.push(_core.template.statement.ast`
-          if (${_core.types.identifier(completionId)}) return ${_core.types.identifier(completionId)}.v;
-        `);
-    }
-  }
-  loopNode.body = _core.types.blockStatement(bodyStmts);
-  return varPath;
-}
-function isVarInLoopHead(path) {
-  if (_core.types.isForStatement(path.parent)) return path.key === "init";
-  if (_core.types.isForXStatement(path.parent)) return path.key === "left";
-  return false;
-}
-function filterMap(list, fn) {
-  const result = [];
-  for (const item of list) {
-    const mapped = fn(item);
-    if (mapped) result.push(mapped);
-  }
-  return result;
-}
-
-//# sourceMappingURL=loop.js.map