switch to vuepress

3 files changed, 409 insertions, 0 deletions

diff --git a/node_modules/@babel/plugin-transform-modules-commonjs/README.md b/node_modules/@babel/plugin-transform-modules-commonjs/README.md
new file mode 100644
index 00000000..96c1a2b8
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-modules-commonjs/README.md
@@ -0,0 +1,163 @@
+# @babel/plugin-transform-modules-commonjs
+
+> This plugin transforms ES2015 modules to [CommonJS](http://wiki.commonjs.org/wiki/Modules/1.1).
+
+## Example
+
+**In**
+
+```javascript
+export default 42;
+```
+
+**Out**
+
+```javascript
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = 42;
+```
+
+## Installation
+
+```sh
+npm install --save-dev @babel/plugin-transform-modules-commonjs
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```js
+// without options
+{
+  "plugins": ["@babel/plugin-transform-modules-commonjs"]
+}
+
+// with options
+{
+  "plugins": [
+    ["@babel/plugin-transform-modules-commonjs", {
+      "allowTopLevelThis": true
+    }]
+  ]
+}
+```
+
+### Via CLI
+
+```sh
+babel --plugins @babel/plugin-transform-modules-commonjs script.js
+```
+
+### Via Node API
+
+```javascript
+require("@babel/core").transform("code", {
+  plugins: ["@babel/plugin-transform-modules-commonjs"]
+});
+```
+
+## Options
+
+### `loose`
+
+`boolean`, defaults to `false`.
+
+By default, when using exports with babel a non-enumerable `__esModule` property
+is exported.
+
+```javascript
+var foo = exports.foo = 5;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+```
+
+In environments that don't support this you can enable loose mode on `@babel/plugin-transform-modules-commonjs`
+and instead of using `Object.defineProperty` an assignment will be used instead.
+
+```javascript
+var foo = exports.foo = 5;
+exports.__esModule = true;
+```
+
+### `strict`
+
+`boolean`, defaults to `false`
+
+By default, when using exports with babel a non-enumerable `__esModule` property
+is exported. In some cases this property is used to determine if the import _is_ the
+default export or if it _contains_ the default export.
+
+```javascript
+var foo = exports.foo = 5;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+```
+
+In order to prevent the `__esModule` property from being exported, you can set
+the `strict` option to `true`.
+
+### `noInterop`
+
+`boolean`, defaults to `false`
+
+By default, when using exports with babel a non-enumerable `__esModule` property
+is exported. This property is then used to determine if the import _is_ the default
+export or if it _contains_ the default export.
+
+```javascript
+"use strict";
+
+var _foo = _interopRequireDefault(require("foo"));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+```
+
+In cases where the auto-unwrapping of `default` is not needed, you can set the
+`noInterop` option to `true` to avoid the usage of the `interopRequireDefault`
+helper (shown in inline form above).
+
+### `lazy`
+
+`boolean`, `Array<string>`, or `(string) => boolean`, defaults to `false`
+
+Changes Babel's compiled `import` statements to be lazily evaluated when their
+imported bindings are used for the first time.
+
+This can improve initial load time of your module because evaluating
+dependencies up front is sometimes entirely un-necessary. This is especially
+the case when implementing a library module.
+
+The value of `lazy` has a few possible effects:
+
+* `false` - No lazy initialization of any imported module.
+* `true` - Do not lazy-initialize local `./foo` imports, but lazy-init `foo` dependencies.
+
+  Local paths are much more likely to have circular dependencies, which may break if loaded lazily,
+  so they are not lazy by default, whereas dependencies between independent modules are rarely cyclical.
+
+* `Array<string>` - Lazy-initialize all imports with source matching one of the given strings.
+* `(string) => boolean` - Pass a callback that will be called to decide if a given source string should be lazy-loaded.
+
+The two cases where imports can never be lazy are:
+
+* `import "foo";`
+
+  Side-effect imports are automatically non-lazy since their very existence means
+  that there is no binding to later kick off initialization.
+
+* `export * from "foo"`
+
+  Re-exporting all names requires up-front execution because otherwise there is no
+  way to know what names need to be exported.
diff --git a/node_modules/@babel/plugin-transform-modules-commonjs/lib/index.js b/node_modules/@babel/plugin-transform-modules-commonjs/lib/index.js
new file mode 100644
index 00000000..2d0d2258
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-modules-commonjs/lib/index.js
@@ -0,0 +1,222 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _helperPluginUtils() {
+  const data = require("@babel/helper-plugin-utils");
+
+  _helperPluginUtils = function _helperPluginUtils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperModuleTransforms() {
+  const data = require("@babel/helper-module-transforms");
+
+  _helperModuleTransforms = function _helperModuleTransforms() {
+    return data;
+  };
+
+  return data;
+}
+
+function _helperSimpleAccess() {
+  const data = _interopRequireDefault(require("@babel/helper-simple-access"));
+
+  _helperSimpleAccess = function _helperSimpleAccess() {
+    return data;
+  };
+
+  return data;
+}
+
+function _core() {
+  const data = require("@babel/core");
+
+  _core = function _core() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _helperPluginUtils().declare)((api, options) => {
+  api.assertVersion(7);
+  const loose = options.loose,
+        _options$strictNamesp = options.strictNamespace,
+        strictNamespace = _options$strictNamesp === void 0 ? false : _options$strictNamesp,
+        _options$mjsStrictNam = options.mjsStrictNamespace,
+        mjsStrictNamespace = _options$mjsStrictNam === void 0 ? true : _options$mjsStrictNam,
+        allowTopLevelThis = options.allowTopLevelThis,
+        strict = options.strict,
+        strictMode = options.strictMode,
+        noInterop = options.noInterop,
+        _options$lazy = options.lazy,
+        lazy = _options$lazy === void 0 ? false : _options$lazy,
+        _options$allowCommonJ = options.allowCommonJSExports,
+        allowCommonJSExports = _options$allowCommonJ === void 0 ? true : _options$allowCommonJ;
+
+  if (typeof lazy !== "boolean" && typeof lazy !== "function" && (!Array.isArray(lazy) || !lazy.every(item => typeof item === "string"))) {
+    throw new Error(`.lazy must be a boolean, array of strings, or a function`);
+  }
+
+  if (typeof strictNamespace !== "boolean") {
+    throw new Error(`.strictNamespace must be a boolean, or undefined`);
+  }
+
+  if (typeof mjsStrictNamespace !== "boolean") {
+    throw new Error(`.mjsStrictNamespace must be a boolean, or undefined`);
+  }
+
+  const getAssertion = localName => _core().template.expression.ast`
+    (function(){
+      throw new Error(
+        "The CommonJS '" + "${localName}" + "' variable is not available in ES6 modules." +
+        "Consider setting setting sourceType:script or sourceType:unambiguous in your " +
+        "Babel config for this file.");
+    })()
+  `;
+
+  const moduleExportsVisitor = {
+    ReferencedIdentifier(path) {
+      const localName = path.node.name;
+      if (localName !== "module" && localName !== "exports") return;
+      const localBinding = path.scope.getBinding(localName);
+      const rootBinding = this.scope.getBinding(localName);
+
+      if (rootBinding !== localBinding || path.parentPath.isObjectProperty({
+        value: path.node
+      }) && path.parentPath.parentPath.isObjectPattern() || path.parentPath.isAssignmentExpression({
+        left: path.node
+      }) || path.isAssignmentExpression({
+        left: path.node
+      })) {
+        return;
+      }
+
+      path.replaceWith(getAssertion(localName));
+    },
+
+    AssignmentExpression(path) {
+      const left = path.get("left");
+
+      if (left.isIdentifier()) {
+        const localName = path.node.name;
+        if (localName !== "module" && localName !== "exports") return;
+        const localBinding = path.scope.getBinding(localName);
+        const rootBinding = this.scope.getBinding(localName);
+        if (rootBinding !== localBinding) return;
+        const right = path.get("right");
+        right.replaceWith(_core().types.sequenceExpression([right.node, getAssertion(localName)]));
+      } else if (left.isPattern()) {
+        const ids = left.getOuterBindingIdentifiers();
+        const localName = Object.keys(ids).filter(localName => {
+          if (localName !== "module" && localName !== "exports") return false;
+          return this.scope.getBinding(localName) === path.scope.getBinding(localName);
+        })[0];
+
+        if (localName) {
+          const right = path.get("right");
+          right.replaceWith(_core().types.sequenceExpression([right.node, getAssertion(localName)]));
+        }
+      }
+    }
+
+  };
+  return {
+    visitor: {
+      Program: {
+        exit(path, state) {
+          if (!(0, _helperModuleTransforms().isModule)(path)) return;
+          path.scope.rename("exports");
+          path.scope.rename("module");
+          path.scope.rename("require");
+          path.scope.rename("__filename");
+          path.scope.rename("__dirname");
+
+          if (!allowCommonJSExports) {
+            (0, _helperSimpleAccess().default)(path, new Set(["module", "exports"]));
+            path.traverse(moduleExportsVisitor, {
+              scope: path.scope
+            });
+          }
+
+          let moduleName = this.getModuleName();
+          if (moduleName) moduleName = _core().types.stringLiteral(moduleName);
+
+          const _rewriteModuleStateme = (0, _helperModuleTransforms().rewriteModuleStatementsAndPrepareHeader)(path, {
+            exportName: "exports",
+            loose,
+            strict,
+            strictMode,
+            allowTopLevelThis,
+            noInterop,
+            lazy,
+            esNamespaceOnly: typeof state.filename === "string" && /\.mjs$/.test(state.filename) ? mjsStrictNamespace : strictNamespace
+          }),
+                meta = _rewriteModuleStateme.meta,
+                headers = _rewriteModuleStateme.headers;
+
+          for (var _iterator = meta.source, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+            var _ref;
+
+            if (_isArray) {
+              if (_i >= _iterator.length) break;
+              _ref = _iterator[_i++];
+            } else {
+              _i = _iterator.next();
+              if (_i.done) break;
+              _ref = _i.value;
+            }
+
+            const _ref2 = _ref,
+                  source = _ref2[0],
+                  metadata = _ref2[1];
+
+            const loadExpr = _core().types.callExpression(_core().types.identifier("require"), [_core().types.stringLiteral(source)]);
+
+            let header;
+
+            if ((0, _helperModuleTransforms().isSideEffectImport)(metadata)) {
+              if (metadata.lazy) throw new Error("Assertion failure");
+              header = _core().types.expressionStatement(loadExpr);
+            } else {
+              const init = (0, _helperModuleTransforms().wrapInterop)(path, loadExpr, metadata.interop) || loadExpr;
+
+              if (metadata.lazy) {
+                header = _core().template.ast`
+                  function ${metadata.name}() {
+                    const data = ${init};
+                    ${metadata.name} = function(){ return data; };
+                    return data;
+                  }
+                `;
+              } else {
+                header = _core().template.ast`
+                  var ${metadata.name} = ${init};
+                `;
+              }
+            }
+
+            header.loc = metadata.loc;
+            headers.push(header);
+            headers.push(...(0, _helperModuleTransforms().buildNamespaceInitStatements)(meta, metadata, loose));
+          }
+
+          (0, _helperModuleTransforms().ensureStatementsHoisted)(headers);
+          path.unshiftContainer("body", headers);
+        }
+
+      }
+    }
+  };
+});
+
+exports.default = _default;
\ No newline at end of file
diff --git a/node_modules/@babel/plugin-transform-modules-commonjs/package.json b/node_modules/@babel/plugin-transform-modules-commonjs/package.json
new file mode 100644
index 00000000..c5ee6622
--- /dev/null
+++ b/node_modules/@babel/plugin-transform-modules-commonjs/package.json
@@ -0,0 +1,24 @@
+{
+  "name": "@babel/plugin-transform-modules-commonjs",
+  "version": "7.0.0-beta.47",
+  "description": "This plugin transforms ES2015 modules to CommonJS",
+  "repository": "https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-modules-commonjs",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "dependencies": {
+    "@babel/helper-module-transforms": "7.0.0-beta.47",
+    "@babel/helper-plugin-utils": "7.0.0-beta.47",
+    "@babel/helper-simple-access": "7.0.0-beta.47"
+  },
+  "keywords": [
+    "babel-plugin"
+  ],
+  "peerDependencies": {
+    "@babel/core": "7.0.0-beta.47"
+  },
+  "devDependencies": {
+    "@babel/core": "7.0.0-beta.47",
+    "@babel/helper-plugin-test-runner": "7.0.0-beta.47",
+    "@babel/plugin-syntax-object-rest-spread": "7.0.0-beta.47"
+  }
+}