@flex-development/mlly 1.0.0-alpha.1 → 1.0.0-alpha.11

package/dist/internal/validate-string.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/internal/validate-string.ts"],
+  "mappings": "AAKA,SAAS,4BAA4C;AAgBrD,MAAM,iBAAiB,CAAC,OAAgB,SAAkC;AACxE,MAAI,OAAO,UAAU;AAAU,WAAO;AACtC,QAAM,IAAI,qBAAqB,MAAM,UAAU,KAAK;AACtD;AAEA,IAAO,0BAAQ;",
+  "names": []
+}

package/dist/internal/validate-url-string.d.mts

@@ -0,0 +1,22 @@
+/**
+ * @file Internal - validateURLString
+ * @module mlly/internal/validateURLString
+ */
+/// <reference types="node" />
+import { URL } from 'node:url';
+/**
+ * Checks if given `value` is an instance of {@linkcode URL} or a string.
+ *
+ * Throws [`ERR_INVALID_ARG_TYPE`][1] if the `value` is of neither type.
+ *
+ * [1]: https://nodejs.org/api/errors.html#err_invalid_arg_value
+ *
+ * @see {@linkcode ERR_INVALID_ARG_TYPE}
+ *
+ * @param {unknown} value - Value supplied by user
+ * @param {string} name - Name of invalid argument or property
+ * @return {value is URL | string} `true` if `value` is `URL` instance or string
+ * @throws {NodeError<TypeError>} If `value` is not `URL` instance or string
+ */
+declare const validateURLString: (value: unknown, name: string) => value is string | URL;
+export default validateURLString;

package/dist/internal/validate-url-string.mjs

@@ -0,0 +1,12 @@
+import { ERR_INVALID_ARG_TYPE } from "@flex-development/errnode";
+import { URL } from "node:url";
+const validateURLString = (value, name) => {
+  if (value instanceof URL || typeof value === "string")
+    return true;
+  throw new ERR_INVALID_ARG_TYPE(name, ["URL", "string"], value);
+};
+var validate_url_string_default = validateURLString;
+export {
+  validate_url_string_default as default
+};
+//# sourceMappingURL=validate-url-string.mjs.map

package/dist/internal/validate-url-string.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/internal/validate-url-string.ts"],
+  "mappings": "AAKA,SAAS,4BAA4C;AACrD,SAAS,WAAW;AAgBpB,MAAM,oBAAoB,CACxB,OACA,SAC0B;AAC1B,MAAI,iBAAiB,OAAO,OAAO,UAAU;AAAU,WAAO;AAC9D,QAAM,IAAI,qBAAqB,MAAM,CAAC,OAAO,QAAQ,GAAG,KAAK;AAC/D;AAEA,IAAO,8BAAQ;",
+  "names": []
+}

package/dist/types/declaration.d.mts

@@ -5,5 +5,5 @@
 /**
  * Export declaration kinds.
  */
-declare type Declaration = 'abstract class' | 'async function' | 'async function*' | 'class' | 'const enum' | 'const' | 'default async function' | 'default async function*' | 'default async' | 'default function' | 'default function*' | 'default' | 'enum' | 'function' | 'function*' | 'interface' | 'let' | 'namespace' | 'type' | 'var';
+type Declaration = 'class' | 'const enum' | 'const' | 'enum' | 'function' | 'function*' | 'interface' | 'let' | 'namespace' | 'type' | 'var';
 export type { Declaration as default };

package/dist/types/fn-change-ext.d.mts

@@ -0,0 +1,28 @@
+/**
+ * @file Type Definitions - ChangeExtFn
+ * @module mlly/types/ChangeExtFn
+ */
+/// <reference types="node" />
+import type { Nilable } from '@flex-development/tutils';
+import type { URL } from 'node:url';
+/**
+ * Function that returns a new file extension for the given module `specifier`.
+ *
+ * Returning an empty string (`''`) will remove the original file extension;
+ * returning `null` or `undefined` will skip extension replacement.
+ *
+ * ::: info
+ * The new file extension need not begin with a dot character (`'.'`).
+ * :::
+ *
+ * @see {@linkcode URL}
+ * @see https://github.com/flex-development/pathe/tree/1.0.3#changeextpath-string-ext-nullablestring-string
+ *
+ * @template Ext - File extension type(s)
+ *
+ * @param {string} specifier - Original module specifier
+ * @param {URL} url - Resolved module URL
+ * @return {Ext | PromiseLike<Ext>} New file extension, `null`, or `undefined`
+ */
+type ChangeExtFn<Ext extends Nilable<string> = Nilable<string>> = (specifier: string, url: URL) => Ext | PromiseLike<Ext>;
+export type { ChangeExtFn as default };

package/dist/types/index.d.mts

@@ -3,7 +3,11 @@
  * @module mlly/types
  */
 export type { default as Declaration } from './declaration.mjs';
-export type { default as Ext } from './ext.mjs';
-export type { default as MIMEType } from './mime-type.mjs';
-export type { default as SpecifierType } from './specifier-type.mjs';
-export type { default as StatementType } from './statement-type.mjs';
+export type { default as ChangeExtFn } from './fn-change-ext.mjs';
+export type { default as MimeType } from './mime-type.mjs';
+export type { default as ModuleId } from './module-id.mjs';
+export type { default as ModuleSpecifierType } from './module-specifier-type.mjs';
+export type { default as Protocol } from './protocol.mjs';
+export type { default as SyntaxKindExport } from './syntax-kind-export.mjs';
+export type { default as SyntaxKindImport } from './syntax-kind-import.mjs';
+export type { default as SyntaxKindRequire } from './syntax-kind-require.mjs';

package/dist/types/index.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=index.mjs.map

package/dist/types/index.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": [],
+  "mappings": "",
+  "names": []
+}

package/dist/types/mime-type.d.mts

@@ -1,11 +1,13 @@
 /**
- * @file Type Definitions - MIMEType
- * @module mlly/types/MIMEType
+ * @file Type Definitions - MimeType
+ * @module mlly/types/MimeType
  */
 /**
- * Supported MIME types.
+ * Supported [MIME types][1].
+ *
+ * [1]: https://developer.mozilla.org/docs/Web/HTTP/Basics_of_HTTP/MIME_types
  *
  * @see https://nodejs.org/api/esm.html#esm_data_imports
  */
-declare type MIMEType = 'application/json' | 'application/wasm' | 'text/javascript';
-export type { MIMEType as default };
+type MimeType = 'application/json' | 'application/typescript' | 'application/wasm' | 'text/javascript';
+export type { MimeType as default };

package/dist/types/module-id.d.mts

@@ -0,0 +1,13 @@
+/**
+ * @file Type Definitions - ModuleId
+ * @module mlly/types/ModuleId
+ */
+/// <reference types="node" />
+import type { URL } from 'node:url';
+/**
+ * ECMAScript (ES) module identifier.
+ *
+ * @see {@linkcode URL}
+ */
+type ModuleId = URL | string;
+export type { ModuleId as default };

package/dist/types/module-specifier-type.d.mts

@@ -0,0 +1,11 @@
+/**
+ * @file Type Definitions - ModuleSpecifierType
+ * @module mlly/types/ModuleSpecifierType
+ */
+/**
+ * Module specifier types.
+ *
+ * @see https://nodejs.org/api/esm.html#terminology
+ */
+type ModuleSpecifierType = 'absolute' | 'bare' | 'relative';
+export type { ModuleSpecifierType as default };

package/dist/types/protocol.d.mts

@@ -0,0 +1,14 @@
+/**
+ * @file Type Definitions - Protocol
+ * @module mlly/types/Protocol
+ */
+import type { LiteralUnion } from '@flex-development/tutils';
+/**
+ * URL protocols.
+ *
+ * @see https://nodejs.org/api/url.html#urlprotocol
+ * @see https://iana.org/assignments/uri-schemes/uri-schemes.xhtml
+ * @see https://url.spec.whatwg.org/#special-scheme
+ */
+type Protocol = LiteralUnion<`${'blob' | 'content' | 'cvs' | 'data' | 'dns' | 'file' | 'fish' | 'ftp' | 'git' | 'http' | 'https' | 'mvn' | 'redis' | 'sftp' | 'ssh' | 'svn' | 'urn' | 'view-source' | 'ws' | 'wss'}:`, `${string}:`>;
+export type { Protocol as default };

package/dist/types/syntax-kind-export.d.mts

@@ -0,0 +1,12 @@
+/**
+ * @file Type Definitions - SyntaxKindExport
+ * @module mlly/types/SyntaxKindExport
+ */
+import type { StatementSyntaxKind } from '../enums/index.mjs';
+/**
+ * `export` statement syntax kinds.
+ *
+ * @see {@linkcode StatementSyntaxKind}
+ */
+type SyntaxKindExport = StatementSyntaxKind.DECLARATION | StatementSyntaxKind.DEFAULT | StatementSyntaxKind.LIST | StatementSyntaxKind.NAMED | StatementSyntaxKind.NAMESPACE;
+export type { SyntaxKindExport as default };

package/dist/types/syntax-kind-import.d.mts

@@ -0,0 +1,12 @@
+/**
+ * @file Type Definitions - SyntaxKindImport
+ * @module mlly/types/SyntaxKindImport
+ */
+import type { StatementSyntaxKind } from '../enums/index.mjs';
+/**
+ * `import` statement syntax kinds.
+ *
+ * @see {@linkcode StatementSyntaxKind}
+ */
+type SyntaxKindImport = StatementSyntaxKind.DEFAULT | StatementSyntaxKind.DEFAULT_WITH_NAMED | StatementSyntaxKind.DEFAULT_WITH_NAMESPACE | StatementSyntaxKind.DYNAMIC | StatementSyntaxKind.NAMED | StatementSyntaxKind.NAMESPACE | StatementSyntaxKind.SIDE_EFFECT;
+export type { SyntaxKindImport as default };

package/dist/types/syntax-kind-require.d.mts

@@ -0,0 +1,12 @@
+/**
+ * @file Type Definitions - SyntaxKindRequire
+ * @module mlly/types/SyntaxKindRequire
+ */
+import type { StatementSyntaxKind } from '../enums/index.mjs';
+/**
+ * `require` statement syntax kinds.
+ *
+ * @see {@linkcode StatementSyntaxKind}
+ */
+type SyntaxKindRequire = StatementSyntaxKind.REQUIRE;
+export type { SyntaxKindRequire as default };

package/dist/utils/compare-subpaths.d.mts

@@ -0,0 +1,25 @@
+/**
+ * @file compareSubpaths
+ * @module mlly/utils/compareSubpaths
+ */
+import { CompareResult } from '@flex-development/tutils';
+/**
+ * Returns a number indicating if a subpath pattern is equal to, greater than,
+ * or less than another subpath pattern.
+ *
+ * - `-1`: `subpath2` is less than `subpath1`
+ * - `0`: `subpath2` is equal to `subpath1`
+ * - `1`: `subpath2` is greater than `subpath1`
+ *
+ * Implements the `PATTERN_KEY_COMPARE` algorithm.
+ *
+ * @see https://nodejs.org/api/esm.html#resolution-algorithm
+ *
+ * @param {string} subpath1 - Subpath to be compared
+ * @param {string} subpath2 - Subpath to compare `subpath1` to
+ * @return {CompareResult} Comparsion result
+ * @throws {NodeError<Error | TypeError>} If either either subpath contains more
+ * than pattern character (`'*'`) or is not a string
+ */
+declare const compareSubpaths: (subpath1: string, subpath2: string) => CompareResult;
+export default compareSubpaths;

package/dist/utils/compare-subpaths.mjs

@@ -0,0 +1,24 @@
+import validateString from "../internal/validate-string.mjs";
+import { CompareResult } from "@flex-development/tutils";
+import assert from "node:assert";
+import PATTERN_CHARACTER from "./pattern-character.mjs";
+const compareSubpaths = (subpath1, subpath2) => {
+  validateString(subpath1, "subpath1");
+  validateString(subpath2, "subpath2");
+  let pattern1 = -1;
+  let pattern2 = -1;
+  for (const [index, subpath] of [subpath1, subpath2].entries()) {
+    const message = `'${subpath}' is expected to contain a single '*'`;
+    const pattern_index = subpath.indexOf(PATTERN_CHARACTER);
+    assert(pattern_index === subpath.lastIndexOf(PATTERN_CHARACTER), message);
+    index === 0 ? pattern1 = pattern_index : pattern2 = pattern_index;
+  }
+  const length1 = pattern1 === -1 ? subpath1.length : pattern1 + 1;
+  const length2 = pattern2 === -1 ? subpath2.length : pattern2 + 1;
+  return length1 > length2 ? CompareResult.LESS_THAN : length2 > length1 ? CompareResult.GREATER_THAN : pattern1 === -1 ? CompareResult.GREATER_THAN : pattern2 === -1 ? CompareResult.LESS_THAN : subpath1.length > subpath2.length ? CompareResult.LESS_THAN : subpath2.length > subpath1.length ? CompareResult.GREATER_THAN : CompareResult.EQUAL;
+};
+var compare_subpaths_default = compareSubpaths;
+export {
+  compare_subpaths_default as default
+};
+//# sourceMappingURL=compare-subpaths.mjs.map

package/dist/utils/compare-subpaths.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/compare-subpaths.ts"],
+  "mappings": "AAKA,OAAO,oBAAoB;AAE3B,SAAS,qBAAqB;AAC9B,OAAO,YAAY;AACnB,OAAO,uBAAuB;AAoB9B,MAAM,kBAAkB,CAAC,UAAkB,aAAoC;AAC7E,iBAAe,UAAU,UAAU;AACnC,iBAAe,UAAU,UAAU;AAOnC,MAAI,WAAmB;AAOvB,MAAI,WAAmB;AAGvB,aAAW,CAAC,OAAO,OAAO,KAAK,CAAC,UAAU,QAAQ,EAAE,QAAQ,GAAG;AAM7D,UAAM,UAAkB,IAAI;AAO5B,UAAM,gBAAwB,QAAQ,QAAQ,iBAAiB;AAG/D,WAAO,kBAAkB,QAAQ,YAAY,iBAAiB,GAAG,OAAO;AAGxE,cAAU,IAAK,WAAW,gBAAkB,WAAW;AAAA,EACzD;AAOA,QAAM,UAAkB,aAAa,KAAK,SAAS,SAAS,WAAW;AAOvE,QAAM,UAAkB,aAAa,KAAK,SAAS,SAAS,WAAW;AAEvE,SAAO,UAAU,UACb,cAAc,YACd,UAAU,UACV,cAAc,eACd,aAAa,KACb,cAAc,eACd,aAAa,KACb,cAAc,YACd,SAAS,SAAS,SAAS,SAC3B,cAAc,YACd,SAAS,SAAS,SAAS,SAC3B,cAAc,eACd,cAAc;AACpB;AAEA,IAAO,2BAAQ;",
+  "names": []
+}

package/dist/utils/conditions.d.mts

@@ -0,0 +1,13 @@
+/**
+ * @file CONDITIONS
+ * @module mlly/utils/CONDITIONS
+ */
+/**
+ * Default export conditions.
+ *
+ * @see https://nodejs.org/api/packages.html#conditional-exports
+ *
+ * @const {Set<string>} CONDITIONS
+ */
+declare const CONDITIONS: Set<string>;
+export default CONDITIONS;

package/dist/utils/conditions.mjs

@@ -0,0 +1,6 @@
+const CONDITIONS = /* @__PURE__ */ new Set(["node", "import"]);
+var conditions_default = CONDITIONS;
+export {
+  conditions_default as default
+};
+//# sourceMappingURL=conditions.mjs.map

package/dist/utils/conditions.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/conditions.ts"],
+  "mappings": "AAYA,MAAM,aAA0B,oBAAI,IAAI,CAAC,QAAQ,QAAQ,CAAC;AAE1D,IAAO,qBAAQ;",
+  "names": []
+}

package/dist/{lib → utils}/detect-syntax.d.mts

@@ -1,16 +1,16 @@
 /**
  * @file detectSyntax
- * @module mlly/lib/detectSyntax
+ * @module mlly/utils/detectSyntax
  */
 /**
  * Detects if `code` contains CommonJS syntax, ESM syntax, or a mixture of both.
  *
  * Ignores matches in comments.
  *
- * @see {@link hasCJSSyntax}
- * @see {@link hasESMSyntax}
+ * @see {@linkcode hasCJSSyntax}
+ * @see {@linkcode hasESMSyntax}
  *
- * @param {string} code - Code to check
+ * @param {string} code - Code to evaluate
  * @return {{ cjs: boolean; esm: boolean; mixed: boolean }} Detection result
  */
 declare const detectSyntax: (code: string) => {

package/dist/{lib → utils}/detect-syntax.mjs

@@ -9,3 +9,4 @@ var detect_syntax_default = detectSyntax;
 export {
   detect_syntax_default as default
 };
+//# sourceMappingURL=detect-syntax.mjs.map

package/dist/utils/detect-syntax.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/detect-syntax.ts"],
+  "mappings": "AAKA,OAAO,kBAAkB;AACzB,OAAO,kBAAkB;AAazB,MAAM,eAAe,CACnB,SACmD;AAMnD,QAAM,MAAe,aAAa,IAAI;AAOtC,QAAM,MAAe,aAAa,IAAI;AAEtC,SAAO,EAAE,KAAK,KAAK,OAAO,OAAO,IAAI;AACvC;AAEA,IAAO,wBAAQ;",
+  "names": []
+}

package/dist/utils/extension-format-map.d.mts

@@ -0,0 +1,16 @@
+/**
+ * @file EXTENSION_FORMAT_MAP
+ * @module mlly/utils/EXTENSION_FORMAT_MAP
+ */
+import { Format } from '../enums/index.mjs';
+import type { Ext } from '@flex-development/pathe';
+/**
+ * Default file extension to module formats map.
+ *
+ * @see {@linkcode Ext}
+ * @see {@linkcode Format}
+ *
+ * @const {Map<Ext, Format>} EXTENSION_FORMAT_MAP
+ */
+declare const EXTENSION_FORMAT_MAP: Map<Ext, Format>;
+export default EXTENSION_FORMAT_MAP;

package/dist/utils/extension-format-map.mjs

@@ -0,0 +1,22 @@
+import { Format } from "../enums/index.mjs";
+const EXTENSION_FORMAT_MAP = /* @__PURE__ */ new Map([
+  [".cjs", Format.COMMONJS],
+  [".cts", Format.COMMONJS],
+  [".d.cts", Format.COMMONJS],
+  [".d.mts", Format.MODULE],
+  [".d.ts", Format.MODULE],
+  [".js", Format.MODULE],
+  [".json", Format.JSON],
+  [".jsx", Format.MODULE],
+  [".mjs", Format.MODULE],
+  [".mts", Format.MODULE],
+  [".node", Format.COMMONJS],
+  [".ts", Format.MODULE],
+  [".tsx", Format.MODULE],
+  [".wasm", Format.WASM]
+]);
+var extension_format_map_default = EXTENSION_FORMAT_MAP;
+export {
+  extension_format_map_default as default
+};
+//# sourceMappingURL=extension-format-map.mjs.map

package/dist/utils/extension-format-map.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/extension-format-map.ts"],
+  "mappings": "AAKA,SAAS,cAAc;AAWvB,MAAM,uBAAyC,oBAAI,IAAiB;AAAA,EAClE,CAAC,QAAQ,OAAO,QAAQ;AAAA,EACxB,CAAC,QAAQ,OAAO,QAAQ;AAAA,EACxB,CAAC,UAAU,OAAO,QAAQ;AAAA,EAC1B,CAAC,UAAU,OAAO,MAAM;AAAA,EACxB,CAAC,SAAS,OAAO,MAAM;AAAA,EACvB,CAAC,OAAO,OAAO,MAAM;AAAA,EACrB,CAAC,SAAS,OAAO,IAAI;AAAA,EACrB,CAAC,QAAQ,OAAO,MAAM;AAAA,EACtB,CAAC,QAAQ,OAAO,MAAM;AAAA,EACtB,CAAC,QAAQ,OAAO,MAAM;AAAA,EACtB,CAAC,SAAS,OAAO,QAAQ;AAAA,EACzB,CAAC,OAAO,OAAO,MAAM;AAAA,EACrB,CAAC,QAAQ,OAAO,MAAM;AAAA,EACtB,CAAC,SAAS,OAAO,IAAI;AACvB,CAAC;AAED,IAAO,+BAAQ;",
+  "names": []
+}

package/dist/utils/extract-statements.d.mts

@@ -0,0 +1,21 @@
+/**
+ * @file extractStatements
+ * @module mlly/utils/extractStatements
+ */
+import type { Statement } from '../interfaces/index.mjs';
+/**
+ * Finds all `export`, `import`, and/or  `require` statements in `code`.
+ *
+ * Ignores matches in comments.
+ *
+ * @see {@linkcode findDynamicImports}
+ * @see {@linkcode findExports}
+ * @see {@linkcode findRequires}
+ * @see {@linkcode findStaticImports}
+ *
+ * @param {string} [code=''] - Code to evaluate
+ * @return {Statement[]} Extracted statements
+ * @throws {NodeError<TypeError>} If `code` is not a string
+ */
+declare const extractStatements: (code?: string) => Statement[];
+export default extractStatements;

package/dist/{lib → utils}/extract-statements.mjs

@@ -1,9 +1,11 @@
+import validateString from "../internal/validate-string.mjs";
 import findDynamicImports from "./find-dynamic-imports.mjs";
 import findExports from "./find-exports.mjs";
 import findRequires from "./find-requires.mjs";
 import findStaticImports from "./find-static-imports.mjs";
 const extractStatements = (code = "") => {
-  if (!code)
+  validateString(code, "code");
+  if (code.trim().length < "export".length)
     return [];
   return [
     ...findDynamicImports(code),
@@ -16,3 +18,4 @@ var extract_statements_default = extractStatements;
 export {
   extract_statements_default as default
 };
+//# sourceMappingURL=extract-statements.mjs.map

package/dist/utils/extract-statements.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/extract-statements.ts"],
+  "mappings": "AAMA,OAAO,oBAAoB;AAE3B,OAAO,wBAAwB;AAC/B,OAAO,iBAAiB;AACxB,OAAO,kBAAkB;AACzB,OAAO,uBAAuB;AAgB9B,MAAM,oBAAoB,CAAC,OAAe,OAAoB;AAC5D,iBAAe,MAAM,MAAM;AAG3B,MAAI,KAAK,KAAK,EAAE,SAAS,SAAS;AAAQ,WAAO,CAAC;AAElD,SAAO;AAAA,IACL,GAAG,mBAAmB,IAAI;AAAA,IAC1B,GAAG,YAAY,IAAI;AAAA,IACnB,GAAG,aAAa,IAAI;AAAA,IACpB,GAAG,kBAAkB,IAAI;AAAA,EAC3B;AACF;AAEA,IAAO,6BAAQ;",
+  "names": []
+}

package/dist/utils/fill-modules.d.mts

@@ -0,0 +1,23 @@
+/**
+ * @file fillModules
+ * @module mlly/utils/fillModules
+ */
+import type { FillModuleOptions } from '../interfaces/index.mjs';
+/**
+ * Ensures all absolute and relative module specifiers in the given piece of
+ * source `code` are fully specified.
+ *
+ * Ignores specifiers that already have file extensions.
+ *
+ * @see {@linkcode FillModuleOptions}
+ * @see https://nodejs.org/api/esm.html#mandatory-file-extensions
+ * @see https://nodejs.org/api/esm.html#terminology
+ *
+ * @async
+ *
+ * @param {string} code - Code to evaluate
+ * @param {FillModuleOptions} options - Module fill options
+ * @return {Promise<string>} `code` with fully specified module specifiers
+ */
+declare const fillModules: (code: string, options: FillModuleOptions) => Promise<string>;
+export default fillModules;

package/dist/utils/fill-modules.mjs

@@ -0,0 +1,64 @@
+import { SpecifierSyntaxKind } from "../enums/index.mjs";
+import regexp from "../internal/escape-reg-exp.mjs";
+import isFunction from "../internal/is-function.mjs";
+import { ERR_UNKNOWN_FILE_EXTENSION } from "@flex-development/errnode";
+import pathe from "@flex-development/pathe";
+import CONDITIONS from "./conditions.mjs";
+import extractStatements from "./extract-statements.mjs";
+import isAbsoluteSpecifier from "./is-absolute-specifier.mjs";
+import isBareSpecifier from "./is-bare-specifier.mjs";
+import resolveModule from "./resolve-module.mjs";
+import toBareSpecifier from "./to-bare-specifier.mjs";
+import toRelativeSpecifier from "./to-relative-specifier.mjs";
+const fillModules = async (code, options) => {
+  const { conditions = CONDITIONS, ext, parent = import.meta.url } = options;
+  for (const statement of extractStatements(code)) {
+    if (!statement.specifier)
+      continue;
+    if (statement.specifier_syntax === SpecifierSyntaxKind.DYNAMIC)
+      continue;
+    const url = await resolveModule(statement.specifier, {
+      ...options,
+      /**
+       * Returns a replacement file extension for the given module `specifier`
+       * **if it is non-bare and does not already have an extension**.
+       *
+       * Throws [`ERR_UNKNOWN_FILE_EXTENSION`][1] if the replacement extension
+       * is `null`, `undefined`, an empty string, or a dot character (`'.'`).
+       *
+       * [1]: https://nodejs.org/api/errors.html#err_unknown_file_extension
+       *
+       * @async
+       *
+       * @param {string} specifier - Module specifier
+       * @param {URL} url - Resolved module URL
+       * @return {Promise<string | undefined>} New file extension or `undefined`
+       */
+      async ext(specifier, url2) {
+        if (isBareSpecifier(specifier))
+          return void 0;
+        if (pathe.extname(specifier) === pathe.extname(url2.href))
+          return void 0;
+        const rext = isFunction(ext) ? await ext(specifier, url2) : ext;
+        if (!(rext && rext.trim().length > (rext.startsWith(".") ? 1 : 0))) {
+          throw new ERR_UNKNOWN_FILE_EXTENSION(rext, specifier);
+        }
+        return rext;
+      }
+    });
+    code = code.replace(
+      statement.code,
+      statement.code.replace(
+        new RegExp(`(?<=["'])${regexp(statement.specifier)}(?=["'])`),
+        // convert module url back to absolute, bare, or relative specifier
+        statement.specifier.startsWith("#") ? statement.specifier : isAbsoluteSpecifier(statement.specifier) ? url.href : isBareSpecifier(statement.specifier) ? toBareSpecifier(url, parent, new Set(conditions)) : toRelativeSpecifier(url, parent)
+      )
+    );
+  }
+  return code;
+};
+var fill_modules_default = fillModules;
+export {
+  fill_modules_default as default
+};
+//# sourceMappingURL=fill-modules.mjs.map

package/dist/utils/fill-modules.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/fill-modules.ts"],
+  "mappings": "AAKA,SAAS,2BAA2B;AAEpC,OAAO,YAAY;AACnB,OAAO,gBAAgB;AACvB,SAAS,kCAAkC;AAC3C,OAAO,WAAW;AAElB,OAAO,gBAAgB;AACvB,OAAO,uBAAuB;AAC9B,OAAO,yBAAyB;AAChC,OAAO,qBAAqB;AAC5B,OAAO,mBAAmB;AAC1B,OAAO,qBAAqB;AAC5B,OAAO,yBAAyB;AAkBhC,MAAM,cAAc,OAClB,MACA,YACoB;AACpB,QAAM,EAAE,aAAa,YAAY,KAAK,SAAS,YAAY,IAAI,IAAI;AAGnE,aAAW,aAAa,kBAAkB,IAAI,GAAG;AAE/C,QAAI,CAAC,UAAU;AAAW;AAG1B,QAAI,UAAU,qBAAqB,oBAAoB;AAAS;AAOhE,UAAM,MAAW,MAAM,cAAc,UAAU,WAAW;AAAA,MACxD,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAgBH,MAAM,IAAI,WAAmBA,MAAuC;AAElE,YAAI,gBAAgB,SAAS;AAAG,iBAAO;AAGvC,YAAI,MAAM,QAAQ,SAAS,MAAM,MAAM,QAAQA,KAAI,IAAI;AAAG,iBAAO;AAOjE,cAAM,OAAe,WAAW,GAAG,IAAI,MAAM,IAAI,WAAWA,IAAG,IAAI;AAGnE,YAAI,EAAE,QAAQ,KAAK,KAAK,EAAE,UAAU,KAAK,WAAW,GAAG,IAAI,IAAI,KAAK;AAClE,gBAAM,IAAI,2BAA2B,MAAM,SAAS;AAAA,QACtD;AAEA,eAAO;AAAA,MACT;AAAA,IACF,CAAC;AAGD,WAAO,KAAK;AAAA,MACV,UAAU;AAAA,MACV,UAAU,KAAK;AAAA,QACb,IAAI,OAAO,YAAY,OAAO,UAAU,SAAS,WAAW;AAAA;AAAA,QAE5D,UAAU,UAAU,WAAW,GAAG,IAC9B,UAAU,YACV,oBAAoB,UAAU,SAAS,IACvC,IAAI,OACJ,gBAAgB,UAAU,SAAS,IACnC,gBAAgB,KAAK,QAAQ,IAAI,IAAI,UAAU,CAAC,IAChD,oBAAoB,KAAK,MAAM;AAAA,MACrC;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAEA,IAAO,uBAAQ;",
+  "names": ["url"]
+}

package/dist/utils/find-dynamic-imports.d.mts

@@ -0,0 +1,18 @@
+/**
+ * @file findDynamicImports
+ * @module mlly/utils/findDynamicImports
+ */
+import type { DynamicImport } from '../interfaces/index.mjs';
+/**
+ * Finds all dynamic import statements in `code`. Ignores matches in comments.
+ *
+ * @see {@linkcode DynamicImport}
+ * @see https://regex101.com/r/PTPAvU
+ * @see https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/import
+ *
+ * @param {string} [code=''] - Code to evaluate
+ * @return {DynamicImport[]} Dynamic import statement objects
+ * @throws {NodeError<TypeError>} If `code` is not a string
+ */
+declare const findDynamicImports: (code?: string) => DynamicImport[];
+export default findDynamicImports;

package/dist/utils/find-dynamic-imports.mjs

@@ -0,0 +1,39 @@
+import {
+  SpecifierSyntaxKind,
+  StatementKind,
+  StatementSyntaxKind
+} from "../enums/index.mjs";
+import getSpecifierKind from "../internal/get-specifier-kind.mjs";
+import validateString from "../internal/validate-string.mjs";
+import { DYNAMIC_IMPORT_REGEX } from "@flex-development/import-regex";
+const findDynamicImports = (code = "") => {
+  validateString(code, "code");
+  return [...code.matchAll(DYNAMIC_IMPORT_REGEX)].map((match) => {
+    const { 0: code2 = "", index: start = 0, groups = {} } = match;
+    const {
+      expression = "",
+      imports = "",
+      options = "",
+      specifier = ""
+    } = groups;
+    const specifier_syntax = /^["']/.test(specifier) ? SpecifierSyntaxKind.STATIC : SpecifierSyntaxKind.DYNAMIC;
+    return {
+      code: code2,
+      end: start + code2.length,
+      expression,
+      imports: imports === "" ? [] : imports.replace(/^{|}$/g, "").split(",").map((e) => e.trim()).filter((e) => e.length > 0),
+      kind: StatementKind.IMPORT,
+      options,
+      specifier: specifier.replace(/^["']|["']$/g, ""),
+      specifier_kind: specifier_syntax === SpecifierSyntaxKind.DYNAMIC ? null : getSpecifierKind(specifier),
+      specifier_syntax,
+      start,
+      syntax: StatementSyntaxKind.DYNAMIC
+    };
+  });
+};
+var find_dynamic_imports_default = findDynamicImports;
+export {
+  find_dynamic_imports_default as default
+};
+//# sourceMappingURL=find-dynamic-imports.mjs.map

package/dist/utils/find-dynamic-imports.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/find-dynamic-imports.ts"],
+  "mappings": "AAKA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,OAAO,sBAAsB;AAC7B,OAAO,oBAAoB;AAE3B,SAAS,4BAA4B;AAarC,MAAM,qBAAqB,CAAC,OAAe,OAAwB;AACjE,iBAAe,MAAM,MAAM;AAE3B,SAAO,CAAC,GAAG,KAAK,SAAS,oBAAoB,CAAC,EAAE,IAAI,WAAS;AAC3D,UAAM,EAAE,GAAGA,QAAO,IAAI,OAAO,QAAQ,GAAG,SAAS,CAAC,EAAE,IAAI;AACxD,UAAM;AAAA,MACJ,aAAa;AAAA,MACb,UAAU;AAAA,MACV,UAAU;AAAA,MACV,YAAY;AAAA,IACd,IAAI;AAOJ,UAAM,mBAAwC,QAAQ,KAAK,SAAS,IAChE,oBAAoB,SACpB,oBAAoB;AAExB,WAAO;AAAA,MACL,MAAAA;AAAA,MACA,KAAK,QAAQA,MAAK;AAAA,MAClB;AAAA,MACA,SACE,YAAY,KACR,CAAC,IACD,QACG,QAAQ,UAAU,EAAE,EACpB,MAAM,GAAG,EACT,IAAI,OAAK,EAAE,KAAK,CAAC,EACjB,OAAO,OAAK,EAAE,SAAS,CAAC;AAAA,MACjC,MAAM,cAAc;AAAA,MACpB;AAAA,MACA,WAAW,UAAU,QAAQ,gBAAgB,EAAE;AAAA,MAC/C,gBACE,qBAAqB,oBAAoB,UACrC,OACA,iBAAiB,SAAS;AAAA,MAChC;AAAA,MACA;AAAA,MACA,QAAQ,oBAAoB;AAAA,IAC9B;AAAA,EACF,CAAC;AACH;AAEA,IAAO,+BAAQ;",
+  "names": ["code"]
+}

package/dist/utils/find-exports.d.mts

@@ -0,0 +1,21 @@
+/**
+ * @file findExports
+ * @module mlly/utils/findExports
+ */
+import type { ExportStatement } from '../interfaces/index.mjs';
+/**
+ * Finds all export statements in `code`. Ignores matches in comments.
+ *
+ * @see {@linkcode ExportStatement}
+ * @see https://regex101.com/r/JtvRUt
+ * @see https://regex101.com/r/8HpMrA
+ * @see https://regex101.com/r/G7GhEt
+ * @see https://regex101.com/r/KQEDdZ
+ * @see https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/export
+ *
+ * @param {string} [code=''] - Code to evaluate
+ * @return {ExportStatement[]} Export statement objects
+ * @throws {NodeError<TypeError>} If `code` is not a string
+ */
+declare const findExports: (code?: string) => ExportStatement[];
+export default findExports;