added babel

7 files changed, 371 insertions, 0 deletions

diff --git a/node_modules/@babel/preset-modules/src/plugins/transform-async-arrows-in-class/index.js b/node_modules/@babel/preset-modules/src/plugins/transform-async-arrows-in-class/index.js
new file mode 100644
index 00000000..b0594777
--- /dev/null
+++ b/node_modules/@babel/preset-modules/src/plugins/transform-async-arrows-in-class/index.js
@@ -0,0 +1,35 @@
+/**
+ * Safari 10.3 had an issue where async arrow function expressions within any class method would throw.
+ * After an initial fix, any references to the instance via `this` within those methods would also throw.
+ * This is fixed by converting arrow functions in class methods into equivalent function expressions.
+ * @see https://bugs.webkit.org/show_bug.cgi?id=166879
+ *
+ * @example
+ *   class X{ a(){ async () => {}; } }   // throws
+ *   class X{ a(){ async function() {}; } }   // works
+ *
+ * @example
+ *   class X{ a(){
+ *     async () => this.a;   // throws
+ *   } }
+ *   class X{ a(){
+ *     var _this=this;
+ *     async function() { return _this.a };   // works
+ *   } }
+ */
+
+const OPTS = {
+  allowInsertArrow: false,
+  specCompliant: false,
+};
+
+export default ({ types: t }) => ({
+  name: "transform-async-arrows-in-class",
+  visitor: {
+    ArrowFunctionExpression(path) {
+      if (path.node.async && path.findParent(t.isClassMethod)) {
+        path.arrowFunctionToExpression(OPTS);
+      }
+    },
+  },
+});
diff --git a/node_modules/@babel/preset-modules/src/plugins/transform-edge-default-parameters/index.js b/node_modules/@babel/preset-modules/src/plugins/transform-edge-default-parameters/index.js
new file mode 100644
index 00000000..fff50f19
--- /dev/null
+++ b/node_modules/@babel/preset-modules/src/plugins/transform-edge-default-parameters/index.js
@@ -0,0 +1,29 @@
+/**
+ * Converts destructured parameters with default values to non-shorthand syntax.
+ * This fixes the only arguments-related bug in ES Modules-supporting browsers (Edge 16 & 17).
+ * Use this plugin instead of @babel/plugin-transform-parameters when targeting ES Modules.
+ */
+
+export default ({ types: t }) => {
+  const isArrowParent = p =>
+    p.parentKey === "params" &&
+    p.parentPath &&
+    t.isArrowFunctionExpression(p.parentPath);
+
+  return {
+    name: "transform-edge-default-parameters",
+    visitor: {
+      AssignmentPattern(path) {
+        const arrowArgParent = path.find(isArrowParent);
+        if (arrowArgParent && path.parent.shorthand) {
+          // In Babel 7+, there is no way to force non-shorthand properties.
+          path.parent.shorthand = false;
+          (path.parent.extra || {}).shorthand = false;
+
+          // So, to ensure non-shorthand, rename the local identifier so it no longer matches:
+          path.scope.rename(path.parent.key.name);
+        }
+      },
+    },
+  };
+};
diff --git a/node_modules/@babel/preset-modules/src/plugins/transform-edge-function-name/index.js b/node_modules/@babel/preset-modules/src/plugins/transform-edge-function-name/index.js
new file mode 100644
index 00000000..f6873283
--- /dev/null
+++ b/node_modules/@babel/preset-modules/src/plugins/transform-edge-function-name/index.js
@@ -0,0 +1,31 @@
+/**
+ * Edge 16 & 17 do not infer function.name from variable assignment.
+ * All other `function.name` behavior works fine, so we can skip most of @babel/transform-function-name.
+ * @see https://kangax.github.io/compat-table/es6/#test-function_name_property_variables_(function)
+ *
+ * Note: contrary to various Github issues, Edge 16+ *does* correctly infer the name of Arrow Functions.
+ * The variable declarator name inference issue only affects function expressions, so that's all we fix here.
+ *
+ * A Note on Minification: Terser undoes this transform *by default* unless `keep_fnames` is set to true.
+ * There is by design - if Function.name is critical to your application, you must configure
+ * your minifier to preserve function names.
+ */
+
+export default ({ types: t }) => ({
+  name: "transform-edge-function-name",
+  visitor: {
+    FunctionExpression: {
+      exit(path) {
+        if (!path.node.id && t.isIdentifier(path.parent.id)) {
+          const id = t.cloneNode(path.parent.id);
+          const binding = path.scope.getBinding(id.name);
+          // if the binding gets reassigned anywhere, rename it
+          if (binding?.constantViolations.length) {
+            path.scope.rename(id.name);
+          }
+          path.node.id = id;
+        }
+      },
+    },
+  },
+});
diff --git a/node_modules/@babel/preset-modules/src/plugins/transform-jsx-spread/index.js b/node_modules/@babel/preset-modules/src/plugins/transform-jsx-spread/index.js
new file mode 100644
index 00000000..ef015245
--- /dev/null
+++ b/node_modules/@babel/preset-modules/src/plugins/transform-jsx-spread/index.js
@@ -0,0 +1,111 @@
+import esutils from "esutils";
+
+/**
+ * Converts JSX Spread arguments into Object Spread, avoiding Babel's helper or Object.assign injection.
+ * Input:
+ * 	 <div a="1" {...b} />
+ * Output:
+ *   <div {...{ a: "1", ...b }} />
+ * ...which Babel converts to:
+ *   h("div", { a: "1", ...b })
+ */
+export default ({ types: t }) => {
+  // converts a set of JSXAttributes to an Object.assign() call
+  function convertAttributesAssign(attributes) {
+    const args = [];
+    for (let i = 0, current; i < attributes.length; i++) {
+      const node = attributes[i];
+      if (t.isJSXSpreadAttribute(node)) {
+        // the first attribute is a spread, avoid copying all other attributes onto it
+        if (i === 0) {
+          args.push(t.objectExpression([]));
+        }
+        current = null;
+        args.push(node.argument);
+      } else {
+        const name = getAttributeName(node);
+        const value = getAttributeValue(node);
+        if (!current) {
+          current = t.objectExpression([]);
+          args.push(current);
+        }
+        current.properties.push(t.objectProperty(name, value));
+      }
+    }
+    return t.callExpression(
+      t.memberExpression(t.identifier("Object"), t.identifier("assign")),
+      args
+    );
+  }
+
+  // Converts a JSXAttribute to the equivalent ObjectExpression property
+  function convertAttributeSpread(node) {
+    if (t.isJSXSpreadAttribute(node)) {
+      return t.spreadElement(node.argument);
+    }
+
+    const name = getAttributeName(node);
+    const value = getAttributeValue(node);
+    return t.inherits(t.objectProperty(name, value), node);
+  }
+
+  // Convert a JSX attribute name to an Object expression property name
+  function getAttributeName(node) {
+    if (t.isJSXNamespacedName(node.name)) {
+      return t.stringLiteral(
+        node.name.namespace.name + ":" + node.name.name.name
+      );
+    }
+    if (esutils.keyword.isIdentifierNameES6(node.name.name)) {
+      return t.identifier(node.name.name);
+    }
+    return t.stringLiteral(node.name.name);
+  }
+
+  // Convert a JSX attribute value to a JavaScript expression value
+  function getAttributeValue(node) {
+    let value = node.value || t.booleanLiteral(true);
+
+    if (t.isJSXExpressionContainer(value)) {
+      value = value.expression;
+    } else if (t.isStringLiteral(value)) {
+      value.value = value.value.replace(/\n\s+/g, " ");
+
+      // "raw" JSXText should not be used from a StringLiteral because it needs to be escaped.
+      if (value.extra && value.extra.raw) {
+        delete value.extra.raw;
+      }
+    }
+
+    return value;
+  }
+
+  return {
+    name: "transform-jsx-spread",
+    visitor: {
+      JSXOpeningElement(path, state) {
+        const useSpread = state.opts.useSpread === true;
+        const hasSpread = path.node.attributes.some(attr =>
+          t.isJSXSpreadAttribute(attr)
+        );
+
+        // ignore JSX Elements without spread or with lone spread:
+        if (!hasSpread || path.node.attributes.length === 1) return;
+
+        if (useSpread) {
+          path.node.attributes = [
+            t.jsxSpreadAttribute(
+              t.objectExpression(
+                path.node.attributes.map(convertAttributeSpread)
+              )
+            ),
+          ];
+        } else {
+          path.node.attributes = [
+            t.jsxSpreadAttribute(convertAttributesAssign(path.node.attributes)),
+          ];
+        }
+      },
+    },
+  };
+};
diff --git a/node_modules/@babel/preset-modules/src/plugins/transform-safari-block-shadowing/index.js b/node_modules/@babel/preset-modules/src/plugins/transform-safari-block-shadowing/index.js
new file mode 100644
index 00000000..f509c6b6
--- /dev/null
+++ b/node_modules/@babel/preset-modules/src/plugins/transform-safari-block-shadowing/index.js
@@ -0,0 +1,39 @@
+/**
+ * Fixes block-shadowed let/const bindings in Safari 10/11.
+ * https://kangax.github.io/compat-table/es6/#test-let_scope_shadow_resolution
+ */
+export default function({ types: t }) {
+  return {
+    name: "transform-safari-block-shadowing",
+    visitor: {
+      VariableDeclarator(path) {
+        // the issue only affects let and const bindings:
+        const kind = path.parent.kind;
+        if (kind !== "let" && kind !== "const") return;
+
+        // ignore non-block-scoped bindings:
+        const block = path.scope.block;
+        if (t.isFunction(block) || t.isProgram(block)) return;
+
+        const bindings = t.getOuterBindingIdentifiers(path.node.id);
+        for (const name of Object.keys(bindings)) {
+          let scope = path.scope;
+
+          // ignore parent bindings (note: impossible due to let/const?)
+          if (!scope.hasOwnBinding(name)) continue;
+
+          // check if shadowed within the nearest function/program boundary
+          while ((scope = scope.parent)) {
+            if (scope.hasOwnBinding(name)) {
+              path.scope.rename(name);
+              break;
+            }
+            if (t.isFunction(scope.block) || t.isProgram(scope.block)) {
+              break;
+            }
+          }
+        }
+      },
+    },
+  };
+}
diff --git a/node_modules/@babel/preset-modules/src/plugins/transform-safari-for-shadowing/index.js b/node_modules/@babel/preset-modules/src/plugins/transform-safari-for-shadowing/index.js
new file mode 100644
index 00000000..83b4eafd
--- /dev/null
+++ b/node_modules/@babel/preset-modules/src/plugins/transform-safari-for-shadowing/index.js
@@ -0,0 +1,38 @@
+/**
+ * Safari ~11 has an issue where variable declarations in a For statement throw if they shadow parameters.
+ * This is fixed by renaming any declarations in the left/init part of a For* statement so they don't shadow.
+ * @see https://bugs.webkit.org/show_bug.cgi?id=171041
+ *
+ * @example
+ *   e => { for (let e of []) e }   // throws
+ *   e => { for (let _e of []) _e }   // works
+ */
+
+function handle(declaration) {
+  if (!declaration.isVariableDeclaration()) return;
+
+  const fn = declaration.getFunctionParent();
+  const { name } = declaration.node.declarations[0].id;
+
+  // check if there is a shadowed binding coming from a parameter
+  if (
+    fn &&
+    fn.scope.hasOwnBinding(name) &&
+    fn.scope.getOwnBinding(name).kind === "param"
+  ) {
+    declaration.scope.rename(name);
+  }
+}
+
+export default () => ({
+  name: "transform-safari-for-shadowing",
+  visitor: {
+    ForXStatement(path) {
+      handle(path.get("left"));
+    },
+
+    ForStatement(path) {
+      handle(path.get("init"));
+    },
+  },
+});
diff --git a/node_modules/@babel/preset-modules/src/plugins/transform-tagged-template-caching/index.js b/node_modules/@babel/preset-modules/src/plugins/transform-tagged-template-caching/index.js
new file mode 100644
index 00000000..65d03999
--- /dev/null
+++ b/node_modules/@babel/preset-modules/src/plugins/transform-tagged-template-caching/index.js
@@ -0,0 +1,88 @@
+/**
+ * Converts destructured parameters with default values to non-shorthand syntax.
+ * This fixes the only Tagged Templates-related bug in ES Modules-supporting browsers (Safari 10 & 11).
+ * Use this plugin instead of `@babel/plugin-transform-template-literals` when targeting ES Modules.
+ *
+ * @example
+ *   // Bug 1: Safari 10/11 doesn't reliably return the same Strings value.
+ *   // The value changes depending on invocation and function optimization state.
+ *   function f() { return Object`` }
+ *   f() === new f()  // false, should be true.
+ *
+ * @example
+ *   // Bug 2: Safari 10/11 use the same cached strings value when the string parts are the same.
+ *   // This behavior comes from an earlier version of the spec, and can cause tricky bugs.
+ *   Object``===Object``  // true, should be false.
+ *
+ * Benchmarks: https://jsperf.com/compiled-tagged-template-performance
+ */
+export default ({ types: t }) => ({
+  name: "transform-tagged-template-caching",
+  visitor: {
+    TaggedTemplateExpression(path, state) {
+      // tagged templates we've already dealt with
+      let processed = state.get("processed");
+      if (!processed) {
+        processed = new WeakSet();
+        state.set("processed", processed);
+      }
+
+      if (processed.has(path.node)) return path.skip();
+
+      // Grab the expressions from the original tag.
+      //   tag`a${'hello'}`  // ['hello']
+      const expressions = path.node.quasi.expressions;
+
+      // Create an identity function helper:
+      //   identity = t => t
+      let identity = state.get("identity");
+      if (!identity) {
+        identity = path.scope
+          .getProgramParent()
+          .generateDeclaredUidIdentifier("_");
+        state.set("identity", identity);
+        const binding = path.scope.getBinding(identity.name);
+        binding.path.get("init").replaceWith(
+          t.arrowFunctionExpression(
+            // re-use the helper identifier for compressability
+            [t.identifier("t")],
+            t.identifier("t")
+          )
+        );
+      }
+
+      // Use the identity function helper to get a reference to the template's Strings.
+      // We replace all expressions with `0` ensure Strings has the same shape.
+      //   identity`a${0}`
+      const template = t.taggedTemplateExpression(
+        t.cloneNode(identity),
+        t.templateLiteral(
+          path.node.quasi.quasis,
+          expressions.map(() => t.numericLiteral(0))
+        )
+      );
+      processed.add(template);
+
+      // Install an inline cache at the callsite using the global variable:
+      //   _t || (_t = identity`a${0}`)
+      const ident = path.scope
+        .getProgramParent()
+        .generateDeclaredUidIdentifier("t");
+      path.scope.getBinding(ident.name).path.parent.kind = "let";
+      const inlineCache = t.logicalExpression(
+        "||",
+        ident,
+        t.assignmentExpression("=", t.cloneNode(ident), template)
+      );
+
+      // The original tag function becomes a plain function call.
+      // The expressions omitted from the cached Strings tag are directly applied as arguments.
+      //   tag(_t || (_t = Object`a${0}`), 'hello')
+      const node = t.callExpression(path.node.tag, [
+        inlineCache,
+        ...expressions,
+      ]);
+      path.replaceWith(node);
+    },
+  },
+});