Initial import with skill sheet working

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

@@ -0,0 +1,150 @@
+/** Options for parsing imports. */
+type Options = {
+  /**
+   * If set to a file path, then {@link Import.moduleSpecifier.resolved} of
+   * returned instances will be set to the result of calling
+   * `require.resolve(moduleSpecifier.value)` from the given file path.
+   * Otherwise, will be undefined.
+   */
+  readonly resolveFrom?: string
+}
+
+/**
+ * A type representing what kind of module a specifier refers to.
+ *
+ * - 'unknown' if the module specifier is not a simple constant string literal
+ * - '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
+ */
+type ModuleSpecifierType =
+  | 'invalid'
+  | 'absolute'
+  | 'relative'
+  | 'builtin'
+  | 'package'
+  | 'unknown'
+
+/**
+ * A type representing an import in JavaScript code.
+ *
+ * `code.substring(startIndex, endIndex)` returns the full import statement or
+ * expression.
+ */
+type Import = {
+  /** The start index of the import in the JavaScript (inclusive). */
+  startIndex: number
+
+  /** The end index of the import in the JavaScript (exclusive). */
+  endIndex: number
+
+  /** Whether the import is a dynamic import (e.g. `import('module')`). */
+  isDynamicImport: boolean
+
+  /**
+   * A type representing the code specifiying the module being imported.
+   *
+   * `code.substring(moduleSpecifier.startIndex, moduleSpecifier.endIndex)`
+   * returns the module specifier including quotes.
+   */
+  moduleSpecifier: {
+    /**
+     * What kind of module the specifier refers to.
+     *
+     * 'unknown' when `moduleSpecifier.isConstant` is false.
+     */
+    type: ModuleSpecifierType
+
+    /** The start index of the specifier in the JavaScript (inclusive). */
+    startIndex: number
+
+    /** The end index of the specifier in the JavaScript (exclusive). */
+    endIndex: number
+
+    /**
+     * 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`)).
+     */
+    isConstant: boolean
+
+    /**
+     * The module specifier as it was written in the code. For non-constant
+     * dynamic imports it could be a complex expression.
+     */
+    code: string
+
+    /**
+     * `code` without string literal quotes and unescaped if `isConstant` is
+     * true. Otherwise, it is undefined.
+     */
+    value?: string
+
+    /** Set if the `resolveFrom` option is set and `value` is not undefined. */
+    resolved?: string
+  }
+
+  /**
+   * A type representing what is being imported from the module.
+   *
+   * Undefined if `isDynamicImport` is true.
+   */
+  importClause?: {
+    /**
+     * The default import identifier or undefined if the import statement does
+     * not have a default import.
+     */
+    default?: string
+
+    /**
+     * An 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:
+     * ```
+     * [{ specifier: 'a', binding: 'a' }, { specifier: 'x', binding: 'y' }]
+     * ```
+     */
+    named: { specifier: string; binding: string }[]
+
+    /**
+     * The namespace import identifier or undefined if the import statement does
+     * not have a namespace import.
+     */
+    namespace?: string
+  }
+}
+
+/**
+ * A promise that resolves once WASM has finished loading.
+ *
+ * Await this promise to be certain calling `parseImportsSync` is safe.
+ */
+declare const wasmLoadPromise: Promise<void>
+
+/**
+ * Returns a promise resolving to a lazy iterable/iterator that iterates over
+ * the imports in `code`.
+ */
+declare const parseImports: (
+  code: string,
+  options?: Options,
+) => Promise<Iterable<Import>>
+
+/**
+ * Returns a lazy iterable/iterator that iterates over the imports in `code`.
+ *
+ * @throws if called before WASM has finished loading. Await `wasmLoadPromise`
+ * to be sure it has finished.
+ */
+declare const parseImportsSync: (
+  code: string,
+  options?: Options,
+) => Iterable<Import>
+
+export { type Import, type ModuleSpecifierType, type Options, parseImports, parseImportsSync, wasmLoadPromise };