first commit

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

+"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);
+}
\ No newline at end of file

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

+"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";
+}
\ No newline at end of file

node_modules/@babel/helper-module-imports/package.json

+{
+  "_from": "@babel/helper-module-imports@^7.0.0",
+  "_id": "@babel/helper-module-imports@7.7.0",
+  "_inBundle": false,
+  "_integrity": "sha512-Dv3hLKIC1jyfTkClvyEkYP2OlkzNvWs5+Q8WgPbxM5LMeorons7iPP91JM+DU7tRbhqA1ZeooPaMFvQrn23RHw==",
+  "_location": "/@babel/helper-module-imports",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@babel/helper-module-imports@^7.0.0",
+    "name": "@babel/helper-module-imports",
+    "escapedName": "@babel%2fhelper-module-imports",
+    "scope": "@babel",
+    "rawSpec": "^7.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^7.0.0"
+  },
+  "_requiredBy": [
+    "/@babel/helper-module-transforms",
+    "/@babel/plugin-transform-async-to-generator",
+    "/@babel/plugin-transform-runtime",
+    "/@babel/preset-env",
+    "/@vue/babel-plugin-transform-vue-jsx",
+    "/@vue/babel-preset-app"
+  ],
+  "_resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.7.0.tgz",
+  "_shasum": "99c095889466e5f7b6d66d98dffc58baaf42654d",
+  "_spec": "@babel/helper-module-imports@^7.0.0",
+  "_where": "C:\\Work\\OneDrive - bwstaff\\M4_Lab\\TV3\\NewVersion01\\LAFJLBmf939XYm5gj\\dev\\node_modules\\@vue\\babel-preset-app",
+  "author": {
+    "name": "Logan Smyth",
+    "email": "loganfsmyth@gmail.com"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "@babel/types": "^7.7.0"
+  },
+  "deprecated": false,
+  "description": "Babel helper functions for inserting module loads",
+  "devDependencies": {
+    "@babel/core": "^7.7.0"
+  },
+  "gitHead": "97faa83953cb87e332554fa559a4956d202343ea",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "name": "@babel/helper-module-imports",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel/tree/master/packages/babel-helper-module-imports"
+  },
+  "version": "7.7.0"
+}

node_modules/@babel/helper-module-transforms/LICENSE

+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@babel/helper-module-transforms/README.md

+# @babel/helper-module-transforms
+
+> Babel helper functions for implementing ES6 module transformations
+
+See our website [@babel/helper-module-transforms](https://babeljs.io/docs/en/next/babel-helper-module-transforms.html) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/helper-module-transforms
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-module-transforms --dev
+```

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

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.rewriteModuleStatementsAndPrepareHeader = rewriteModuleStatementsAndPrepareHeader;
+exports.ensureStatementsHoisted = ensureStatementsHoisted;
+exports.wrapInterop = wrapInterop;
+exports.buildNamespaceInitStatements = buildNamespaceInitStatements;
+Object.defineProperty(exports, "isModule", {
+  enumerable: true,
+  get: function () {
+    return _helperModuleImports.isModule;
+  }
+});
+Object.defineProperty(exports, "hasExports", {
+  enumerable: true,
+  get: function () {
+    return _normalizeAndLoadMetadata.hasExports;
+  }
+});
+Object.defineProperty(exports, "isSideEffectImport", {
+  enumerable: true,
+  get: function () {
+    return _normalizeAndLoadMetadata.isSideEffectImport;
+  }
+});
+
+var _assert = _interopRequireDefault(require("assert"));
+
+var t = _interopRequireWildcard(require("@babel/types"));
+
+var _template = _interopRequireDefault(require("@babel/template"));
+
+var _chunk = _interopRequireDefault(require("lodash/chunk"));
+
+var _helperModuleImports = require("@babel/helper-module-imports");
+
+var _rewriteThis = _interopRequireDefault(require("./rewrite-this"));
+
+var _rewriteLiveReferences = _interopRequireDefault(require("./rewrite-live-references"));
+
+var _normalizeAndLoadMetadata = _interopRequireWildcard(require("./normalize-and-load-metadata"));
+
+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; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { 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 }; }
+
+function rewriteModuleStatementsAndPrepareHeader(path, {
+  exportName,
+  strict,
+  allowTopLevelThis,
+  strictMode,
+  loose,
+  noInterop,
+  lazy,
+  esNamespaceOnly
+}) {
+  (0, _assert.default)((0, _helperModuleImports.isModule)(path), "Cannot process module statements in a script");
+  path.node.sourceType = "script";
+  const meta = (0, _normalizeAndLoadMetadata.default)(path, exportName, {
+    noInterop,
+    loose,
+    lazy,
+    esNamespaceOnly
+  });
+
+  if (!allowTopLevelThis) {
+    (0, _rewriteThis.default)(path);
+  }
+
+  (0, _rewriteLiveReferences.default)(path, meta);
+
+  if (strictMode !== false) {
+    const hasStrict = path.node.directives.some(directive => {
+      return directive.value.value === "use strict";
+    });
+
+    if (!hasStrict) {
+      path.unshiftContainer("directives", t.directive(t.directiveLiteral("use strict")));
+    }
+  }
+
+  const headers = [];
+
+  if ((0, _normalizeAndLoadMetadata.hasExports)(meta) && !strict) {
+    headers.push(buildESModuleHeader(meta, loose));
+  }
+
+  const nameList = buildExportNameListDeclaration(path, meta);
+
+  if (nameList) {
+    meta.exportNameListName = nameList.name;
+    headers.push(nameList.statement);
+  }
+
+  headers.push(...buildExportInitializationStatements(path, meta, loose));
+  return {
+    meta,
+    headers
+  };
+}
+
+function ensureStatementsHoisted(statements) {
+  statements.forEach(header => {
+    header._blockHoist = 3;
+  });
+}
+
+function wrapInterop(programPath, expr, type) {
+  if (type === "none") {
+    return null;
+  }
+
+  let helper;
+
+  if (type === "default") {
+    helper = "interopRequireDefault";
+  } else if (type === "namespace") {
+    helper = "interopRequireWildcard";
+  } else {
+    throw new Error(`Unknown interop: ${type}`);
+  }
+
+  return t.callExpression(programPath.hub.addHelper(helper), [expr]);
+}
+
+function buildNamespaceInitStatements(metadata, sourceMetadata, loose = false) {
+  const statements = [];
+  let srcNamespace = t.identifier(sourceMetadata.name);
+  if (sourceMetadata.lazy) srcNamespace = t.callExpression(srcNamespace, []);
+
+  for (const localName of sourceMetadata.importsNamespace) {
+    if (localName === sourceMetadata.name) continue;
+    statements.push(_template.default.statement`var NAME = SOURCE;`({
+      NAME: localName,
+      SOURCE: t.cloneNode(srcNamespace)
+    }));
+  }
+
+  if (loose) {
+    statements.push(...buildReexportsFromMeta(metadata, sourceMetadata, loose));
+  }
+
+  for (const exportName of sourceMetadata.reexportNamespace) {
+    statements.push((sourceMetadata.lazy ? _template.default.statement`
+            Object.defineProperty(EXPORTS, "NAME", {
+              enumerable: true,
+              get: function() {
+                return NAMESPACE;
+              }
+            });
+          ` : _template.default.statement`EXPORTS.NAME = NAMESPACE;`)({
+      EXPORTS: metadata.exportName,
+      NAME: exportName,
+      NAMESPACE: t.cloneNode(srcNamespace)
+    }));
+  }
+
+  if (sourceMetadata.reexportAll) {
+    const statement = buildNamespaceReexport(metadata, t.cloneNode(srcNamespace), loose);
+    statement.loc = sourceMetadata.reexportAll.loc;
+    statements.push(statement);
+  }
+
+  return statements;
+}
+
+const getTemplateForReexport = loose => {
+  return loose ? _template.default.statement`EXPORTS.EXPORT_NAME = NAMESPACE.IMPORT_NAME;` : _template.default`
+      Object.defineProperty(EXPORTS, "EXPORT_NAME", {
+        enumerable: true,
+        get: function() {
+          return NAMESPACE.IMPORT_NAME;
+        },
+      });
+    `;
+};
+
+const buildReexportsFromMeta = (meta, metadata, loose) => {
+  const namespace = metadata.lazy ? t.callExpression(t.identifier(metadata.name), []) : t.identifier(metadata.name);
+  const templateForCurrentMode = getTemplateForReexport(loose);
+  return Array.from(metadata.reexports, ([exportName, importName]) => templateForCurrentMode({
+    EXPORTS: meta.exportName,
+    EXPORT_NAME: exportName,
+    NAMESPACE: t.cloneNode(namespace),
+    IMPORT_NAME: importName
+  }));
+};
+
+function buildESModuleHeader(metadata, enumerable = false) {
+  return (enumerable ? _template.default.statement`
+        EXPORTS.__esModule = true;
+      ` : _template.default.statement`
+        Object.defineProperty(EXPORTS, "__esModule", {
+          value: true,
+        });
+      `)({
+    EXPORTS: metadata.exportName
+  });
+}
+
+function buildNamespaceReexport(metadata, namespace, loose) {
+  return (loose ? _template.default.statement`
+        Object.keys(NAMESPACE).forEach(function(key) {
+          if (key === "default" || key === "__esModule") return;
+          VERIFY_NAME_LIST;
+
+          EXPORTS[key] = NAMESPACE[key];
+        });
+      ` : _template.default.statement`
+        Object.keys(NAMESPACE).forEach(function(key) {
+          if (key === "default" || key === "__esModule") return;
+          VERIFY_NAME_LIST;
+
+          Object.defineProperty(EXPORTS, key, {
+            enumerable: true,
+            get: function() {
+              return NAMESPACE[key];
+            },
+          });
+        });
+    `)({
+    NAMESPACE: namespace,
+    EXPORTS: metadata.exportName,
+    VERIFY_NAME_LIST: metadata.exportNameListName ? _template.default`
+            if (Object.prototype.hasOwnProperty.call(EXPORTS_LIST, key)) return;
+          `({
+      EXPORTS_LIST: metadata.exportNameListName
+    }) : null
+  });
+}
+
+function buildExportNameListDeclaration(programPath, metadata) {
+  const exportedVars = Object.create(null);
+
+  for (const data of metadata.local.values()) {
+    for (const name of data.names) {
+      exportedVars[name] = true;
+    }
+  }
+
+  let hasReexport = false;
+
+  for (const data of metadata.source.values()) {
+    for (const exportName of data.reexports.keys()) {
+      exportedVars[exportName] = true;
+    }
+
+    for (const exportName of data.reexportNamespace) {
+      exportedVars[exportName] = true;
+    }
+
+    hasReexport = hasReexport || data.reexportAll;
+  }
+
+  if (!hasReexport || Object.keys(exportedVars).length === 0) return null;
+  const name = programPath.scope.generateUidIdentifier("exportNames");
+  delete exportedVars.default;
+  return {
+    name: name.name,
+    statement: t.variableDeclaration("var", [t.variableDeclarator(name, t.valueToNode(exportedVars))])
+  };
+}
+
+function buildExportInitializationStatements(programPath, metadata, loose = false) {
+  const initStatements = [];
+  const exportNames = [];
+
+  for (const [localName, data] of metadata.local) {
+    if (data.kind === "import") {} else if (data.kind === "hoisted") {
+      initStatements.push(buildInitStatement(metadata, data.names, t.identifier(localName)));
+    } else {
+      exportNames.push(...data.names);
+    }
+  }
+
+  for (const data of metadata.source.values()) {
+    if (!loose) {
+      initStatements.push(...buildReexportsFromMeta(metadata, data, loose));
+    }
+
+    for (const exportName of data.reexportNamespace) {
+      exportNames.push(exportName);
+    }
+  }
+
+  initStatements.push(...(0, _chunk.default)(exportNames, 100).map(members => {
+    return buildInitStatement(metadata, members, programPath.scope.buildUndefinedNode());
+  }));
+  return initStatements;
+}
+
+function buildInitStatement(metadata, exportNames, initExpr) {
+  return t.expressionStatement(exportNames.reduce((acc, exportName) => _template.default.expression`EXPORTS.NAME = VALUE`({
+    EXPORTS: metadata.exportName,
+    NAME: exportName,
+    VALUE: acc
+  }), initExpr));
+}
\ No newline at end of file

node_modules/@babel/helper-module-transforms/lib/normalize-and-load-metadata.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasExports = hasExports;
+exports.isSideEffectImport = isSideEffectImport;
+exports.default = normalizeModuleAndLoadMetadata;
+
+var _path = require("path");
+
+var _helperSplitExportDeclaration = _interopRequireDefault(require("@babel/helper-split-export-declaration"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function hasExports(metadata) {
+  return metadata.hasExports;
+}
+
+function isSideEffectImport(source) {
+  return source.imports.size === 0 && source.importsNamespace.size === 0 && source.reexports.size === 0 && source.reexportNamespace.size === 0 && !source.reexportAll;
+}
+
+function normalizeModuleAndLoadMetadata(programPath, exportName, {
+  noInterop = false,
+  loose = false,
+  lazy = false,
+  esNamespaceOnly = false
+} = {}) {
+  if (!exportName) {
+    exportName = programPath.scope.generateUidIdentifier("exports").name;
+  }
+
+  nameAnonymousExports(programPath);
+  const {
+    local,
+    source,
+    hasExports
+  } = getModuleMetadata(programPath, {
+    loose,
+    lazy
+  });
+  removeModuleDeclarations(programPath);
+
+  for (const [, metadata] of source) {
+    if (metadata.importsNamespace.size > 0) {
+      metadata.name = metadata.importsNamespace.values().next().value;
+    }
+
+    if (noInterop) metadata.interop = "none";else if (esNamespaceOnly) {
+      if (metadata.interop === "namespace") {
+        metadata.interop = "default";
+      }
+    }
+  }
+
+  return {
+    exportName,
+    exportNameListName: null,
+    hasExports,
+    local,
+    source
+  };
+}
+
+function getModuleMetadata(programPath, {
+  loose,
+  lazy
+}) {
+  const localData = getLocalExportMetadata(programPath, loose);
+  const sourceData = new Map();
+
+  const getData = sourceNode => {
+    const source = sourceNode.value;
+    let data = sourceData.get(source);
+
+    if (!data) {
+      data = {
+        name: programPath.scope.generateUidIdentifier((0, _path.basename)(source, (0, _path.extname)(source))).name,
+        interop: "none",
+        loc: null,
+        imports: new Map(),
+        importsNamespace: new Set(),
+        reexports: new Map(),
+        reexportNamespace: new Set(),
+        reexportAll: null,
+        lazy: false
+      };
+      sourceData.set(source, data);
+    }
+
+    return data;
+  };
+
+  let hasExports = false;
+  programPath.get("body").forEach(child => {
+    if (child.isImportDeclaration()) {
+      const data = getData(child.node.source);
+      if (!data.loc) data.loc = child.node.loc;
+      child.get("specifiers").forEach(spec => {
+        if (spec.isImportDefaultSpecifier()) {
+          const localName = spec.get("local").node.name;
+          data.imports.set(localName, "default");
+          const reexport = localData.get(localName);
+
+          if (reexport) {
+            localData.delete(localName);
+            reexport.names.forEach(name => {
+              data.reexports.set(name, "default");
+            });
+          }
+        } else if (spec.isImportNamespaceSpecifier()) {
+          const localName = spec.get("local").node.name;
+          data.importsNamespace.add(localName);
+          const reexport = localData.get(localName);
+
+          if (reexport) {
+            localData.delete(localName);
+            reexport.names.forEach(name => {
+              data.reexportNamespace.add(name);
+            });
+          }
+        } else if (spec.isImportSpecifier()) {
+          const importName = spec.get("imported").node.name;
+          const localName = spec.get("local").node.name;
+          data.imports.set(localName, importName);
+          const reexport = localData.get(localName);
+
+          if (reexport) {
+            localData.delete(localName);
+            reexport.names.forEach(name => {
+              data.reexports.set(name, importName);
+            });
+          }
+        }
+      });
+    } else if (child.isExportAllDeclaration()) {
+      hasExports = true;
+      const data = getData(child.node.source);
+      if (!data.loc) data.loc = child.node.loc;
+      data.reexportAll = {
+        loc: child.node.loc
+      };
+    } else if (child.isExportNamedDeclaration() && child.node.source) {
+      hasExports = true;
+      const data = getData(child.node.source);
+      if (!data.loc) data.loc = child.node.loc;
+      child.get("specifiers").forEach(spec => {
+        if (!spec.isExportSpecifier()) {
+          throw spec.buildCodeFrameError("Unexpected export specifier type");
+        }
+
+        const importName = spec.get("local").node.name;
+        const exportName = spec.get("exported").node.name;
+        data.reexports.set(exportName, importName);
+
+        if (exportName === "__esModule") {
+          throw exportName.buildCodeFrameError('Illegal export "__esModule".');
+        }
+      });
+    } else if (child.isExportNamedDeclaration() || child.isExportDefaultDeclaration()) {
+      hasExports = true;
+    }
+  });
+
+  for (const metadata of sourceData.values()) {
+    let needsDefault = false;
+    let needsNamed = false;
+
+    if (metadata.importsNamespace.size > 0) {
+      needsDefault = true;
+      needsNamed = true;
+    }
+
+    if (metadata.reexportAll) {
+      needsNamed = true;
+    }
+
+    for (const importName of metadata.imports.values()) {
+      if (importName === "default") needsDefault = true;else needsNamed = true;
+    }
+
+    for (const importName of metadata.reexports.values()) {
+      if (importName === "default") needsDefault = true;else needsNamed = true;
+    }
+
+    if (needsDefault && needsNamed) {
+      metadata.interop = "namespace";
+    } else if (needsDefault) {
+      metadata.interop = "default";
+    }
+  }
+
+  for (const [source, metadata] of sourceData) {
+    if (lazy !== false && !(isSideEffectImport(metadata) || metadata.reexportAll)) {
+      if (lazy === true) {
+        metadata.lazy = !/\./.test(source);
+      } else if (Array.isArray(lazy)) {
+        metadata.lazy = lazy.indexOf(source) !== -1;
+      } else if (typeof lazy === "function") {
+        metadata.lazy = lazy(source);
+      } else {
+        throw new Error(`.lazy must be a boolean, string array, or function`);
+      }
+    }
+  }
+
+  return {
+    hasExports,
+    local: localData,
+    source: sourceData
+  };
+}
+
+function getLocalExportMetadata(programPath, loose) {
+  const bindingKindLookup = new Map();
+  programPath.get("body").forEach(child => {
+    let kind;
+
+    if (child.isImportDeclaration()) {
+      kind = "import";
+    } else {
+      if (child.isExportDefaultDeclaration()) child = child.get("declaration");
+
+      if (child.isExportNamedDeclaration()) {
+        if (child.node.declaration) {
+          child = child.get("declaration");
+        } else if (loose && child.node.source && child.get("source").isStringLiteral()) {
+          child.node.specifiers.forEach(specifier => {
+            bindingKindLookup.set(specifier.local.name, "block");
+          });
+          return;
+        }
+      }
+
+      if (child.isFunctionDeclaration()) {
+        kind = "hoisted";
+      } else if (child.isClassDeclaration()) {
+        kind = "block";
+      } else if (child.isVariableDeclaration({
+        kind: "var"
+      })) {
+        kind = "var";
+      } else if (child.isVariableDeclaration()) {
+        kind = "block";
+      } else {
+        return;
+      }
+    }
+
+    Object.keys(child.getOuterBindingIdentifiers()).forEach(name => {
+      bindingKindLookup.set(name, kind);
+    });
+  });
+  const localMetadata = new Map();
+
+  const getLocalMetadata = idPath => {
+    const localName = idPath.node.name;
+    let metadata = localMetadata.get(localName);
+
+    if (!metadata) {
+      const kind = bindingKindLookup.get(localName);
+
+      if (kind === undefined) {
+        throw idPath.buildCodeFrameError(`Exporting local "${localName}", which is not declared.`);
+      }
+
+      metadata = {
+        names: [],
+        kind
+      };
+      localMetadata.set(localName, metadata);
+    }
+
+    return metadata;
+  };
+
+  programPath.get("body").forEach(child => {
+    if (child.isExportNamedDeclaration() && (loose || !child.node.source)) {
+      if (child.node.declaration) {
+        const declaration = child.get("declaration");
+        const ids = declaration.getOuterBindingIdentifierPaths();
+        Object.keys(ids).forEach(name => {
+          if (name === "__esModule") {
+            throw declaration.buildCodeFrameError('Illegal export "__esModule".');
+          }
+
+          getLocalMetadata(ids[name]).names.push(name);
+        });
+      } else {
+        child.get("specifiers").forEach(spec => {
+          const local = spec.get("local");
+          const exported = spec.get("exported");
+
+          if (exported.node.name === "__esModule") {
+            throw exported.buildCodeFrameError('Illegal export "__esModule".');
+          }
+
+          getLocalMetadata(local).names.push(exported.node.name);
+        });
+      }
+    } else if (child.isExportDefaultDeclaration()) {
+      const declaration = child.get("declaration");
+
+      if (declaration.isFunctionDeclaration() || declaration.isClassDeclaration()) {
+        getLocalMetadata(declaration.get("id")).names.push("default");
+      } else {
+        throw declaration.buildCodeFrameError("Unexpected default expression export.");
+      }
+    }
+  });
+  return localMetadata;
+}
+
+function nameAnonymousExports(programPath) {
+  programPath.get("body").forEach(child => {
+    if (!child.isExportDefaultDeclaration()) return;
+    (0, _helperSplitExportDeclaration.default)(child);
+  });
+}
+
+function removeModuleDeclarations(programPath) {
+  programPath.get("body").forEach(child => {
+    if (child.isImportDeclaration()) {
+      child.remove();
+    } else if (child.isExportNamedDeclaration()) {
+      if (child.node.declaration) {
+        child.node.declaration._blockHoist = child.node._blockHoist;
+        child.replaceWith(child.node.declaration);
+      } else {
+        child.remove();
+      }
+    } else if (child.isExportDefaultDeclaration()) {
+      const declaration = child.get("declaration");
+
+      if (declaration.isFunctionDeclaration() || declaration.isClassDeclaration()) {
+        declaration._blockHoist = child.node._blockHoist;
+        child.replaceWith(declaration);
+      } else {
+        throw declaration.buildCodeFrameError("Unexpected default expression export.");
+      }
+    } else if (child.isExportAllDeclaration()) {
+      child.remove();
+    }
+  });
+}
\ No newline at end of file

node_modules/@babel/helper-module-transforms/lib/rewrite-live-references.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = rewriteLiveReferences;
+
+var _assert = _interopRequireDefault(require("assert"));
+
+var t = _interopRequireWildcard(require("@babel/types"));
+
+var _template = _interopRequireDefault(require("@babel/template"));
+
+var _helperSimpleAccess = _interopRequireDefault(require("@babel/helper-simple-access"));
+
+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; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { 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 }; }
+
+function rewriteLiveReferences(programPath, metadata) {
+  const imported = new Map();
+  const exported = new Map();
+
+  const requeueInParent = path => {
+    programPath.requeue(path);
+  };
+
+  for (const [source, data] of metadata.source) {
+    for (const [localName, importName] of data.imports) {
+      imported.set(localName, [source, importName, null]);
+    }
+
+    for (const localName of data.importsNamespace) {
+      imported.set(localName, [source, null, localName]);
+    }
+  }
+
+  for (const [local, data] of metadata.local) {
+    let exportMeta = exported.get(local);
+
+    if (!exportMeta) {
+      exportMeta = [];
+      exported.set(local, exportMeta);
+    }
+
+    exportMeta.push(...data.names);
+  }
+
+  programPath.traverse(rewriteBindingInitVisitor, {
+    metadata,
+    requeueInParent,
+    scope: programPath.scope,
+    exported
+  });
+  (0, _helperSimpleAccess.default)(programPath, new Set([...Array.from(imported.keys()), ...Array.from(exported.keys())]));
+  programPath.traverse(rewriteReferencesVisitor, {
+    seen: new WeakSet(),
+    metadata,
+    requeueInParent,
+    scope: programPath.scope,
+    imported,
+    exported,
+    buildImportReference: ([source, importName, localName], identNode) => {
+      const meta = metadata.source.get(source);
+
+      if (localName) {
+        if (meta.lazy) identNode = t.callExpression(identNode, []);
+        return identNode;
+      }
+
+      let namespace = t.identifier(meta.name);
+      if (meta.lazy) namespace = t.callExpression(namespace, []);
+      return t.memberExpression(namespace, t.identifier(importName));
+    }
+  });
+}
+
+const rewriteBindingInitVisitor = {
+  ClassProperty(path) {
+    path.skip();
+  },
+
+  Function(path) {
+    path.skip();
+  },
+
+  ClassDeclaration(path) {
+    const {
+      requeueInParent,
+      exported,
+      metadata
+    } = this;
+    const {
+      id
+    } = path.node;
+    if (!id) throw new Error("Expected class to have a name");
+    const localName = id.name;
+    const exportNames = exported.get(localName) || [];
+
+    if (exportNames.length > 0) {
+      const statement = t.expressionStatement(buildBindingExportAssignmentExpression(metadata, exportNames, t.identifier(localName)));
+      statement._blockHoist = path.node._blockHoist;
+      requeueInParent(path.insertAfter(statement)[0]);
+    }
+  },
+
+  VariableDeclaration(path) {
+    const {
+      requeueInParent,
+      exported,
+      metadata
+    } = this;
+    Object.keys(path.getOuterBindingIdentifiers()).forEach(localName => {
+      const exportNames = exported.get(localName) || [];
+
+      if (exportNames.length > 0) {
+        const statement = t.expressionStatement(buildBindingExportAssignmentExpression(metadata, exportNames, t.identifier(localName)));
+        statement._blockHoist = path.node._blockHoist;
+        requeueInParent(path.insertAfter(statement)[0]);
+      }
+    });
+  }
+
+};
+
+const buildBindingExportAssignmentExpression = (metadata, exportNames, localExpr) => {
+  return (exportNames || []).reduce((expr, exportName) => {
+    return t.assignmentExpression("=", t.memberExpression(t.identifier(metadata.exportName), t.identifier(exportName)), expr);
+  }, localExpr);
+};
+
+const buildImportThrow = localName => {
+  return _template.default.expression.ast`
+    (function() {
+      throw new Error('"' + '${localName}' + '" is read-only.');
+    })()
+  `;
+};
+
+const rewriteReferencesVisitor = {
+  ReferencedIdentifier(path) {
+    const {
+      seen,
+      buildImportReference,
+      scope,
+      imported,
+      requeueInParent
+    } = this;
+    if (seen.has(path.node)) return;
+    seen.add(path.node);
+    const localName = path.node.name;
+    const localBinding = path.scope.getBinding(localName);
+    const rootBinding = scope.getBinding(localName);
+    if (rootBinding !== localBinding) return;
+    const importData = imported.get(localName);
+
+    if (importData) {
+      const ref = buildImportReference(importData, path.node);
+      ref.loc = path.node.loc;
+
+      if (path.parentPath.isCallExpression({
+        callee: path.node
+      }) && t.isMemberExpression(ref)) {
+        path.replaceWith(t.sequenceExpression([t.numericLiteral(0), ref]));
+      } else if (path.isJSXIdentifier() && t.isMemberExpression(ref)) {
+        const {
+          object,
+          property
+        } = ref;
+        path.replaceWith(t.JSXMemberExpression(t.JSXIdentifier(object.name), t.JSXIdentifier(property.name)));
+      } else {
+        path.replaceWith(ref);
+      }
+
+      requeueInParent(path);
+      path.skip();
+    }
+  },
+
+  AssignmentExpression: {
+    exit(path) {
+      const {
+        scope,
+        seen,
+        imported,
+        exported,
+        requeueInParent,
+        buildImportReference
+      } = this;
+      if (seen.has(path.node)) return;
+      seen.add(path.node);
+      const left = path.get("left");
+      if (left.isMemberExpression()) return;
+
+      if (left.isIdentifier()) {
+        const localName = left.node.name;
+
+        if (scope.getBinding(localName) !== path.scope.getBinding(localName)) {
+          return;
+        }
+
+        const exportedNames = exported.get(localName);
+        const importData = imported.get(localName);
+
+        if ((exportedNames === null || exportedNames === void 0 ? void 0 : exportedNames.length) > 0 || importData) {
+          (0, _assert.default)(path.node.operator === "=", "Path was not simplified");
+          const assignment = path.node;
+
+          if (importData) {
+            assignment.left = buildImportReference(importData, assignment.left);
+            assignment.right = t.sequenceExpression([assignment.right, buildImportThrow(localName)]);
+          }
+
+          path.replaceWith(buildBindingExportAssignmentExpression(this.metadata, exportedNames, assignment));
+          requeueInParent(path);
+        }
+      } else {
+        const ids = left.getOuterBindingIdentifiers();
+        const programScopeIds = Object.keys(ids).filter(localName => scope.getBinding(localName) === path.scope.getBinding(localName));
+        const id = programScopeIds.find(localName => imported.has(localName));
+
+        if (id) {
+          path.node.right = t.sequenceExpression([path.node.right, buildImportThrow(id)]);
+        }
+
+        const items = [];
+        programScopeIds.forEach(localName => {
+          const exportedNames = exported.get(localName) || [];
+
+          if (exportedNames.length > 0) {
+            items.push(buildBindingExportAssignmentExpression(this.metadata, exportedNames, t.identifier(localName)));
+          }
+        });
+
+        if (items.length > 0) {
+          let node = t.sequenceExpression(items);
+
+          if (path.parentPath.isExpressionStatement()) {
+            node = t.expressionStatement(node);
+            node._blockHoist = path.parentPath.node._blockHoist;
+          }
+
+          const statement = path.insertAfter(node)[0];
+          requeueInParent(statement);
+        }
+      }
+    }
+
+  }
+};
\ No newline at end of file

node_modules/@babel/helper-module-transforms/lib/rewrite-this.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = rewriteThis;
+
+function rewriteThis(programPath) {
+  programPath.traverse(rewriteThisVisitor);
+}
+
+const rewriteThisVisitor = {
+  ThisExpression(path) {
+    path.replaceWith(path.scope.buildUndefinedNode());
+  },
+
+  Function(path) {
+    if (!path.isArrowFunctionExpression()) path.skip();
+  },
+
+  ClassProperty(path) {
+    path.skip();
+  },
+
+  ClassPrivateProperty(path) {
+    path.skip();
+  }
+
+};
\ No newline at end of file

node_modules/@babel/helper-module-transforms/package.json

+{
+  "_from": "@babel/helper-module-transforms@^7.1.0",
+  "_id": "@babel/helper-module-transforms@7.7.0",
+  "_inBundle": false,
+  "_integrity": "sha512-rXEefBuheUYQyX4WjV19tuknrJFwyKw0HgzRwbkyTbB+Dshlq7eqkWbyjzToLrMZk/5wKVKdWFluiAsVkHXvuQ==",
+  "_location": "/@babel/helper-module-transforms",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@babel/helper-module-transforms@^7.1.0",
+    "name": "@babel/helper-module-transforms",
+    "escapedName": "@babel%2fhelper-module-transforms",
+    "scope": "@babel",
+    "rawSpec": "^7.1.0",
+    "saveSpec": null,
+    "fetchSpec": "^7.1.0"
+  },
+  "_requiredBy": [
+    "/@babel/plugin-transform-modules-amd",
+    "/@babel/plugin-transform-modules-commonjs",
+    "/@babel/plugin-transform-modules-umd"
+  ],
+  "_resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.7.0.tgz",
+  "_shasum": "154a69f0c5b8fd4d39e49750ff7ac4faa3f36786",
+  "_spec": "@babel/helper-module-transforms@^7.1.0",
+  "_where": "C:\\Work\\OneDrive - bwstaff\\M4_Lab\\TV3\\NewVersion01\\LAFJLBmf939XYm5gj\\dev\\node_modules\\@babel\\plugin-transform-modules-amd",
+  "author": {
+    "name": "Logan Smyth",
+    "email": "loganfsmyth@gmail.com"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "@babel/helper-module-imports": "^7.7.0",
+    "@babel/helper-simple-access": "^7.7.0",
+    "@babel/helper-split-export-declaration": "^7.7.0",
+    "@babel/template": "^7.7.0",
+    "@babel/types": "^7.7.0",
+    "lodash": "^4.17.13"
+  },
+  "deprecated": false,
+  "description": "Babel helper functions for implementing ES6 module transformations",
+  "gitHead": "97faa83953cb87e332554fa559a4956d202343ea",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "name": "@babel/helper-module-transforms",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel/tree/master/packages/babel-helper-module-transforms"
+  },
+  "version": "7.7.0"
+}

node_modules/@babel/helper-optimise-call-expression/LICENSE

+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@babel/helper-optimise-call-expression/README.md

+# @babel/helper-optimise-call-expression
+
+> Helper function to optimise call expression
+
+See our website [@babel/helper-optimise-call-expression](https://babeljs.io/docs/en/next/babel-helper-optimise-call-expression.html) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/helper-optimise-call-expression
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-optimise-call-expression --dev
+```

node_modules/@babel/helper-optimise-call-expression/lib/index.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+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; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { 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 _default(callee, thisNode, args) {
+  if (args.length === 1 && t.isSpreadElement(args[0]) && t.isIdentifier(args[0].argument, {
+    name: "arguments"
+  })) {
+    return t.callExpression(t.memberExpression(callee, t.identifier("apply")), [thisNode, args[0].argument]);
+  } else {
+    return t.callExpression(t.memberExpression(callee, t.identifier("call")), [thisNode, ...args]);
+  }
+}
\ No newline at end of file

node_modules/@babel/helper-optimise-call-expression/package.json

+{
+  "_from": "@babel/helper-optimise-call-expression@^7.7.0",
+  "_id": "@babel/helper-optimise-call-expression@7.7.0",
+  "_inBundle": false,
+  "_integrity": "sha512-48TeqmbazjNU/65niiiJIJRc5JozB8acui1OS7bSd6PgxfuovWsvjfWSzlgx+gPFdVveNzUdpdIg5l56Pl5jqg==",
+  "_location": "/@babel/helper-optimise-call-expression",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@babel/helper-optimise-call-expression@^7.7.0",
+    "name": "@babel/helper-optimise-call-expression",
+    "escapedName": "@babel%2fhelper-optimise-call-expression",
+    "scope": "@babel",
+    "rawSpec": "^7.7.0",
+    "saveSpec": null,
+    "fetchSpec": "^7.7.0"
+  },
+  "_requiredBy": [
+    "/@babel/helper-create-class-features-plugin",
+    "/@babel/helper-replace-supers",
+    "/@babel/plugin-transform-classes"
+  ],
+  "_resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.7.0.tgz",
+  "_shasum": "4f66a216116a66164135dc618c5d8b7a959f9365",
+  "_spec": "@babel/helper-optimise-call-expression@^7.7.0",
+  "_where": "C:\\Work\\OneDrive - bwstaff\\M4_Lab\\TV3\\NewVersion01\\LAFJLBmf939XYm5gj\\dev\\node_modules\\@babel\\helper-create-class-features-plugin",
+  "bundleDependencies": false,
+  "dependencies": {
+    "@babel/types": "^7.7.0"
+  },
+  "deprecated": false,
+  "description": "Helper function to optimise call expression",
+  "gitHead": "97faa83953cb87e332554fa559a4956d202343ea",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "name": "@babel/helper-optimise-call-expression",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel/tree/master/packages/babel-helper-optimise-call-expression"
+  },
+  "version": "7.7.0"
+}

node_modules/@babel/helper-plugin-utils/LICENSE

+MIT License
+
+Copyright (c) 2014-2018 Sebastian McKenzie <sebmck@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@babel/helper-plugin-utils/README.md

+# @babel/helper-plugin-utils
+
+> General utilities for plugins to use
+
+See our website [@babel/helper-plugin-utils](https://babeljs.io/docs/en/next/babel-helper-plugin-utils.html) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/helper-plugin-utils
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-plugin-utils --dev
+```

node_modules/@babel/helper-plugin-utils/lib/index.js

+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.declare = declare;
+
+function declare(builder) {
+  return (api, options, dirname) => {
+    if (!api.assertVersion) {
+      api = Object.assign(copyApiObject(api), {
+        assertVersion(range) {
+          throwVersionError(range, api.version);
+        }
+
+      });
+    }
+
+    return builder(api, options || {}, dirname);
+  };
+}
+
+function copyApiObject(api) {
+  let proto = null;
+
+  if (typeof api.version === "string" && /^7\./.test(api.version)) {
+    proto = Object.getPrototypeOf(api);
+
+    if (proto && (!has(proto, "version") || !has(proto, "transform") || !has(proto, "template") || !has(proto, "types"))) {
+      proto = null;
+    }
+  }
+
+  return Object.assign({}, proto, api);
+}
+
+function has(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function throwVersionError(range, version) {
+  if (typeof range === "number") {
+    if (!Number.isInteger(range)) {
+      throw new Error("Expected string or integer value.");
+    }
+
+    range = `^${range}.0.0-0`;
+  }
+
+  if (typeof range !== "string") {
+    throw new Error("Expected string or integer value.");
+  }
+
+  const limit = Error.stackTraceLimit;
+
+  if (typeof limit === "number" && limit < 25) {
+    Error.stackTraceLimit = 25;
+  }
+
+  let err;
+
+  if (version.slice(0, 2) === "7.") {
+    err = new Error(`Requires Babel "^7.0.0-beta.41", but was loaded with "${version}". ` + `You'll need to update your @babel/core version.`);
+  } else {
+    err = new Error(`Requires Babel "${range}", but was loaded with "${version}". ` + `If you are sure you have a compatible version of @babel/core, ` + `it is likely that something in your build process is loading the ` + `wrong version. Inspect the stack trace of this error to look for ` + `the first entry that doesn't mention "@babel/core" or "babel-core" ` + `to see what is calling Babel.`);
+  }
+
+  if (typeof limit === "number") {
+    Error.stackTraceLimit = limit;
+  }
+
+  throw Object.assign(err, {
+    code: "BABEL_VERSION_UNSUPPORTED",
+    version,
+    range
+  });
+}
\ No newline at end of file

node_modules/@babel/helper-plugin-utils/package.json

+{
+  "_from": "@babel/helper-plugin-utils@^7.0.0",
+  "_id": "@babel/helper-plugin-utils@7.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-CYAOUCARwExnEixLdB6sDm2dIJ/YgEAKDM1MOeMeZu9Ld/bDgVo8aiWrXwcY7OBh+1Ea2uUcVRcxKk0GJvW7QA==",
+  "_location": "/@babel/helper-plugin-utils",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@babel/helper-plugin-utils@^7.0.0",
+    "name": "@babel/helper-plugin-utils",
+    "escapedName": "@babel%2fhelper-plugin-utils",
+    "scope": "@babel",
+    "rawSpec": "^7.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^7.0.0"
+  },
+  "_requiredBy": [
+    "/@babel/helper-create-class-features-plugin",
+    "/@babel/plugin-proposal-async-generator-functions",
+    "/@babel/plugin-proposal-class-properties",
+    "/@babel/plugin-proposal-decorators",
+    "/@babel/plugin-proposal-json-strings",
+    "/@babel/plugin-proposal-object-rest-spread",
+    "/@babel/plugin-proposal-optional-catch-binding",
+    "/@babel/plugin-proposal-unicode-property-regex",
+    "/@babel/plugin-syntax-async-generators",
+    "/@babel/plugin-syntax-decorators",
+    "/@babel/plugin-syntax-dynamic-import",
+    "/@babel/plugin-syntax-json-strings",
+    "/@babel/plugin-syntax-jsx",
+    "/@babel/plugin-syntax-object-rest-spread",
+    "/@babel/plugin-syntax-optional-catch-binding",
+    "/@babel/plugin-transform-arrow-functions",
+    "/@babel/plugin-transform-async-to-generator",
+    "/@babel/plugin-transform-block-scoped-functions",
+    "/@babel/plugin-transform-block-scoping",
+    "/@babel/plugin-transform-classes",
+    "/@babel/plugin-transform-computed-properties",
+    "/@babel/plugin-transform-destructuring",
+    "/@babel/plugin-transform-dotall-regex",
+    "/@babel/plugin-transform-duplicate-keys",
+    "/@babel/plugin-transform-exponentiation-operator",
+    "/@babel/plugin-transform-for-of",
+    "/@babel/plugin-transform-function-name",
+    "/@babel/plugin-transform-literals",
+    "/@babel/plugin-transform-modules-amd",
+    "/@babel/plugin-transform-modules-commonjs",
+    "/@babel/plugin-transform-modules-systemjs",
+    "/@babel/plugin-transform-modules-umd",
+    "/@babel/plugin-transform-new-target",
+    "/@babel/plugin-transform-object-super",
+    "/@babel/plugin-transform-parameters",
+    "/@babel/plugin-transform-runtime",
+    "/@babel/plugin-transform-shorthand-properties",
+    "/@babel/plugin-transform-spread",
+    "/@babel/plugin-transform-sticky-regex",
+    "/@babel/plugin-transform-template-literals",
+    "/@babel/plugin-transform-typeof-symbol",
+    "/@babel/plugin-transform-unicode-regex",
+    "/@babel/preset-env"
+  ],
+  "_resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.0.0.tgz",
+  "_shasum": "bbb3fbee98661c569034237cc03967ba99b4f250",
+  "_spec": "@babel/helper-plugin-utils@^7.0.0",
+  "_where": "C:\\Work\\OneDrive - bwstaff\\M4_Lab\\TV3\\NewVersion01\\LAFJLBmf939XYm5gj\\dev\\node_modules\\@babel\\plugin-proposal-class-properties",
+  "author": {
+    "name": "Logan Smyth",
+    "email": "loganfsmyth@gmail.com"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "General utilities for plugins to use",
+  "homepage": "https://babeljs.io/",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "name": "@babel/helper-plugin-utils",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel/tree/master/packages/babel-helper-plugin-utils"
+  },
+  "version": "7.0.0"
+}

node_modules/@babel/helper-plugin-utils/src/index.js

+export function declare(builder) {
+  return (api, options, dirname) => {
+    if (!api.assertVersion) {
+      // Inject a custom version of 'assertVersion' for Babel 6 and early
+      // versions of Babel 7's beta that didn't have it.
+      api = Object.assign(copyApiObject(api), {
+        assertVersion(range) {
+          throwVersionError(range, api.version);
+        },
+      });
+    }
+
+    return builder(api, options || {}, dirname);
+  };
+}
+
+function copyApiObject(api) {
+  // Babel >= 7 <= beta.41 passed the API as a new object that had
+  // babel/core as the prototype. While slightly faster, it also
+  // means that the Object.assign copy below fails. Rather than
+  // keep complexity, the Babel 6 behavior has been reverted and this
+  // normalizes all that for Babel 7.
+  let proto = null;
+  if (typeof api.version === "string" && /^7\./.test(api.version)) {
+    proto = Object.getPrototypeOf(api);
+    if (
+      proto &&
+      (!has(proto, "version") ||
+        !has(proto, "transform") ||
+        !has(proto, "template") ||
+        !has(proto, "types"))
+    ) {
+      proto = null;
+    }
+  }
+
+  return {
+    ...proto,
+    ...api,
+  };
+}
+
+function has(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function throwVersionError(range, version) {
+  if (typeof range === "number") {
+    if (!Number.isInteger(range)) {
+      throw new Error("Expected string or integer value.");
+    }
+    range = `^${range}.0.0-0`;
+  }
+  if (typeof range !== "string") {
+    throw new Error("Expected string or integer value.");
+  }
+
+  const limit = Error.stackTraceLimit;
+
+  if (typeof limit === "number" && limit < 25) {
+    // Bump up the limit if needed so that users are more likely
+    // to be able to see what is calling Babel.
+    Error.stackTraceLimit = 25;
+  }
+
+  let err;
+  if (version.slice(0, 2) === "7.") {
+    err = new Error(
+      `Requires Babel "^7.0.0-beta.41", but was loaded with "${version}". ` +
+        `You'll need to update your @babel/core version.`,
+    );
+  } else {
+    err = new Error(
+      `Requires Babel "${range}", but was loaded with "${version}". ` +
+        `If you are sure you have a compatible version of @babel/core, ` +
+        `it is likely that something in your build process is loading the ` +
+        `wrong version. Inspect the stack trace of this error to look for ` +
+        `the first entry that doesn't mention "@babel/core" or "babel-core" ` +
+        `to see what is calling Babel.`,
+    );
+  }
+
+  if (typeof limit === "number") {
+    Error.stackTraceLimit = limit;
+  }
+
+  throw Object.assign(
+    err,
+    ({
+      code: "BABEL_VERSION_UNSUPPORTED",
+      version,
+      range,
+    }: any),
+  );
+}

node_modules/@babel/helper-regex/LICENSE

+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.