modified

node_modules/parse-imports/dist/main/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/// <reference types="node"/>
+
+declare namespace parseImports {
+  export type ModuleSpecifierType =
+    | 'invalid'
+    | 'absolute'
+    | 'relative'
+    | 'builtin'
+    | 'package'
+    | 'unknown'
+
+  export type Import = {
+    isDynamicImport: boolean
+    moduleSpecifier: {
+      type: ModuleSpecifierType
+      isConstant: boolean
+      code: string
+      value?: string
+      resolved?: string
+    }
+    importClause?: {
+      default?: string
+      named: { specifier: string; binding: string }[]
+      namespace?: string
+    }
+  }
+
+  export type Options = { readonly resolveFrom?: string }
+}
+
+declare const parseImports: {
+  (code: string, options?: parseImports.Options): Promise<
+    IterableIterator<parseImports.Import>
+  >
+}
+
+export = parseImports

node_modules/parse-imports/dist/main/index.js

@@ -0,0 +1,74 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _esModuleLexer = require("es-module-lexer");
+
+var _parseModuleSpecifier = _interopRequireDefault(require("./parse-module-specifier"));
+
+var _parseImportClause = _interopRequireDefault(require("./parse-import-clause"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const parseImports = async (code, {
+  resolveFrom
+} = {}) => {
+  const [imports] = await (0, _esModuleLexer.parse)(code, resolveFrom != null ? resolveFrom : undefined);
+  return function* () {
+    for (let {
+      d: dynamicImportStartIndex,
+      ss: statementStartIndex,
+      s: moduleSpecifierStartIndex,
+      e: moduleSpecifierEndIndexExclusive
+    } of imports) {
+      const isDynamicImport = dynamicImportStartIndex > -1; // Include string literal quotes in character range
+
+      if (!isDynamicImport) {
+        moduleSpecifierStartIndex--;
+        moduleSpecifierEndIndexExclusive++;
+      }
+
+      const moduleSpecifierString = code.substring(moduleSpecifierStartIndex, moduleSpecifierEndIndexExclusive);
+      const moduleSpecifier = (0, _parseModuleSpecifier.default)(moduleSpecifierString, {
+        isDynamicImport,
+        resolveFrom
+      });
+      let importClause;
+
+      if (!isDynamicImport) {
+        let importClauseString = code.substring(statementStartIndex + `import`.length, moduleSpecifierStartIndex).trim();
+
+        if (importClauseString.endsWith(`from`)) {
+          importClauseString = importClauseString.substring(0, importClauseString.length - `from`.length);
+        }
+
+        importClause = (0, _parseImportClause.default)(importClauseString);
+      }
+
+      yield {
+        isDynamicImport,
+        moduleSpecifier,
+        importClause
+      };
+    }
+  }();
+};
+
+var _default = parseImports;
+exports.default = _default;

node_modules/parse-imports/dist/main/parse-import-clause/index.js

@@ -0,0 +1,72 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _skip = require("./skip");
+
+var _parseNamedImports = _interopRequireDefault(require("./parse-named-imports"));
+
+var _parseNamespaceImport = _interopRequireDefault(require("./parse-namespace-import"));
+
+var _parseDefaultImport = _interopRequireDefault(require("./parse-default-import"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Assumes import clause is syntactically valid
+const parseImportClause = importClauseString => {
+  let defaultImport;
+  let namespaceImport;
+  const namedImports = [];
+
+  for (let i = 0; i < importClauseString.length; i++) {
+    if (_skip.separatorRegex.test(importClauseString[i])) {
+      continue;
+    }
+
+    if (importClauseString[i] === `{`) {
+      let newNamedImports;
+      ({
+        namedImports: newNamedImports,
+        i
+      } = (0, _parseNamedImports.default)(importClauseString, i));
+      namedImports.push(...newNamedImports);
+    } else if (importClauseString[i] === `*`) {
+      ;
+      ({
+        namespaceImport,
+        i
+      } = (0, _parseNamespaceImport.default)(importClauseString, i));
+    } else {
+      ;
+      ({
+        defaultImport,
+        i
+      } = (0, _parseDefaultImport.default)(importClauseString, i));
+    }
+  }
+
+  return {
+    default: defaultImport,
+    namespace: namespaceImport,
+    named: namedImports
+  };
+};
+
+var _default = parseImportClause;
+exports.default = _default;

node_modules/parse-imports/dist/main/parse-import-clause/parse-default-import.js

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _skip = require("./skip");
+
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const parseDefaultImport = (importClauseString, i) => {
+  const startIndex = i;
+  i = (0, _skip.skipNonSeparators)(importClauseString, i);
+  return {
+    defaultImport: importClauseString.substring(startIndex, i),
+    i
+  };
+};
+
+var _default = parseDefaultImport;
+exports.default = _default;

node_modules/parse-imports/dist/main/parse-import-clause/parse-named-imports.js

@@ -0,0 +1,53 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const parseNamedImports = (importClauseString, i) => {
+  const startIndex = ++i;
+
+  while (i < importClauseString.length && importClauseString[i] !== `}`) {
+    i++;
+  }
+
+  const namedImports = importClauseString.substring(startIndex, i++).split(`,`).map(namedImport => {
+    namedImport = namedImport.trim();
+
+    if (namedImport.includes(` `)) {
+      const components = namedImport.split(` `);
+      return {
+        specifier: components[0],
+        binding: components[components.length - 1]
+      };
+    }
+
+    return {
+      specifier: namedImport,
+      binding: namedImport
+    };
+  }).filter(({
+    specifier
+  }) => specifier.length > 0);
+  return {
+    namedImports,
+    i
+  };
+};
+
+var _default = parseNamedImports;
+exports.default = _default;

node_modules/parse-imports/dist/main/parse-import-clause/parse-namespace-import.js

@@ -0,0 +1,37 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _skip = require("./skip");
+
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const parseNamespaceImport = (importClauseString, i) => {
+  i++;
+  i = (0, _skip.skipSeparators)(importClauseString, i);
+  i += `as`.length;
+  i = (0, _skip.skipSeparators)(importClauseString, i);
+  const startIndex = i;
+  i = (0, _skip.skipNonSeparators)(importClauseString, i);
+  return {
+    namespaceImport: importClauseString.substring(startIndex, i),
+    i
+  };
+};
+
+var _default = parseNamespaceImport;
+exports.default = _default;

node_modules/parse-imports/dist/main/parse-import-clause/skip.js

@@ -0,0 +1,42 @@
+"use strict";
+
+exports.__esModule = true;
+exports.skipNonSeparators = exports.skipSeparators = exports.separatorRegex = void 0;
+
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const separatorRegex = /^(?:\s+|,)$/u;
+exports.separatorRegex = separatorRegex;
+
+const skipSeparators = (imported, i) => {
+  while (i < imported.length && separatorRegex.test(imported[i])) {
+    i++;
+  }
+
+  return i;
+};
+
+exports.skipSeparators = skipSeparators;
+
+const skipNonSeparators = (imported, i) => {
+  while (i < imported.length && !separatorRegex.test(imported[i])) {
+    i++;
+  }
+
+  return i;
+};
+
+exports.skipNonSeparators = skipNonSeparators;

node_modules/parse-imports/dist/main/parse-module-specifier/index.js

@@ -0,0 +1,55 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _slashes = require("slashes");
+
+var _isConstantStringLiteral = _interopRequireDefault(require("./is-constant-string-literal"));
+
+var _parseType = _interopRequireDefault(require("./parse-type"));
+
+var _resolve = _interopRequireDefault(require("./resolve"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const parseModuleSpecifier = (moduleSpecifierString, {
+  isDynamicImport,
+  resolveFrom
+}) => {
+  const {
+    isConstant,
+    value
+  } = !isDynamicImport || (0, _isConstantStringLiteral.default)(moduleSpecifierString) ? {
+    isConstant: true,
+    value: (0, _slashes.stripSlashes)(moduleSpecifierString.substring(1, moduleSpecifierString.length - 1))
+  } : {
+    isConstant: false,
+    value: undefined
+  };
+  return {
+    type: isConstant ? (0, _parseType.default)(value) : `unknown`,
+    isConstant,
+    code: moduleSpecifierString,
+    value,
+    resolved: typeof resolveFrom === `string` && isConstant ? (0, _resolve.default)(resolveFrom, value) : undefined
+  };
+};
+
+var _default = parseModuleSpecifier;
+exports.default = _default;

node_modules/parse-imports/dist/main/parse-module-specifier/is-constant-string-literal.js

@@ -0,0 +1,45 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Assumes the string is syntactically valid
+const isConstantStringLiteral = stringLiteral => {
+  const quote = [`'`, `"`, `\``].find(quoteCandidate => stringLiteral.startsWith(quoteCandidate) && stringLiteral.endsWith(quoteCandidate));
+
+  if (quote == null) {
+    return false;
+  }
+
+  for (let i = 1; i < stringLiteral.length - 1; i++) {
+    // Check for end of string literal before end of stringLiteral
+    if (stringLiteral[i] === quote && stringLiteral[i - 1] !== `\\`) {
+      return false;
+    } // Check for interpolated value in template literal
+
+
+    if (quote === `\`` && stringLiteral.substring(i, i + 2) === `\${` && stringLiteral[i - 1] !== `\\`) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+var _default = isConstantStringLiteral;
+exports.default = _default;

node_modules/parse-imports/dist/main/parse-module-specifier/parse-type.js

@@ -0,0 +1,48 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _module2 = _interopRequireDefault(require("module"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const builtinModules = new Set(_module2.default.builtinModules);
+
+const parseType = moduleSpecifier => {
+  if (moduleSpecifier.length === 0) {
+    return `invalid`;
+  }
+
+  if (moduleSpecifier.startsWith(`/`)) {
+    return `absolute`;
+  }
+
+  if (moduleSpecifier.startsWith(`.`)) {
+    return `relative`;
+  }
+
+  if (builtinModules.has(moduleSpecifier)) {
+    return `builtin`;
+  }
+
+  return `package`;
+};
+
+var _default = parseType;
+exports.default = _default;

node_modules/parse-imports/dist/main/parse-module-specifier/resolve.js

@@ -0,0 +1,34 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _path = require("path");
+
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const resolve = (from, to) => {
+  try {
+    return require.resolve(to, {
+      paths: [(0, _path.dirname)(from)]
+    });
+  } catch {
+    return undefined;
+  }
+};
+
+var _default = resolve;
+exports.default = _default;

node_modules/parse-imports/dist/module/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/// <reference types="node"/>
+
+declare namespace parseImports {
+  export type ModuleSpecifierType =
+    | 'invalid'
+    | 'absolute'
+    | 'relative'
+    | 'builtin'
+    | 'package'
+    | 'unknown'
+
+  export type Import = {
+    isDynamicImport: boolean
+    moduleSpecifier: {
+      type: ModuleSpecifierType
+      isConstant: boolean
+      code: string
+      value?: string
+      resolved?: string
+    }
+    importClause?: {
+      default?: string
+      named: { specifier: string; binding: string }[]
+      namespace?: string
+    }
+  }
+
+  export type Options = { readonly resolveFrom?: string }
+}
+
+declare const parseImports: {
+  (code: string, options?: parseImports.Options): Promise<
+    IterableIterator<parseImports.Import>
+  >
+}
+
+export = parseImports

node_modules/parse-imports/dist/module/index.js

@@ -0,0 +1,64 @@
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { parse } from 'es-module-lexer';
+import parseModuleSpecifier from './parse-module-specifier';
+import parseImportClause from './parse-import-clause';
+
+const parseImports = async (code, {
+  resolveFrom
+} = {}) => {
+  const [imports] = await parse(code, resolveFrom != null ? resolveFrom : undefined);
+  return function* () {
+    for (let {
+      d: dynamicImportStartIndex,
+      ss: statementStartIndex,
+      s: moduleSpecifierStartIndex,
+      e: moduleSpecifierEndIndexExclusive
+    } of imports) {
+      const isDynamicImport = dynamicImportStartIndex > -1; // Include string literal quotes in character range
+
+      if (!isDynamicImport) {
+        moduleSpecifierStartIndex--;
+        moduleSpecifierEndIndexExclusive++;
+      }
+
+      const moduleSpecifierString = code.substring(moduleSpecifierStartIndex, moduleSpecifierEndIndexExclusive);
+      const moduleSpecifier = parseModuleSpecifier(moduleSpecifierString, {
+        isDynamicImport,
+        resolveFrom
+      });
+      let importClause;
+
+      if (!isDynamicImport) {
+        let importClauseString = code.substring(statementStartIndex + `import`.length, moduleSpecifierStartIndex).trim();
+
+        if (importClauseString.endsWith(`from`)) {
+          importClauseString = importClauseString.substring(0, importClauseString.length - `from`.length);
+        }
+
+        importClause = parseImportClause(importClauseString);
+      }
+
+      yield {
+        isDynamicImport,
+        moduleSpecifier,
+        importClause
+      };
+    }
+  }();
+};
+
+export default parseImports;

node_modules/parse-imports/dist/module/parse-import-clause/index.js

@@ -0,0 +1,60 @@
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { separatorRegex } from './skip';
+import parseNamedImports from './parse-named-imports';
+import parseNamespaceImport from './parse-namespace-import';
+import parseDefaultImport from './parse-default-import'; // Assumes import clause is syntactically valid
+
+const parseImportClause = importClauseString => {
+  let defaultImport;
+  let namespaceImport;
+  const namedImports = [];
+
+  for (let i = 0; i < importClauseString.length; i++) {
+    if (separatorRegex.test(importClauseString[i])) {
+      continue;
+    }
+
+    if (importClauseString[i] === `{`) {
+      let newNamedImports;
+      ({
+        namedImports: newNamedImports,
+        i
+      } = parseNamedImports(importClauseString, i));
+      namedImports.push(...newNamedImports);
+    } else if (importClauseString[i] === `*`) {
+      ;
+      ({
+        namespaceImport,
+        i
+      } = parseNamespaceImport(importClauseString, i));
+    } else {
+      ;
+      ({
+        defaultImport,
+        i
+      } = parseDefaultImport(importClauseString, i));
+    }
+  }
+
+  return {
+    default: defaultImport,
+    namespace: namespaceImport,
+    named: namedImports
+  };
+};
+
+export default parseImportClause;

node_modules/parse-imports/dist/module/parse-import-clause/parse-default-import.js

@@ -0,0 +1,27 @@
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { skipNonSeparators } from './skip';
+
+const parseDefaultImport = (importClauseString, i) => {
+  const startIndex = i;
+  i = skipNonSeparators(importClauseString, i);
+  return {
+    defaultImport: importClauseString.substring(startIndex, i),
+    i
+  };
+};
+
+export default parseDefaultImport;

node_modules/parse-imports/dist/module/parse-import-clause/parse-named-imports.js

@@ -0,0 +1,47 @@
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const parseNamedImports = (importClauseString, i) => {
+  const startIndex = ++i;
+
+  while (i < importClauseString.length && importClauseString[i] !== `}`) {
+    i++;
+  }
+
+  const namedImports = importClauseString.substring(startIndex, i++).split(`,`).map(namedImport => {
+    namedImport = namedImport.trim();
+
+    if (namedImport.includes(` `)) {
+      const components = namedImport.split(` `);
+      return {
+        specifier: components[0],
+        binding: components[components.length - 1]
+      };
+    }
+
+    return {
+      specifier: namedImport,
+      binding: namedImport
+    };
+  }).filter(({
+    specifier
+  }) => specifier.length > 0);
+  return {
+    namedImports,
+    i
+  };
+};
+
+export default parseNamedImports;

node_modules/parse-imports/dist/module/parse-import-clause/parse-namespace-import.js

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { skipNonSeparators, skipSeparators } from './skip';
+
+const parseNamespaceImport = (importClauseString, i) => {
+  i++;
+  i = skipSeparators(importClauseString, i);
+  i += `as`.length;
+  i = skipSeparators(importClauseString, i);
+  const startIndex = i;
+  i = skipNonSeparators(importClauseString, i);
+  return {
+    namespaceImport: importClauseString.substring(startIndex, i),
+    i
+  };
+};
+
+export default parseNamespaceImport;

node_modules/parse-imports/dist/module/parse-import-clause/skip.js

@@ -0,0 +1,30 @@
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export const separatorRegex = /^(?:\s+|,)$/u;
+export const skipSeparators = (imported, i) => {
+  while (i < imported.length && separatorRegex.test(imported[i])) {
+    i++;
+  }
+
+  return i;
+};
+export const skipNonSeparators = (imported, i) => {
+  while (i < imported.length && !separatorRegex.test(imported[i])) {
+    i++;
+  }
+
+  return i;
+};

node_modules/parse-imports/dist/module/parse-module-specifier/index.js

@@ -0,0 +1,44 @@
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { stripSlashes } from 'slashes';
+import isConstantStringLiteral from './is-constant-string-literal';
+import parseType from './parse-type';
+import resolve from './resolve';
+
+const parseModuleSpecifier = (moduleSpecifierString, {
+  isDynamicImport,
+  resolveFrom
+}) => {
+  const {
+    isConstant,
+    value
+  } = !isDynamicImport || isConstantStringLiteral(moduleSpecifierString) ? {
+    isConstant: true,
+    value: stripSlashes(moduleSpecifierString.substring(1, moduleSpecifierString.length - 1))
+  } : {
+    isConstant: false,
+    value: undefined
+  };
+  return {
+    type: isConstant ? parseType(value) : `unknown`,
+    isConstant,
+    code: moduleSpecifierString,
+    value,
+    resolved: typeof resolveFrom === `string` && isConstant ? resolve(resolveFrom, value) : undefined
+  };
+};
+
+export default parseModuleSpecifier;

node_modules/parse-imports/dist/module/parse-module-specifier/is-constant-string-literal.js

@@ -0,0 +1,39 @@
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Assumes the string is syntactically valid
+const isConstantStringLiteral = stringLiteral => {
+  const quote = [`'`, `"`, `\``].find(quoteCandidate => stringLiteral.startsWith(quoteCandidate) && stringLiteral.endsWith(quoteCandidate));
+
+  if (quote == null) {
+    return false;
+  }
+
+  for (let i = 1; i < stringLiteral.length - 1; i++) {
+    // Check for end of string literal before end of stringLiteral
+    if (stringLiteral[i] === quote && stringLiteral[i - 1] !== `\\`) {
+      return false;
+    } // Check for interpolated value in template literal
+
+
+    if (quote === `\`` && stringLiteral.substring(i, i + 2) === `\${` && stringLiteral[i - 1] !== `\\`) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+export default isConstantStringLiteral;

node_modules/parse-imports/dist/module/parse-module-specifier/parse-type.js

@@ -0,0 +1,39 @@
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import module from 'module';
+const builtinModules = new Set(module.builtinModules);
+
+const parseType = moduleSpecifier => {
+  if (moduleSpecifier.length === 0) {
+    return `invalid`;
+  }
+
+  if (moduleSpecifier.startsWith(`/`)) {
+    return `absolute`;
+  }
+
+  if (moduleSpecifier.startsWith(`.`)) {
+    return `relative`;
+  }
+
+  if (builtinModules.has(moduleSpecifier)) {
+    return `builtin`;
+  }
+
+  return `package`;
+};
+
+export default parseType;

node_modules/parse-imports/dist/module/parse-module-specifier/resolve.js

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { dirname } from 'path';
+
+const resolve = (from, to) => {
+  try {
+    return require.resolve(to, {
+      paths: [dirname(from)]
+    });
+  } catch {
+    return undefined;
+  }
+};
+
+export default resolve;

node_modules/parse-imports/license

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

node_modules/parse-imports/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "parse-imports",
+  "version": "0.0.5",
+  "author": {
+    "name": "Tomer Aberbach",
+    "email": "tomeraberbach@gmail.com",
+    "url": "https://tomeraberba.ch"
+  },
+  "description": "A blazing fast ES module imports parser.",
+  "keywords": [
+    "esm",
+    "imports",
+    "module",
+    "parser",
+    "imports"
+  ],
+  "homepage": "https://github.com/TomerAberbach/parse-imports",
+  "repository": "TomerAberbach/parse-imports",
+  "bugs": {
+    "url": "https://github.com/TomerAberbach/parse-imports/issues"
+  },
+  "license": "Apache 2.0",
+  "main": "dist/main/index.js",
+  "module": "dist/module/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "license": "addlicense $(git diff --name-only HEAD)",
+    "lint:eslint:base": "eslint --cache --ext mjs,cjs,js --ignore-path .gitignore --ignore-pattern \"**/fixtures/**/*\"",
+    "lint:eslint": "pnpm run lint:eslint:base -- --fix .",
+    "lint:prettier:base": "prettier --loglevel silent",
+    "lint:prettier": "pnpm run lint:prettier:base -- --write .",
+    "lint": "run-s lint:*",
+    "test": "ava",
+    "build:base": "babel --delete-dir-on-start -D --no-copy-ignored --keep-file-extension --ignore \"src/**/*.test.js,src/**/fixtures/**/*\"",
+    "build:dev": "pnpm run build:base -- -d dist src",
+    "build:main": "cross-env NODE_ENV=main pnpm run build:base -- -d dist/main src",
+    "build:module": "cross-env NODE_ENV=module pnpm run build:base -- -d dist/module src",
+    "build:prod": "run-p build:main build:module",
+    "clean": "rimraf dist"
+  },
+  "eslintConfig": {
+    "extends": "@tomer"
+  },
+  "prettier": "@tomer/prettier-config",
+  "browserslist": [
+    "node >= 10"
+  ],
+  "commitlint": {
+    "extends": "@commitlint/config-conventional"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged",
+      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS",
+      "pre-push": "pnpm run test"
+    }
+  },
+  "ava": {
+    "babel": true,
+    "require": [
+      "@babel/register"
+    ],
+    "files": [
+      "**/{*.,}test.js"
+    ]
+  },
+  "dependencies": {
+    "es-module-lexer": "0.3.26",
+    "slashes": "2.0.2"
+  },
+  "devDependencies": {
+    "@ava/babel": "1.0.1",
+    "@babel/cli": "7.12.10",
+    "@babel/core": "7.12.10",
+    "@babel/preset-env": "7.12.11",
+    "@babel/register": "7.12.10",
+    "@commitlint/cli": "11.0.0",
+    "@commitlint/config-conventional": "11.0.0",
+    "@tomer/eslint-config": "0.0.14",
+    "@tomer/prettier-config": "0.0.2",
+    "@types/node": "14.14.19",
+    "ava": "3.15.0",
+    "ava-fast-check": "4.0.0",
+    "babel-eslint": "10.1.0",
+    "babel-plugin-unassert": "3.0.1",
+    "babel-preset-power-assert": "3.0.0",
+    "command-exists": "1.2.9",
+    "cross-env": "7.0.3",
+    "eslint": "7.16.0",
+    "fast-check": "2.10.0",
+    "husky": "4.3.6",
+    "lint-staged": "10.5.3",
+    "npm-run-all": "4.1.5",
+    "power-assert": "1.6.1",
+    "prettier": "2.2.1",
+    "rimraf": "3.0.2",
+    "shift-codegen": "7.0.3",
+    "shift-fuzzer": "1.0.2"
+  },
+  "engines": {
+    "node": ">= 10"
+  }
+}

node_modules/parse-imports/readme.md

@@ -0,0 +1,237 @@
+# Parse Imports
+
+[![NPM version](https://img.shields.io/npm/v/parse-imports.svg)](https://www.npmjs.com/package/parse-imports)
+
+> A blazing fast ES module imports parser.
+
+## Features
+
+- Uses the superb WASM-based [`es-module-lexer`](https://github.com/guybedford/es-module-lexer) under the hood
+- Identifies module specifier types (e.g. relative file import, package import, builtin import, etc.)
+- Unescapes module specifier escape sequences
+- Collects default, named, and namespace imports
+- Works with dynamic imports
+- Resolves module specifier paths via `require.resolve`
+
+## Install
+
+Supports Node.js versions 10 and above.
+
+```sh
+$ npm i parse-imports
+```
+
+## Usage
+
+```js
+import parseImports from 'parse-imports'
+
+const code = `
+  import a from 'b'
+  import * as c from './d'
+  import { e as f, g as h, i } from '/j'
+  import k, { l as m } from 'n'
+  import o, * as p from "./q"
+  import r, { s as t, u } from "/v"
+  import fs from 'fs'
+
+  ;(async () => {
+    await import("w")
+    await import("x" + "y")
+  })()
+`
+
+const main = async () => {
+  // Lazily iterate over iterable of imports
+  for (const $import of await parseImports(code)) {
+    console.log($import)
+  }
+
+  // Or get as an array of imports
+  const imports = [...(await parseImports(code))]
+
+  console.log(imports[0])
+  //=>
+  // {
+  //   isDynamicImport: false,
+  //   moduleSpecifier: {
+  //     type: 'package',
+  //     isConstant: true,
+  //     code: `'b'`,
+  //     value: 'b',
+  //     resolved: undefined
+  //   },
+  //   importClause: {
+  //     default: 'a',
+  //     named: [],
+  //     namespace: undefined
+  //   }
+  // }
+
+  console.log(imports[1])
+  //=>
+  // {
+  //   isDynamicImport: false,
+  //   moduleSpecifier: {
+  //     type: 'relative',
+  //     isConstant: true,
+  //     code: `'./d'`,
+  //     value: './d',
+  //     resolved: undefined
+  //   },
+  //   importClause: {
+  //     default: undefined,
+  //     named: [],
+  //     namespace: 'c'
+  //   }
+  // }
+
+  console.log(imports[5])
+  //=>
+  // {
+  //   isDynamicImport: false,
+  //   moduleSpecifier: {
+  //     type: 'absolute',
+  //     isConstant: true,
+  //     code: '"/v"',
+  //     value: '/v',
+  //     resolved: undefined
+  //   },
+  //   importClause: {
+  //     default: 'r',
+  //     named: [
+  //       { specifier: 's', binding: 't' },
+  //       { specifier: 'u', binding: 'u' }
+  //     ],
+  //     namespace: undefined
+  //   }
+  // }
+
+  console.log(imports[8])
+  //=>
+  // {
+  //   isDynamicImport: true,
+  //   moduleSpecifier: {
+  //     type: 'package',
+  //     isConstant: true,
+  //     code: '"w"',
+  //     value: 'w',
+  //     resolved: undefined
+  //   },
+  //   importClause: undefined
+  // }
+
+  console.log(imports[9])
+  //=>
+  // {
+  //   isDynamicImport: true,
+  //   moduleSpecifier: {
+  //     type: 'unknown',
+  //     isConstant: false,
+  //     code: '"x" + "y"',
+  //     value: undefined,
+  //     resolved: undefined
+  //   },
+  //   importClause: undefined
+  // }
+}
+```
+
+## API
+
+### `parseImports(code[, options]) -> Promise<IterableIterator<Import>>`
+
+Returns a `Promise` resolving to a lazy [iterable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol)/[iterator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterator_protocol) that iterates over the imports in `code`.
+
+### Parameters
+
+#### `code`
+
+Type: `string`
+
+The JavaScript code to parse for imports.
+
+#### `options`
+
+Type: `object` (optional)
+
+##### Properties
+
+###### `resolveFrom`
+
+Type: `string` (optional)\
+Default: `undefined`
+
+If set to a file path, then `moduleSpecifier.resolved` of the returned `Import` instances will be set to the result of calling `require.resolve(moduleSpecifier.value)` from the given file path. Otherwise, will be `undefined`.
+
+### Types
+
+```ts
+type ModuleSpecifierType =
+  | 'invalid'
+  | 'absolute'
+  | 'relative'
+  | 'builtin'
+  | 'package'
+  | 'unknown'
+
+type Import = {
+  isDynamicImport: boolean
+  moduleSpecifier: {
+    type: ModuleSpecifierType
+    isConstant: boolean
+    code: string
+    value?: string
+    resolved?: string
+  }
+  importClause?: {
+    default?: string
+    named: string[]
+    namespace?: string
+  }
+}
+```
+
+#### `Import`
+
+`moduleSpecifier.isConstant` is `true` when the import is not a dynamic import (`isDynamicImport` is `false`), or when
+the import is a dynamic import where the specifier is a simple string literal (e.g. `import('fs')`, `import("fs")`, `` import(`fs`) ``).
+
+If `moduleSpecifier.isConstant` is `false`, then `moduleSpecifier.type` is `'unknown'`. Otherwise, it is set according to the following rules:
+
+- `'invalid'` if the module specifier is the empty string
+- `'absolute'` if the module specifier is an absolute file path
+- `'relative'` if the module specifier is a relative file path
+- `'builtin'` if the module specifier is the name of a builtin Node.js package
+- `'package'` otherwise
+
+`moduleSpecifier.code` is the module specifier as it was written in the code. For non-constant dynamic imports it could be a complex expression.
+
+`moduleSpecifier.value` is `moduleSpecifier.code` without string literal quotes and unescaped if `moduleSpecifier.isConstant` is `true`. Otherwise, it is `undefined`.
+
+`moduleSpecifier.resolved` is set if the `resolveFrom` option is set and `moduleSpecifier.value` is not `undefined`.
+
+`importClause` is only `undefined` if `isDynamicImport` is `true`.
+
+`importClause.default` is the default import identifier or `undefined` if the import statement does not have a default import.
+
+`importClause.named` is the array of objects representing the named imports of the import statement. It is empty if the import
+statement does not have any named imports. Each object in the array has a `specifier` field set to the imported identifier and a
+`binding` field set to the identifier for accessing the imported value. For example, `import { a, x as y } from 'something'` would have the following
+array for `importClause.named`: `[{ specifier: 'a', binding: 'a' }, { specifier: 'x', binding: 'y' }]`.
+
+`importClause.namespace` is the namespace import identifier or `undefined` if the import statement does not have a namespace import.
+
+## Contributing
+
+Stars are always welcome!
+
+For bugs and feature requests, [please create an issue](https://github.com/TomerAberbach/parse-imports/issues/new).
+
+For pull requests, please read the [contributing guidelines](https://github.com/TomerAberbach/parse-imports/blob/master/contributing.md).
+
+## License
+
+[Apache 2.0](https://github.com/TomerAberbach/parse-imports/blob/master/license)
+
+This is not an official Google product.