Add react

node_modules/babel-plugin-transform-runtime/lib/definitions.js

@@ -0,0 +1,191 @@
+"use strict";
+
+module.exports = {
+  builtins: {
+    Symbol: "symbol",
+    Promise: "promise",
+    Map: "map",
+    WeakMap: "weak-map",
+    Set: "set",
+    WeakSet: "weak-set",
+    Observable: "observable",
+    setImmediate: "set-immediate",
+    clearImmediate: "clear-immediate",
+    asap: "asap"
+  },
+
+  methods: {
+    Array: {
+      concat: "array/concat",
+      copyWithin: "array/copy-within",
+      entries: "array/entries",
+      every: "array/every",
+      fill: "array/fill",
+      filter: "array/filter",
+      findIndex: "array/find-index",
+      find: "array/find",
+      forEach: "array/for-each",
+      from: "array/from",
+      includes: "array/includes",
+      indexOf: "array/index-of",
+
+      join: "array/join",
+      keys: "array/keys",
+      lastIndexOf: "array/last-index-of",
+      map: "array/map",
+      of: "array/of",
+      pop: "array/pop",
+      push: "array/push",
+      reduceRight: "array/reduce-right",
+      reduce: "array/reduce",
+      reverse: "array/reverse",
+      shift: "array/shift",
+      slice: "array/slice",
+      some: "array/some",
+      sort: "array/sort",
+      splice: "array/splice",
+      unshift: "array/unshift",
+      values: "array/values"
+    },
+
+    JSON: {
+      stringify: "json/stringify"
+    },
+
+    Object: {
+      assign: "object/assign",
+      create: "object/create",
+      defineProperties: "object/define-properties",
+      defineProperty: "object/define-property",
+      entries: "object/entries",
+      freeze: "object/freeze",
+      getOwnPropertyDescriptor: "object/get-own-property-descriptor",
+      getOwnPropertyDescriptors: "object/get-own-property-descriptors",
+      getOwnPropertyNames: "object/get-own-property-names",
+      getOwnPropertySymbols: "object/get-own-property-symbols",
+      getPrototypeOf: "object/get-prototype-of",
+      isExtensible: "object/is-extensible",
+      isFrozen: "object/is-frozen",
+      isSealed: "object/is-sealed",
+      is: "object/is",
+      keys: "object/keys",
+      preventExtensions: "object/prevent-extensions",
+      seal: "object/seal",
+      setPrototypeOf: "object/set-prototype-of",
+      values: "object/values"
+    },
+
+    RegExp: {
+      escape: "regexp/escape" },
+
+    Math: {
+      acosh: "math/acosh",
+      asinh: "math/asinh",
+      atanh: "math/atanh",
+      cbrt: "math/cbrt",
+      clz32: "math/clz32",
+      cosh: "math/cosh",
+      expm1: "math/expm1",
+      fround: "math/fround",
+      hypot: "math/hypot",
+      imul: "math/imul",
+      log10: "math/log10",
+      log1p: "math/log1p",
+      log2: "math/log2",
+      sign: "math/sign",
+      sinh: "math/sinh",
+      tanh: "math/tanh",
+      trunc: "math/trunc",
+      iaddh: "math/iaddh",
+      isubh: "math/isubh",
+      imulh: "math/imulh",
+      umulh: "math/umulh"
+    },
+
+    Symbol: {
+      for: "symbol/for",
+      hasInstance: "symbol/has-instance",
+      isConcatSpreadable: "symbol/is-concat-spreadable",
+      iterator: "symbol/iterator",
+      keyFor: "symbol/key-for",
+      match: "symbol/match",
+      replace: "symbol/replace",
+      search: "symbol/search",
+      species: "symbol/species",
+      split: "symbol/split",
+      toPrimitive: "symbol/to-primitive",
+      toStringTag: "symbol/to-string-tag",
+      unscopables: "symbol/unscopables"
+    },
+
+    String: {
+      at: "string/at",
+      codePointAt: "string/code-point-at",
+      endsWith: "string/ends-with",
+      fromCodePoint: "string/from-code-point",
+      includes: "string/includes",
+      matchAll: "string/match-all",
+      padLeft: "string/pad-left",
+      padRight: "string/pad-right",
+      padStart: "string/pad-start",
+      padEnd: "string/pad-end",
+      raw: "string/raw",
+      repeat: "string/repeat",
+      startsWith: "string/starts-with",
+      trim: "string/trim",
+      trimLeft: "string/trim-left",
+      trimRight: "string/trim-right",
+      trimStart: "string/trim-start",
+      trimEnd: "string/trim-end"
+    },
+
+    Number: {
+      EPSILON: "number/epsilon",
+      isFinite: "number/is-finite",
+      isInteger: "number/is-integer",
+      isNaN: "number/is-nan",
+      isSafeInteger: "number/is-safe-integer",
+      MAX_SAFE_INTEGER: "number/max-safe-integer",
+      MIN_SAFE_INTEGER: "number/min-safe-integer",
+      parseFloat: "number/parse-float",
+      parseInt: "number/parse-int"
+    },
+
+    Reflect: {
+      apply: "reflect/apply",
+      construct: "reflect/construct",
+      defineProperty: "reflect/define-property",
+      deleteProperty: "reflect/delete-property",
+      enumerate: "reflect/enumerate",
+      getOwnPropertyDescriptor: "reflect/get-own-property-descriptor",
+      getPrototypeOf: "reflect/get-prototype-of",
+      get: "reflect/get",
+      has: "reflect/has",
+      isExtensible: "reflect/is-extensible",
+      ownKeys: "reflect/own-keys",
+      preventExtensions: "reflect/prevent-extensions",
+      setPrototypeOf: "reflect/set-prototype-of",
+      set: "reflect/set",
+      defineMetadata: "reflect/define-metadata",
+      deleteMetadata: "reflect/delete-metadata",
+      getMetadata: "reflect/get-metadata",
+      getMetadataKeys: "reflect/get-metadata-keys",
+      getOwnMetadata: "reflect/get-own-metadata",
+      getOwnMetadataKeys: "reflect/get-own-metadata-keys",
+      hasMetadata: "reflect/has-metadata",
+      hasOwnMetadata: "reflect/has-own-metadata",
+      metadata: "reflect/metadata"
+    },
+
+    System: {
+      global: "system/global"
+    },
+
+    Error: {
+      isError: "error/is-error" },
+
+    Date: {},
+
+    Function: {}
+  }
+};

node_modules/babel-plugin-transform-runtime/lib/index.js

@@ -0,0 +1,133 @@
+"use strict";
+
+exports.__esModule = true;
+exports.definitions = undefined;
+
+exports.default = function (_ref) {
+  var t = _ref.types;
+
+  function getRuntimeModuleName(opts) {
+    return opts.moduleName || "babel-runtime";
+  }
+
+  function has(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+  }
+
+  var HELPER_BLACKLIST = ["interopRequireWildcard", "interopRequireDefault"];
+
+  return {
+    pre: function pre(file) {
+      var moduleName = getRuntimeModuleName(this.opts);
+
+      if (this.opts.helpers !== false) {
+        file.set("helperGenerator", function (name) {
+          if (HELPER_BLACKLIST.indexOf(name) < 0) {
+            return file.addImport(moduleName + "/helpers/" + name, "default", name);
+          }
+        });
+      }
+
+      this.setDynamic("regeneratorIdentifier", function () {
+        return file.addImport(moduleName + "/regenerator", "default", "regeneratorRuntime");
+      });
+    },
+
+
+    visitor: {
+      ReferencedIdentifier: function ReferencedIdentifier(path, state) {
+        var node = path.node,
+            parent = path.parent,
+            scope = path.scope;
+
+
+        if (node.name === "regeneratorRuntime" && state.opts.regenerator !== false) {
+          path.replaceWith(state.get("regeneratorIdentifier"));
+          return;
+        }
+
+        if (state.opts.polyfill === false) return;
+
+        if (t.isMemberExpression(parent)) return;
+        if (!has(_definitions2.default.builtins, node.name)) return;
+        if (scope.getBindingIdentifier(node.name)) return;
+
+        var moduleName = getRuntimeModuleName(state.opts);
+        path.replaceWith(state.addImport(moduleName + "/core-js/" + _definitions2.default.builtins[node.name], "default", node.name));
+      },
+      CallExpression: function CallExpression(path, state) {
+        if (state.opts.polyfill === false) return;
+
+        if (path.node.arguments.length) return;
+
+        var callee = path.node.callee;
+        if (!t.isMemberExpression(callee)) return;
+        if (!callee.computed) return;
+        if (!path.get("callee.property").matchesPattern("Symbol.iterator")) return;
+
+        var moduleName = getRuntimeModuleName(state.opts);
+        path.replaceWith(t.callExpression(state.addImport(moduleName + "/core-js/get-iterator", "default", "getIterator"), [callee.object]));
+      },
+      BinaryExpression: function BinaryExpression(path, state) {
+        if (state.opts.polyfill === false) return;
+
+        if (path.node.operator !== "in") return;
+        if (!path.get("left").matchesPattern("Symbol.iterator")) return;
+
+        var moduleName = getRuntimeModuleName(state.opts);
+        path.replaceWith(t.callExpression(state.addImport(moduleName + "/core-js/is-iterable", "default", "isIterable"), [path.node.right]));
+      },
+
+      MemberExpression: {
+        enter: function enter(path, state) {
+          if (state.opts.polyfill === false) return;
+          if (!path.isReferenced()) return;
+
+          var node = path.node;
+
+          var obj = node.object;
+          var prop = node.property;
+
+          if (!t.isReferenced(obj, node)) return;
+          if (node.computed) return;
+          if (!has(_definitions2.default.methods, obj.name)) return;
+
+          var methods = _definitions2.default.methods[obj.name];
+          if (!has(methods, prop.name)) return;
+
+          if (path.scope.getBindingIdentifier(obj.name)) return;
+
+          if (obj.name === "Object" && prop.name === "defineProperty" && path.parentPath.isCallExpression()) {
+            var call = path.parentPath.node;
+            if (call.arguments.length === 3 && t.isLiteral(call.arguments[1])) return;
+          }
+
+          var moduleName = getRuntimeModuleName(state.opts);
+          path.replaceWith(state.addImport(moduleName + "/core-js/" + methods[prop.name], "default", obj.name + "$" + prop.name));
+        },
+        exit: function exit(path, state) {
+          if (state.opts.polyfill === false) return;
+          if (!path.isReferenced()) return;
+
+          var node = path.node;
+
+          var obj = node.object;
+
+          if (!has(_definitions2.default.builtins, obj.name)) return;
+          if (path.scope.getBindingIdentifier(obj.name)) return;
+
+          var moduleName = getRuntimeModuleName(state.opts);
+          path.replaceWith(t.memberExpression(state.addImport(moduleName + "/core-js/" + _definitions2.default.builtins[obj.name], "default", obj.name), node.property, node.computed));
+        }
+      }
+    }
+  };
+};
+
+var _definitions = require("./definitions");
+
+var _definitions2 = _interopRequireDefault(_definitions);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.definitions = _definitions2.default;