Add node modules and new code for release (#39)

Co-authored-by: tbarnes94 <tbarnes94@users.noreply.github.com>

node_modules/@babel/helper-module-imports/lib/import-builder.js

@@ -0,0 +1,139 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _assert = _interopRequireDefault(require("assert"));
+
+var t = _interopRequireWildcard(require("@babel/types"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class ImportBuilder {
+  constructor(importedSource, scope, hub) {
+    this._statements = [];
+    this._resultName = null;
+    this._scope = null;
+    this._hub = null;
+    this._scope = scope;
+    this._hub = hub;
+    this._importedSource = importedSource;
+  }
+
+  done() {
+    return {
+      statements: this._statements,
+      resultName: this._resultName
+    };
+  }
+
+  import() {
+    this._statements.push(t.importDeclaration([], t.stringLiteral(this._importedSource)));
+
+    return this;
+  }
+
+  require() {
+    this._statements.push(t.expressionStatement(t.callExpression(t.identifier("require"), [t.stringLiteral(this._importedSource)])));
+
+    return this;
+  }
+
+  namespace(name = "namespace") {
+    name = this._scope.generateUidIdentifier(name);
+    const statement = this._statements[this._statements.length - 1];
+    (0, _assert.default)(statement.type === "ImportDeclaration");
+    (0, _assert.default)(statement.specifiers.length === 0);
+    statement.specifiers = [t.importNamespaceSpecifier(name)];
+    this._resultName = t.cloneNode(name);
+    return this;
+  }
+
+  default(name) {
+    name = this._scope.generateUidIdentifier(name);
+    const statement = this._statements[this._statements.length - 1];
+    (0, _assert.default)(statement.type === "ImportDeclaration");
+    (0, _assert.default)(statement.specifiers.length === 0);
+    statement.specifiers = [t.importDefaultSpecifier(name)];
+    this._resultName = t.cloneNode(name);
+    return this;
+  }
+
+  named(name, importName) {
+    if (importName === "default") return this.default(name);
+    name = this._scope.generateUidIdentifier(name);
+    const statement = this._statements[this._statements.length - 1];
+    (0, _assert.default)(statement.type === "ImportDeclaration");
+    (0, _assert.default)(statement.specifiers.length === 0);
+    statement.specifiers = [t.importSpecifier(name, t.identifier(importName))];
+    this._resultName = t.cloneNode(name);
+    return this;
+  }
+
+  var(name) {
+    name = this._scope.generateUidIdentifier(name);
+    let statement = this._statements[this._statements.length - 1];
+
+    if (statement.type !== "ExpressionStatement") {
+      (0, _assert.default)(this._resultName);
+      statement = t.expressionStatement(this._resultName);
+
+      this._statements.push(statement);
+    }
+
+    this._statements[this._statements.length - 1] = t.variableDeclaration("var", [t.variableDeclarator(name, statement.expression)]);
+    this._resultName = t.cloneNode(name);
+    return this;
+  }
+
+  defaultInterop() {
+    return this._interop(this._hub.addHelper("interopRequireDefault"));
+  }
+
+  wildcardInterop() {
+    return this._interop(this._hub.addHelper("interopRequireWildcard"));
+  }
+
+  _interop(callee) {
+    const statement = this._statements[this._statements.length - 1];
+
+    if (statement.type === "ExpressionStatement") {
+      statement.expression = t.callExpression(callee, [statement.expression]);
+    } else if (statement.type === "VariableDeclaration") {
+      (0, _assert.default)(statement.declarations.length === 1);
+      statement.declarations[0].init = t.callExpression(callee, [statement.declarations[0].init]);
+    } else {
+      _assert.default.fail("Unexpected type.");
+    }
+
+    return this;
+  }
+
+  prop(name) {
+    const statement = this._statements[this._statements.length - 1];
+
+    if (statement.type === "ExpressionStatement") {
+      statement.expression = t.memberExpression(statement.expression, t.identifier(name));
+    } else if (statement.type === "VariableDeclaration") {
+      (0, _assert.default)(statement.declarations.length === 1);
+      statement.declarations[0].init = t.memberExpression(statement.declarations[0].init, t.identifier(name));
+    } else {
+      _assert.default.fail("Unexpected type:" + statement.type);
+    }
+
+    return this;
+  }
+
+  read(name) {
+    this._resultName = t.memberExpression(this._resultName, t.identifier(name));
+  }
+
+}
+
+exports.default = ImportBuilder;

node_modules/@babel/helper-module-imports/lib/import-injector.js

@@ -0,0 +1,271 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _assert = _interopRequireDefault(require("assert"));
+
+var t = _interopRequireWildcard(require("@babel/types"));
+
+var _importBuilder = _interopRequireDefault(require("./import-builder"));
+
+var _isModule = _interopRequireDefault(require("./is-module"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class ImportInjector {
+  constructor(path, importedSource, opts) {
+    this._defaultOpts = {
+      importedSource: null,
+      importedType: "commonjs",
+      importedInterop: "babel",
+      importingInterop: "babel",
+      ensureLiveReference: false,
+      ensureNoContext: false
+    };
+    const programPath = path.find(p => p.isProgram());
+    this._programPath = programPath;
+    this._programScope = programPath.scope;
+    this._hub = programPath.hub;
+    this._defaultOpts = this._applyDefaults(importedSource, opts, true);
+  }
+
+  addDefault(importedSourceIn, opts) {
+    return this.addNamed("default", importedSourceIn, opts);
+  }
+
+  addNamed(importName, importedSourceIn, opts) {
+    (0, _assert.default)(typeof importName === "string");
+    return this._generateImport(this._applyDefaults(importedSourceIn, opts), importName);
+  }
+
+  addNamespace(importedSourceIn, opts) {
+    return this._generateImport(this._applyDefaults(importedSourceIn, opts), null);
+  }
+
+  addSideEffect(importedSourceIn, opts) {
+    return this._generateImport(this._applyDefaults(importedSourceIn, opts), false);
+  }
+
+  _applyDefaults(importedSource, opts, isInit = false) {
+    const optsList = [];
+
+    if (typeof importedSource === "string") {
+      optsList.push({
+        importedSource
+      });
+      optsList.push(opts);
+    } else {
+      (0, _assert.default)(!opts, "Unexpected secondary arguments.");
+      optsList.push(importedSource);
+    }
+
+    const newOpts = Object.assign({}, this._defaultOpts);
+
+    for (const opts of optsList) {
+      if (!opts) continue;
+      Object.keys(newOpts).forEach(key => {
+        if (opts[key] !== undefined) newOpts[key] = opts[key];
+      });
+
+      if (!isInit) {
+        if (opts.nameHint !== undefined) newOpts.nameHint = opts.nameHint;
+        if (opts.blockHoist !== undefined) newOpts.blockHoist = opts.blockHoist;
+      }
+    }
+
+    return newOpts;
+  }
+
+  _generateImport(opts, importName) {
+    const isDefault = importName === "default";
+    const isNamed = !!importName && !isDefault;
+    const isNamespace = importName === null;
+    const {
+      importedSource,
+      importedType,
+      importedInterop,
+      importingInterop,
+      ensureLiveReference,
+      ensureNoContext,
+      nameHint,
+      blockHoist
+    } = opts;
+    let name = nameHint || importName;
+    const isMod = (0, _isModule.default)(this._programPath);
+    const isModuleForNode = isMod && importingInterop === "node";
+    const isModuleForBabel = isMod && importingInterop === "babel";
+    const builder = new _importBuilder.default(importedSource, this._programScope, this._hub);
+
+    if (importedType === "es6") {
+      if (!isModuleForNode && !isModuleForBabel) {
+        throw new Error("Cannot import an ES6 module from CommonJS");
+      }
+
+      builder.import();
+
+      if (isNamespace) {
+        builder.namespace(nameHint || importedSource);
+      } else if (isDefault || isNamed) {
+        builder.named(name, importName);
+      }
+    } else if (importedType !== "commonjs") {
+      throw new Error(`Unexpected interopType "${importedType}"`);
+    } else if (importedInterop === "babel") {
+      if (isModuleForNode) {
+        name = name !== "default" ? name : importedSource;
+        const es6Default = `${importedSource}$es6Default`;
+        builder.import();
+
+        if (isNamespace) {
+          builder.default(es6Default).var(name || importedSource).wildcardInterop();
+        } else if (isDefault) {
+          if (ensureLiveReference) {
+            builder.default(es6Default).var(name || importedSource).defaultInterop().read("default");
+          } else {
+            builder.default(es6Default).var(name).defaultInterop().prop(importName);
+          }
+        } else if (isNamed) {
+          builder.default(es6Default).read(importName);
+        }
+      } else if (isModuleForBabel) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.namespace(name || importedSource);
+        } else if (isDefault || isNamed) {
+          builder.named(name, importName);
+        }
+      } else {
+        builder.require();
+
+        if (isNamespace) {
+          builder.var(name || importedSource).wildcardInterop();
+        } else if ((isDefault || isNamed) && ensureLiveReference) {
+          if (isDefault) {
+            name = name !== "default" ? name : importedSource;
+            builder.var(name).read(importName);
+            builder.defaultInterop();
+          } else {
+            builder.var(importedSource).read(importName);
+          }
+        } else if (isDefault) {
+          builder.var(name).defaultInterop().prop(importName);
+        } else if (isNamed) {
+          builder.var(name).prop(importName);
+        }
+      }
+    } else if (importedInterop === "compiled") {
+      if (isModuleForNode) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.default(name || importedSource);
+        } else if (isDefault || isNamed) {
+          builder.default(importedSource).read(name);
+        }
+      } else if (isModuleForBabel) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.namespace(name || importedSource);
+        } else if (isDefault || isNamed) {
+          builder.named(name, importName);
+        }
+      } else {
+        builder.require();
+
+        if (isNamespace) {
+          builder.var(name || importedSource);
+        } else if (isDefault || isNamed) {
+          if (ensureLiveReference) {
+            builder.var(importedSource).read(name);
+          } else {
+            builder.prop(importName).var(name);
+          }
+        }
+      }
+    } else if (importedInterop === "uncompiled") {
+      if (isDefault && ensureLiveReference) {
+        throw new Error("No live reference for commonjs default");
+      }
+
+      if (isModuleForNode) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.default(name || importedSource);
+        } else if (isDefault) {
+          builder.default(name);
+        } else if (isNamed) {
+          builder.default(importedSource).read(name);
+        }
+      } else if (isModuleForBabel) {
+        builder.import();
+
+        if (isNamespace) {
+          builder.default(name || importedSource);
+        } else if (isDefault) {
+          builder.default(name);
+        } else if (isNamed) {
+          builder.named(name, importName);
+        }
+      } else {
+        builder.require();
+
+        if (isNamespace) {
+          builder.var(name || importedSource);
+        } else if (isDefault) {
+          builder.var(name);
+        } else if (isNamed) {
+          if (ensureLiveReference) {
+            builder.var(importedSource).read(name);
+          } else {
+            builder.var(name).prop(importName);
+          }
+        }
+      }
+    } else {
+      throw new Error(`Unknown importedInterop "${importedInterop}".`);
+    }
+
+    const {
+      statements,
+      resultName
+    } = builder.done();
+
+    this._insertStatements(statements, blockHoist);
+
+    if ((isDefault || isNamed) && ensureNoContext && resultName.type !== "Identifier") {
+      return t.sequenceExpression([t.numericLiteral(0), resultName]);
+    }
+
+    return resultName;
+  }
+
+  _insertStatements(statements, blockHoist = 3) {
+    statements.forEach(node => {
+      node._blockHoist = blockHoist;
+    });
+
+    const targetPath = this._programPath.get("body").find(p => {
+      const val = p.node._blockHoist;
+      return Number.isFinite(val) && val < 4;
+    });
+
+    if (targetPath) {
+      targetPath.insertBefore(statements);
+    } else {
+      this._programPath.unshiftContainer("body", statements);
+    }
+  }
+
+}
+
+exports.default = ImportInjector;

node_modules/@babel/helper-module-imports/lib/index.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addDefault = addDefault;
+exports.addNamed = addNamed;
+exports.addNamespace = addNamespace;
+exports.addSideEffect = addSideEffect;
+Object.defineProperty(exports, "ImportInjector", {
+  enumerable: true,
+  get: function () {
+    return _importInjector.default;
+  }
+});
+Object.defineProperty(exports, "isModule", {
+  enumerable: true,
+  get: function () {
+    return _isModule.default;
+  }
+});
+
+var _importInjector = _interopRequireDefault(require("./import-injector"));
+
+var _isModule = _interopRequireDefault(require("./is-module"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function addDefault(path, importedSource, opts) {
+  return new _importInjector.default(path).addDefault(importedSource, opts);
+}
+
+function addNamed(path, name, importedSource, opts) {
+  return new _importInjector.default(path).addNamed(name, importedSource, opts);
+}
+
+function addNamespace(path, importedSource, opts) {
+  return new _importInjector.default(path).addNamespace(importedSource, opts);
+}
+
+function addSideEffect(path, importedSource, opts) {
+  return new _importInjector.default(path).addSideEffect(importedSource, opts);
+}

node_modules/@babel/helper-module-imports/lib/is-module.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = isModule;
+
+function isModule(path) {
+  const {
+    sourceType
+  } = path.node;
+
+  if (sourceType !== "module" && sourceType !== "script") {
+    throw path.buildCodeFrameError(`Unknown sourceType "${sourceType}", cannot transform.`);
+  }
+
+  return path.node.sourceType === "module";
+}