@flex-development/mlly 1.0.0-alpha.1

package/dist/lib/find-requires.mjs

@@ -0,0 +1,19 @@
+import { REQUIRE_STATEMENT_REGEX } from "../internal/index.mjs";
+const findRequires = (code) => {
+  return [...code.matchAll(REQUIRE_STATEMENT_REGEX)].map((match) => {
+    const { 0: statement = "", index: start = 0, groups = {} } = match;
+    const { imports = "", specifier = "", type = "" } = groups;
+    return {
+      code: statement,
+      end: start + statement.length,
+      imports: imports === "" || type === "require.resolve" ? [] : /const *\w/.test(statement) ? ["default"] : imports.split(",").map((name) => name.trim()),
+      specifier,
+      start,
+      type
+    };
+  });
+};
+var find_requires_default = findRequires;
+export {
+  find_requires_default as default
+};

package/dist/lib/find-static-imports.d.mts

@@ -0,0 +1,15 @@
+/**
+ * @file findStaticImports
+ * @module mlly/lib/findStaticImports
+ */
+import type { StaticImport } from '../interfaces/index.mjs';
+/**
+ * Finds all static import statements in `code`. Ignores matches in comments.
+ *
+ * @see {@link StaticImport}
+ *
+ * @param {string} code - Code to check
+ * @return {StaticImport[]} Static import statement objects
+ */
+declare const findStaticImports: (code: string) => StaticImport[];
+export default findStaticImports;

package/dist/lib/find-static-imports.mjs

@@ -0,0 +1,20 @@
+import { STATIC_IMPORT_REGEX } from "../internal/index.mjs";
+const findStaticImports = (code) => {
+  return [...code.matchAll(STATIC_IMPORT_REGEX)].map((match) => {
+    const { 0: statement = "", index: start = 0, groups = {} } = match;
+    const { imports = "", specifier = "" } = groups;
+    const star = imports.startsWith("* as");
+    return {
+      code: statement,
+      end: start + statement.length,
+      imports: star ? [imports.trim()] : imports.replace(/^type\s*|[{}]/gm, "").split(/,\n?/).map((name) => name.trim()),
+      specifier,
+      start,
+      type: star ? "star" : /{(?<imports>[\w\t\n\r ,]+)}/gm.test(statement) ? "named" : "default"
+    };
+  });
+};
+var find_static_imports_default = findStaticImports;
+export {
+  find_static_imports_default as default
+};

package/dist/lib/has-cjs-syntax.d.mts

@@ -0,0 +1,22 @@
+/**
+ * @file hasCJSSyntax
+ * @module mlly/lib/hasCJSSyntax
+ */
+/**
+ * Detects if `code` contains CommonJS syntax. Ignores matches in comments.
+ *
+ * Syntax patterns:
+ *
+ * - `__dirname`
+ * - `__filename`
+ * - `await import`
+ * - `exports`
+ * - `module.exports`
+ * - `require`
+ * - `require.*`
+ *
+ * @param {string} code - Code to check
+ * @return {boolean} `true` if `code` contains cjs syntax, `false` otherwise
+ */
+declare const hasCJSSyntax: (code: string) => boolean;
+export default hasCJSSyntax;

package/dist/lib/has-cjs-syntax.mjs

@@ -0,0 +1,6 @@
+import { CJS_SYNTAX_REGEX } from "../internal/index.mjs";
+const hasCJSSyntax = (code) => !!code.match(CJS_SYNTAX_REGEX);
+var has_cjs_syntax_default = hasCJSSyntax;
+export {
+  has_cjs_syntax_default as default
+};

package/dist/lib/has-esm-syntax.d.mts

@@ -0,0 +1,18 @@
+/**
+ * @file hasESMSyntax
+ * @module mlly/lib/hasESMSyntax
+ */
+/**
+ * Detects if `code` contains ESM syntax. Ignores matches in comments.
+ *
+ * Syntax patterns:
+ *
+ * - `export` (declaration, default, named, star)
+ * - `import` (default, dynamic, named, star)
+ * - `import.meta.(env|resolve|url)`
+ *
+ * @param {string} code - Code to check
+ * @return {boolean} `true` if `code` contains esm syntax, `false` otherwise
+ */
+declare const hasESMSyntax: (code: string) => boolean;
+export default hasESMSyntax;

package/dist/lib/has-esm-syntax.mjs

@@ -0,0 +1,6 @@
+import { ESM_SYNTAX_REGEX } from "../internal/index.mjs";
+const hasESMSyntax = (code) => !!code.match(ESM_SYNTAX_REGEX);
+var has_esm_syntax_default = hasESMSyntax;
+export {
+  has_esm_syntax_default as default
+};

package/dist/lib/index.d.mts

@@ -0,0 +1,20 @@
+/**
+ * @file Library
+ * @module mlly/lib
+ */
+export { default as detectSyntax } from './detect-syntax.mjs';
+export { default as extractStatements } from './extract-statements.mjs';
+export { default as findDynamicImports } from './find-dynamic-imports.mjs';
+export { default as findExports } from './find-exports.mjs';
+export { default as findRequires } from './find-requires.mjs';
+export { default as findStaticImports } from './find-static-imports.mjs';
+export { default as hasCJSSyntax } from './has-cjs-syntax.mjs';
+export { default as hasESMSyntax } from './has-esm-syntax.mjs';
+export { default as resolveAlias } from './resolve-alias.mjs';
+export { default as resolveAliases } from './resolve-aliases.mjs';
+export { default as resolveModule } from './resolve-module.mjs';
+export { default as resolveModules } from './resolve-modules.mjs';
+export { default as toAbsoluteSpecifier } from './to-absolute-specifier.mjs';
+export { default as toBareSpecifier } from './to-bare-specifier.mjs';
+export { default as toDataURL } from './to-data-url.mjs';
+export { default as toRelativeSpecifier } from './to-relative-specifier.mjs';

package/dist/lib/index.mjs

@@ -0,0 +1,34 @@
+import { default as default2 } from "./detect-syntax.mjs";
+import { default as default3 } from "./extract-statements.mjs";
+import { default as default4 } from "./find-dynamic-imports.mjs";
+import { default as default5 } from "./find-exports.mjs";
+import { default as default6 } from "./find-requires.mjs";
+import { default as default7 } from "./find-static-imports.mjs";
+import { default as default8 } from "./has-cjs-syntax.mjs";
+import { default as default9 } from "./has-esm-syntax.mjs";
+import { default as default10 } from "./resolve-alias.mjs";
+import { default as default11 } from "./resolve-aliases.mjs";
+import { default as default12 } from "./resolve-module.mjs";
+import { default as default13 } from "./resolve-modules.mjs";
+import { default as default14 } from "./to-absolute-specifier.mjs";
+import { default as default15 } from "./to-bare-specifier.mjs";
+import { default as default16 } from "./to-data-url.mjs";
+import { default as default17 } from "./to-relative-specifier.mjs";
+export {
+  default2 as detectSyntax,
+  default3 as extractStatements,
+  default4 as findDynamicImports,
+  default5 as findExports,
+  default6 as findRequires,
+  default7 as findStaticImports,
+  default8 as hasCJSSyntax,
+  default9 as hasESMSyntax,
+  default10 as resolveAlias,
+  default11 as resolveAliases,
+  default12 as resolveModule,
+  default13 as resolveModules,
+  default14 as toAbsoluteSpecifier,
+  default15 as toBareSpecifier,
+  default16 as toDataURL,
+  default17 as toRelativeSpecifier
+};

package/dist/lib/resolve-alias.d.mts

@@ -0,0 +1,20 @@
+/**
+ * @file resolveAlias
+ * @module mlly/lib/resolveAlias
+ */
+import type { ResolveAliasOptions } from '../interfaces/index.mjs';
+/**
+ * Resolves a path alias in `specifier`; does nothing if a path match isn't
+ * found.
+ *
+ * If `options.tsconfig` is found, `options.baseUrl` and `options.paths` will
+ * be overridden with values from the config file.
+ *
+ * @see {@link ResolveAliasOptions}
+ *
+ * @param {string} specifier - Module specifier
+ * @param {ResolveAliasOptions} [options={}] - Resolve alias options
+ * @return {string} `specifier` unmodified or with path alias resolved
+ */
+declare const resolveAlias: (specifier: string, options?: ResolveAliasOptions) => string;
+export default resolveAlias;

package/dist/lib/resolve-alias.mjs

@@ -0,0 +1,41 @@
+import { RESOLVE_EXTENSIONS } from "../constants.mjs";
+import { getCompilerOptions } from "../internal/index.mjs";
+import { createMatchPath } from "tsconfig-paths";
+import upath from "upath";
+import toRelativeSpecifier from "./to-relative-specifier.mjs";
+const resolveAlias = (specifier, options = {}) => {
+  const {
+    extensions = RESOLVE_EXTENSIONS,
+    fileExists,
+    mainFields = ["main", "module"],
+    parent,
+    readFile,
+    tsconfig
+  } = options;
+  let { baseUrl = process.cwd(), paths = {} } = options;
+  if (tsconfig) {
+    const { baseUrl: b = ".", paths: p = paths } = getCompilerOptions(tsconfig);
+    baseUrl = upath.resolve(upath.dirname(tsconfig), b);
+    paths = p;
+  }
+  const matcher = createMatchPath(
+    baseUrl,
+    paths,
+    mainFields,
+    baseUrl.length > 0
+  );
+  let match = matcher(
+    specifier,
+    readFile,
+    fileExists,
+    extensions
+  );
+  if (!match)
+    return specifier;
+  match = /\/node_modules\//.test(match) ? match.replace(/.+\/node_modules\//, "") : parent ? toRelativeSpecifier(match, parent) : match;
+  return match;
+};
+var resolve_alias_default = resolveAlias;
+export {
+  resolve_alias_default as default
+};

package/dist/lib/resolve-aliases.d.mts

@@ -0,0 +1,17 @@
+/**
+ * @file resolveAliases
+ * @module mlly/lib/resolveAliases
+ */
+import type { ResolveAliasOptions } from '../interfaces/index.mjs';
+/**
+ * Resolves path aliases in `code`.
+ *
+ * @see {@link ResolveAliasOptions}
+ * @see {@link resolveAlias}
+ *
+ * @param {string} code - Code containing path aliases
+ * @param {ResolveAliasOptions} [options={}] - Resolve alias options
+ * @return {string} `code` unmodified or with path aliases resolved
+ */
+declare const resolveAliases: (code: string, options?: ResolveAliasOptions) => string;
+export default resolveAliases;

package/dist/lib/resolve-aliases.mjs

@@ -0,0 +1,34 @@
+import { getCompilerOptions } from "../internal/index.mjs";
+import upath from "upath";
+import extractStatements from "./extract-statements.mjs";
+import resolveAlias from "./resolve-alias.mjs";
+const resolveAliases = (code, options = {}) => {
+  const { tsconfig } = options;
+  let { baseUrl = process.cwd(), paths = {} } = options;
+  if (tsconfig) {
+    const { baseUrl: b = ".", paths: p = paths } = getCompilerOptions(tsconfig);
+    baseUrl = upath.resolve(upath.dirname(tsconfig), b);
+    paths = p;
+  }
+  for (const statement of extractStatements(code)) {
+    if (!statement.specifier)
+      continue;
+    const specifier = resolveAlias(statement.specifier, {
+      ...options,
+      baseUrl,
+      paths,
+      tsconfig: void 0
+    });
+    if (specifier === statement.specifier)
+      continue;
+    code = code.replace(
+      statement.code,
+      statement.code.replace(statement.specifier, specifier)
+    );
+  }
+  return code;
+};
+var resolve_aliases_default = resolveAliases;
+export {
+  resolve_aliases_default as default
+};

package/dist/lib/resolve-module.d.mts

@@ -0,0 +1,31 @@
+/**
+ * @file resolveModule
+ * @module mlly/lib/resolveModule
+ */
+import type { ResolveOptions } from '../interfaces/index.mjs';
+/**
+ * Resolves `specifier` according to the [ESM Resolver algorithm][1], mostly 😉.
+ *
+ * Adds support for:
+ *
+ * - Resolving without file extensions and explicit `/index` usage
+ * - Resolving `@types/*` with **and** without explicit `@types/*` usage
+ * - Converting resolved modules into [bare][2] and [relative][3] specifiers
+ * - Removing and replacing file extensions
+ *
+ * [1]: https://nodejs.org/api/esm.html#esm_resolver_algorithm
+ * [2]: {@link toBareSpecifier}
+ * [3]: {@link toRelativeSpecifier}
+ *
+ * @see {@link ResolveOptions}
+ * @see {@link ErrnoException}
+ *
+ * @async
+ *
+ * @param {string} specifier - Module specifier to resolve
+ * @param {ResolveOptions} [options={}] - Resolve options
+ * @return {Promise<string>} Resolved module
+ * @throws {ErrnoException}
+ */
+declare const resolveModule: (specifier: string, options?: ResolveOptions) => Promise<string>;
+export default resolveModule;

package/dist/lib/resolve-module.mjs

@@ -0,0 +1,74 @@
+import { CONDITIONS, RESOLVE_EXTENSIONS } from "../constants.mjs";
+import isBuiltin from "@flex-development/is-builtin";
+import { moduleResolve } from "import-meta-resolve";
+import { pathToFileURL, URL } from "node:url";
+import upath from "upath";
+import toBareSpecifier from "./to-bare-specifier.mjs";
+import toRelativeSpecifier from "./to-relative-specifier.mjs";
+const resolveModule = async (specifier, options = {}) => {
+  const {
+    conditions = CONDITIONS,
+    ext,
+    extensions = RESOLVE_EXTENSIONS,
+    parent = import.meta.url,
+    preserveSymlinks = false,
+    ...opts
+  } = options;
+  const base = typeof parent === "string" ? parent.startsWith("file:") ? new URL(parent) : pathToFileURL(parent) : parent;
+  const tries = isBuiltin(specifier) || /^(?:data|https?):/.test(specifier) ? [] : extensions.flatMap((ext2) => {
+    return [specifier + ext2, specifier + "/index" + ext2].flatMap(($try) => {
+      return [$try, "@types/" + $try];
+    });
+  });
+  tries.unshift(specifier);
+  const ignore = /* @__PURE__ */ new Set([
+    "ERR_MODULE_NOT_FOUND",
+    "ERR_PACKAGE_PATH_NOT_EXPORTED",
+    "ERR_UNSUPPORTED_DIR_IMPORT"
+  ]);
+  let error;
+  let resolved;
+  for (const id of tries) {
+    try {
+      resolved = moduleResolve(
+        id,
+        base,
+        new Set(conditions),
+        preserveSymlinks
+      ).href;
+    } catch (e) {
+      if (id === specifier)
+        error = e;
+      if (ignore.has(e.code))
+        continue;
+      throw e;
+    }
+    if (resolved)
+      break;
+  }
+  if (!resolved)
+    throw error;
+  if (isBuiltin(resolved) || /^(?:data|https?):/.test(resolved))
+    return resolved;
+  const type = typeof opts.type === "function" ? await opts.type(resolved) : opts.type ?? "absolute";
+  if (type === "bare")
+    resolved = await toBareSpecifier(resolved, conditions);
+  if (type === "relative")
+    resolved = toRelativeSpecifier(resolved, parent);
+  if (ext !== void 0) {
+    if (ext === false) {
+      resolved = upath.removeExt(resolved, upath.extname(resolved));
+    } else if (type === "relative") {
+      resolved = upath.changeExt(
+        resolved,
+        typeof ext === "function" ? await ext(specifier, resolved) : ext
+      );
+    }
+    resolved = resolved.replace(/\/index$/, "");
+  }
+  return resolved;
+};
+var resolve_module_default = resolveModule;
+export {
+  resolve_module_default as default
+};

package/dist/lib/resolve-modules.d.mts

@@ -0,0 +1,19 @@
+/**
+ * @file resolveModules
+ * @module mlly/lib/resolveModules
+ */
+import type { ResolveOptions } from '../interfaces/index.mjs';
+/**
+ * Resolves all modules in `code`.
+ *
+ * @see {@link ResolveOptions}
+ * @see {@link resolveModule}
+ *
+ * @async
+ *
+ * @param {string} code - Code containing module specifiers
+ * @param {ResolveOptions} [options={}] - Resolve options
+ * @return {Promise<string>} `code` with modules resolved
+ */
+declare const resolveModules: (code: string, options?: ResolveOptions) => Promise<string>;
+export default resolveModules;

package/dist/lib/resolve-modules.mjs

@@ -0,0 +1,29 @@
+import upath from "upath";
+import extractStatements from "./extract-statements.mjs";
+import resolveModule from "./resolve-module.mjs";
+const resolveModules = async (code, options = {}) => {
+  for (const statement of extractStatements(code)) {
+    if (!statement.specifier)
+      continue;
+    if (statement.specifier_type === "dynamic")
+      continue;
+    const type = (resolved) => {
+      return upath.isAbsolute(statement.specifier) || statement.specifier.startsWith("file:") ? "absolute" : /\/node_modules\//.test(resolved) ? "bare" : "relative";
+    };
+    code = code.replace(
+      statement.code,
+      statement.code.replace(
+        statement.specifier,
+        await resolveModule(statement.specifier, {
+          ...options,
+          type: options.type ?? type
+        })
+      )
+    );
+  }
+  return code;
+};
+var resolve_modules_default = resolveModules;
+export {
+  resolve_modules_default as default
+};

package/dist/lib/to-absolute-specifier.d.mts

@@ -0,0 +1,22 @@
+/**
+ * @file toAbsoluteSpecifier
+ * @module mlly/lib/toAbsoluteSpecifier
+ */
+import { URL } from 'node:url';
+/**
+ * Converts `specifier` into an absolute specifier.
+ *
+ * ::: info
+ * The absolute specifier will only include a file extension if `specifier`
+ * includes a file extension.
+ * :::
+ *
+ * @see {@link URL}
+ * @see https://nodejs.org/api/esm.html#terminology
+ *
+ * @param {URL | string} specifier - Module specifier to convert
+ * @param {URL | string} [cwd=process.cwd()] - Current working directory
+ * @return {string} `specifier` as absolute specifier (file url)
+ */
+declare const toAbsoluteSpecifier: (specifier: URL | string, cwd?: URL | string) => string;
+export default toAbsoluteSpecifier;

package/dist/lib/to-absolute-specifier.mjs

@@ -0,0 +1,20 @@
+import { fileURLToPath, pathToFileURL, URL } from "node:url";
+import upath from "upath";
+const toAbsoluteSpecifier = (specifier, cwd = process.cwd()) => {
+  if (cwd instanceof URL)
+    cwd = cwd.href;
+  if (specifier instanceof URL)
+    specifier = specifier.href;
+  if (cwd.startsWith("file:"))
+    cwd = fileURLToPath(cwd);
+  if (specifier.startsWith("file:"))
+    specifier = fileURLToPath(specifier);
+  if (!upath.isAbsolute(specifier))
+    specifier = upath.resolve(cwd, specifier);
+  cwd = pathToFileURL(cwd).href.replace(/\/$/, "") + "/";
+  return new URL(specifier, cwd).href;
+};
+var to_absolute_specifier_default = toAbsoluteSpecifier;
+export {
+  to_absolute_specifier_default as default
+};

package/dist/lib/to-bare-specifier.d.mts

@@ -0,0 +1,28 @@
+/**
+ * @file toBareSpecifier
+ * @module mlly/lib/toBareSpecifier
+ */
+import type { ResolveOptions } from '../interfaces/index.mjs';
+import { URL } from 'node:url';
+/**
+ * Converts `specifier` into a bare specifier.
+ *
+ * ::: info
+ * The bare specifier will only include a file extension if `specifier` includes
+ * a file extension.
+ * :::
+ *
+ * @see {@link CONDITIONS}
+ * @see {@link URL}
+ * @see {@link ErrnoException}
+ * @see https://nodejs.org/api/esm.html#terminology
+ *
+ * @async
+ *
+ * @param {URL | string} specifier - File url or path to convert
+ * @param {ResolveOptions['conditions']} [conditions=CONDITIONS] - Conditions
+ * @return {string} `specifier` as bare specifier
+ * @throws {ErrnoException}
+ */
+declare const toBareSpecifier: (specifier: URL | string, conditions?: ResolveOptions['conditions']) => Promise<string>;
+export default toBareSpecifier;

package/dist/lib/to-bare-specifier.mjs

@@ -0,0 +1,78 @@
+import { CONDITIONS } from "../constants.mjs";
+import isBuiltin from "@flex-development/is-builtin";
+import { isNIL } from "@flex-development/tutils";
+import { codes as errors } from "import-meta-resolve/lib/errors.js";
+import {
+  findEntryInExports,
+  findPathInExports,
+  parseModuleId
+} from "node-package-exports";
+import { fileURLToPath, URL } from "node:url";
+import { readPackageUp } from "read-pkg-up";
+import upath from "upath";
+const toBareSpecifier = async (specifier, conditions = CONDITIONS) => {
+  if (specifier instanceof URL)
+    specifier = specifier.href;
+  if (specifier.startsWith("file:"))
+    specifier = fileURLToPath(specifier);
+  if (isBuiltin(specifier))
+    return specifier;
+  const pkg = await readPackageUp({
+    cwd: specifier,
+    normalize: false
+  });
+  if (!pkg) {
+    const pkgerror = "- package.json not found";
+    throw new errors.ERR_INVALID_PACKAGE_CONFIG(pkgerror, `'${specifier}'`, "");
+  }
+  const normalize = (p) => {
+    return upath.format({
+      base: "",
+      dir: upath.dirname(p),
+      ext: "",
+      name: upath.basename(p, upath.extname(p)),
+      root: ""
+    }).replace(/^(\w)/, "./$1");
+  };
+  const {
+    name,
+    path,
+    raw: bare
+  } = parseModuleId(specifier.replace(/.*node_modules\//, ""));
+  if (name.startsWith("@types"))
+    return name.replace(/^@types\/(\w+)$/g, "$1");
+  const { exports } = pkg.packageJson;
+  if (isNIL(exports)) {
+    const { main = "", types = "" } = pkg.packageJson;
+    if (bare === name || path === main || path === types)
+      return name;
+    if ([normalize(main), normalize(types)].includes(normalize(path))) {
+      return name;
+    }
+    return bare;
+  }
+  if (path === findEntryInExports(exports, [...conditions]))
+    return name;
+  const { dir } = upath.parse(path.replace(/^\.\//, ""));
+  const tries = new Set(
+    [
+      path || ".",
+      ...dir.split("/").map((seg) => "./" + (path.split(seg + "/")[1] ?? ""))
+    ].map((trypath) => /^\.\/index(?:\..*)?$/.test(trypath) ? "." : trypath).filter((trypath) => trypath === "." || trypath.length > 2)
+  );
+  for (const trypath of tries) {
+    const exportpath = findPathInExports(trypath, exports, [
+      ...conditions
+    ]);
+    if (exportpath)
+      return upath.join(name, trypath);
+  }
+  throw new errors.ERR_PACKAGE_PATH_NOT_EXPORTED(
+    upath.dirname(pkg.path) + "/",
+    [...tries][0]
+  );
+};
+var to_bare_specifier_default = toBareSpecifier;
+export {
+  to_bare_specifier_default as default
+};

package/dist/lib/to-data-url.d.mts

@@ -0,0 +1,29 @@
+/**
+ * @file toDataURL
+ * @module mlly/lib/toDataURL
+ */
+import type { MIMEType } from '../types/index.mjs';
+/**
+ * Converts `code` into a [`data:` URL][1] using `base64` encoding.
+ *
+ * ::: tip
+ * `data:` URLs only resolve [bare specifiers][2] for builtin modules and
+ * [absolute specifiers][2].
+ *
+ * Call [`await resolveModules(code)`][3] to ensure all specifiers are absolute
+ * or bare.
+ * :::
+ *
+ * [1]: https://developer.mozilla.org/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
+ * [2]: https://nodejs.org/api/esm.html#terminology
+ * [3]: {@link ./resolve-modules.ts}
+ *
+ * @see {@link MIMEType}
+ * @see https://nodejs.org/api/esm.html#esm_data_imports
+ *
+ * @param {string} code - Code to convert
+ * @param {MIMEType} [mime='text/javascript'] - MIME type
+ * @return {string} `code` as `data:` URL
+ */
+declare const toDataURL: (code: string, mime?: MIMEType) => string;
+export default toDataURL;

package/dist/lib/to-data-url.mjs

@@ -0,0 +1,7 @@
+const toDataURL = (code, mime = "text/javascript") => {
+  return `data:${mime};base64,${Buffer.from(code).toString("base64")}`;
+};
+var to_data_url_default = toDataURL;
+export {
+  to_data_url_default as default
+};

package/dist/lib/to-relative-specifier.d.mts

@@ -0,0 +1,22 @@
+/**
+ * @file toRelativeSpecifier
+ * @module mlly/lib/toRelativeSpecifier
+ */
+import { URL } from 'node:url';
+/**
+ * Converts `specifier` into a relative specifier.
+ *
+ * ::: info
+ * The relative specifier will only include a file extension if `specifier`
+ * includes a file extension.
+ * :::
+ *
+ * @see {@link URL}
+ * @see https://nodejs.org/api/esm.html#terminology
+ *
+ * @param {URL | string} specifier - Module specifier to convert
+ * @param {URL | string} parent - Parent module URL or path to resolve from
+ * @return {string} `specifier` as relative specifier
+ */
+declare const toRelativeSpecifier: (specifier: URL | string, parent: URL | string) => string;
+export default toRelativeSpecifier;