@flex-development/mlly 1.0.0-alpha.17 → 1.0.0-alpha.19

package/dist/interfaces/protocol-map.d.mts

@@ -0,0 +1,35 @@
+/**
+ * @file Interfaces - ProtocolMap
+ * @module mlly/interfaces/ProtocolMap
+ */
+/**
+ * URL protocol registry.
+ *
+ * @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
+ */
+interface ProtocolMap {
+    blob: 'blob:';
+    content: 'content:';
+    cvs: 'cvs:';
+    data: 'data:';
+    dns: 'dns:';
+    file: 'file:';
+    fish: 'fish:';
+    ftp: 'ftp:';
+    git: 'git:';
+    http: 'http:';
+    https: 'https:';
+    mvn: 'mvn:';
+    node: 'node:';
+    redis: 'redis:';
+    sftp: 'sftp:';
+    ssh: 'ssh:';
+    svn: 'svn:';
+    urn: 'urn:';
+    viewSource: 'view-source:';
+    ws: 'ws:';
+    wss: 'wss:';
+}
+export type { ProtocolMap as default };

package/dist/interfaces/stats.d.mts

@@ -0,0 +1,28 @@
+/**
+ * @file Interfaces - Stats
+ * @module mlly/interfaces/Stats
+ */
+/**
+ * File system metadata.
+ */
+interface Stats {
+    /**
+     * Check if the stats object describes a file system directory.
+     *
+     * @this {void}
+     *
+     * @return {boolean}
+     *  `true` if stats object describes directory, `false` otherwise
+     */
+    isDirectory(this: void): boolean;
+    /**
+     * Check if the stats object describes a regular file.
+     *
+     * @this {void}
+     *
+     * @return {boolean}
+     *  `true` if stats object describes regular file, `false` otherwise
+     */
+    isFile(this: void): boolean;
+}
+export type { Stats as default };

package/dist/internal/chars.mjs

@@ -0,0 +1,11 @@
+var chars = /* @__PURE__ */ ((chars2) => {
+  chars2["asterisk"] = "*";
+  chars2["at"] = "@";
+  chars2["empty"] = "";
+  chars2["hash"] = "#";
+  return chars2;
+})(chars || {});
+var chars_default = chars;
+export {
+  chars_default as default
+};

package/dist/internal/check-invalid-segments.mjs

@@ -0,0 +1,19 @@
+import chars from "#internal/chars";
+function checkInvalidSegments(str) {
+  const separator = /\/|\\/;
+  const segments = str.startsWith("./") ? str.slice(2).split(separator) : str.split(separator);
+  const checks = [
+    /^(\.|%2e)(\.|%2e)?/i,
+    /^(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53)/i
+  ];
+  for (const segment of segments) {
+    if (segment === chars.empty || checks.some((check) => check.test(segment))) {
+      return true;
+    }
+  }
+  return false;
+}
+var check_invalid_segments_default = checkInvalidSegments;
+export {
+  check_invalid_segments_default as default
+};

package/dist/internal/fs.browser.mjs

@@ -0,0 +1,36 @@
+const fs = {
+  /**
+   * Get the contents of a file.
+   *
+   * @return {never}
+   *  Never; not implemented
+   * @throws {Error}
+   */
+  readFile() {
+    throw new Error("[readFile] not implemented");
+  },
+  /**
+   * Get the resolved pathname of a file.
+   *
+   * @return {never}
+   *  Never; not implemented
+   * @throws {Error}
+   */
+  realpath() {
+    throw new Error("[realpath] not implemented");
+  },
+  /**
+   * Get information about a file.
+   *
+   * @return {never}
+   *  Never; not implemented
+   * @throws {Error}
+   */
+  stat() {
+    throw new Error("[stat] not implemented");
+  }
+};
+var fs_browser_default = fs;
+export {
+  fs_browser_default as default
+};

package/dist/internal/fs.d.mts

@@ -0,0 +1,7 @@
+declare module '#internal/fs' {
+  import type { FileSystem } from '@flex-development/mlly'
+
+  const fs: FileSystem
+
+  export default fs
+}

package/dist/internal/invalid-package-target.mjs

@@ -0,0 +1,18 @@
+import chars from "#internal/chars";
+import {
+  ERR_INVALID_PACKAGE_TARGET
+} from "@flex-development/errnode";
+import { fileURLToPath } from "@flex-development/pathe";
+function invalidPackageTarget(packageUrl, subpath, target, isImports, parent) {
+  return new ERR_INVALID_PACKAGE_TARGET(
+    fileURLToPath(packageUrl),
+    subpath,
+    typeof target === "object" && target !== null ? JSON.stringify(target, null, "") : String(target) + (typeof target === "bigint" ? "n" : chars.empty),
+    isImports,
+    parent && fileURLToPath(parent)
+  );
+}
+var invalid_package_target_default = invalidPackageTarget;
+export {
+  invalid_package_target_default as default
+};

package/dist/internal/invalid-subpath.mjs

@@ -0,0 +1,16 @@
+import chars from "#internal/chars";
+import {
+  ERR_INVALID_MODULE_SPECIFIER
+} from "@flex-development/errnode";
+import { fileURLToPath } from "@flex-development/pathe";
+function invalidSubpath(subpath, patternMatch, packageUrl, isImports, parent) {
+  return new ERR_INVALID_MODULE_SPECIFIER(
+    subpath.replace(chars.asterisk, () => patternMatch),
+    `request is not a valid match in pattern "${subpath}" for the "${isImports ? "imports" : "exports"}" resolution of ${fileURLToPath(new URL("package.json", packageUrl))}`,
+    parent && fileURLToPath(parent)
+  );
+}
+var invalid_subpath_default = invalidSubpath;
+export {
+  invalid_subpath_default as default
+};

package/dist/internal/process.browser.mjs

@@ -0,0 +1,7 @@
+var process_browser_default = {
+  browser: true,
+  platform: "browser"
+};
+export {
+  process_browser_default as default
+};

package/dist/internal/process.d.mts

@@ -0,0 +1,4 @@
+declare module '#internal/process' {
+  const process: NodeJS.Process
+  export default process
+}

package/dist/lib/can-parse-url.d.mts

@@ -0,0 +1,21 @@
+/**
+ * @file canParseUrl
+ * @module mlly/lib/canParseUrl
+ */
+/**
+ * Check if `input` can be parsed to a {@linkcode URL}.
+ *
+ * > 👉 **Note**: If `input` is relative, `base` is required. If `input` is
+ * > absolute, `base` is ignored.
+ *
+ * @see {@linkcode ModuleId}
+ *
+ * @param {unknown} input
+ *  The absolute or relative input URL to parse
+ * @param {unknown} [base]
+ *  Base URL to resolve against if `input` is not absolute
+ * @return {boolean}
+ *  `true` if `input` can be parsed to a `URL`
+ */
+declare function canParseUrl(input: unknown, base?: unknown): boolean;
+export default canParseUrl;

package/dist/lib/can-parse-url.mjs

@@ -0,0 +1,12 @@
+function canParseUrl(input, base) {
+  try {
+    new URL(input, base ?? void 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var can_parse_url_default = canParseUrl;
+export {
+  can_parse_url_default as default
+};

package/dist/lib/cwd.d.mts

@@ -0,0 +1,12 @@
+/**
+ * @file cwd
+ * @module mlly/lib/cwd
+ */
+/**
+ * Get the URL of the current working directory.
+ *
+ * @return {URL}
+ *  URL of current working directory
+ */
+declare function cwd(): URL;
+export default cwd;

package/dist/lib/cwd.mjs

@@ -0,0 +1,8 @@
+import pathe from "@flex-development/pathe";
+function cwd() {
+  return pathe.pathToFileURL(pathe.cwd() + pathe.sep);
+}
+var cwd_default = cwd;
+export {
+  cwd_default as default
+};

package/dist/lib/default-conditions.d.mts

@@ -0,0 +1,15 @@
+/**
+ * @file defaultConditions
+ * @module mlly/lib/defaultConditions
+ */
+import type { Condition } from '@flex-development/pkg-types';
+/**
+ * Default conditions.
+ *
+ * @see {@linkcode Condition}
+ * @see https://nodejs.org/api/packages.html#conditional-exports
+ *
+ * @const {Set<Condition>} defaultConditions
+ */
+declare const defaultConditions: Set<Condition>;
+export default defaultConditions;

package/dist/lib/default-conditions.mjs

@@ -0,0 +1,5 @@
+const defaultConditions = /* @__PURE__ */ new Set(["node", "import"]);
+var default_conditions_default = defaultConditions;
+export {
+  default_conditions_default as default
+};

package/dist/lib/default-extensions.d.mts

@@ -0,0 +1,14 @@
+/**
+ * @file defaultExtensions
+ * @module mlly/lib/defaultExtensions
+ */
+import type { Ext } from '@flex-development/pathe';
+/**
+ * Default resolvable file extensions.
+ *
+ * @see {@linkcode Ext}
+ *
+ * @const {Set<Ext>} defaultExtensions
+ */
+declare const defaultExtensions: Set<Ext>;
+export default defaultExtensions;

package/dist/lib/default-extensions.mjs

@@ -0,0 +1,21 @@
+const defaultExtensions = /* @__PURE__ */ new Set([
+  ".mjs",
+  ".mts",
+  ".cjs",
+  ".cts",
+  ".js",
+  ".ts",
+  ".jsx",
+  ".tsx",
+  ".css",
+  ".json",
+  ".node",
+  ".wasm",
+  ".d.mts",
+  ".d.cts",
+  ".d.ts"
+]);
+var default_extensions_default = defaultExtensions;
+export {
+  default_extensions_default as default
+};

package/dist/lib/default-main-fields.d.mts

@@ -0,0 +1,14 @@
+/**
+ * @file defaultMainFields
+ * @module mlly/lib/defaultMainFields
+ */
+import type { MainField } from '@flex-development/mlly';
+/**
+ * Default main fields.
+ *
+ * @see {@linkcode MainField}
+ *
+ * @const {Set<MainField>} defaultMainFields
+ */
+declare const defaultMainFields: Set<MainField>;
+export default defaultMainFields;

package/dist/lib/default-main-fields.mjs

@@ -0,0 +1,5 @@
+const defaultMainFields = /* @__PURE__ */ new Set(["main"]);
+var default_main_fields_default = defaultMainFields;
+export {
+  default_main_fields_default as default
+};

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

@@ -0,0 +1,16 @@
+/**
+ * @file extensionFormatMap
+ * @module mlly/lib/extensionFormatMap
+ */
+import type { ModuleFormat } from '@flex-development/mlly';
+import type { Ext } from '@flex-development/pathe';
+/**
+ * File extension to module format map.
+ *
+ * @see {@linkcode Ext}
+ * @see {@linkcode ModuleFormat}
+ *
+ * @const {Map<Ext, ModuleFormat>} extensionFormatMap
+ */
+declare const extensionFormatMap: Map<Ext, ModuleFormat>;
+export default extensionFormatMap;

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

@@ -0,0 +1,21 @@
+import formats from "#lib/formats";
+const extensionFormatMap = /* @__PURE__ */ new Map([
+  [".cjs", formats.commonjs],
+  [".cts", formats.cts],
+  [".d.cts", formats.cts],
+  [".d.mts", formats.mts],
+  [".d.ts", formats.mts],
+  [".js", formats.module],
+  [".json", formats.json],
+  [".jsx", formats.module],
+  [".mjs", formats.module],
+  [".mts", formats.mts],
+  [".node", formats.commonjs],
+  [".ts", formats.mts],
+  [".tsx", formats.mts],
+  [".wasm", formats.wasm]
+]);
+var extension_format_map_default = extensionFormatMap;
+export {
+  extension_format_map_default as default
+};

package/dist/lib/formats.d.mts

@@ -0,0 +1,21 @@
+/**
+ * @file formats
+ * @module mlly/lib/formats
+ */
+/**
+ * Module formats.
+ *
+ * @see {@linkcode ModuleFormat}
+ *
+ * @enum {ModuleFormat}
+ */
+declare enum formats {
+    builtin = "builtin",
+    commonjs = "commonjs",
+    cts = "commonjs-typescript",
+    json = "json",
+    module = "module",
+    mts = "module-typescript",
+    wasm = "wasm"
+}
+export default formats;

package/dist/lib/formats.mjs

@@ -0,0 +1,14 @@
+var formats = /* @__PURE__ */ ((formats2) => {
+  formats2["builtin"] = "builtin";
+  formats2["commonjs"] = "commonjs";
+  formats2["cts"] = "commonjs-typescript";
+  formats2["json"] = "json";
+  formats2["module"] = "module";
+  formats2["mts"] = "module-typescript";
+  formats2["wasm"] = "wasm";
+  return formats2;
+})(formats || {});
+var formats_default = formats;
+export {
+  formats_default as default
+};

package/dist/lib/get-source.d.mts

@@ -0,0 +1,26 @@
+/**
+ * @file getSource
+ * @module mlly/lib/getSource
+ */
+import type { GetSourceOptions, ModuleId } from '@flex-development/mlly';
+export default getSource;
+/**
+ * Get the source code for `id`.
+ *
+ * @see {@linkcode ErrUnsupportedEsmUrlScheme}
+ * @see {@linkcode GetSourceOptions}
+ * @see {@linkcode ModuleId}
+ *
+ * @async
+ *
+ * @this {void}
+ *
+ * @param {ModuleId} id
+ *  Module id to handle
+ * @param {GetSourceOptions | null | undefined} [options]
+ *  Source code retrieval options
+ * @return {Promise<string | null | undefined>}
+ *  Source code for `id`
+ * @throws {ErrUnsupportedEsmUrlScheme}
+ */
+declare function getSource(this: void, id: ModuleId, options?: GetSourceOptions | null | undefined): Promise<string | null | undefined>;

package/dist/lib/get-source.mjs

@@ -0,0 +1,70 @@
+import fs from "#internal/fs";
+import process from "#internal/process";
+import isFile from "#lib/is-file";
+import toUrl from "#lib/to-url";
+import {
+  ERR_UNSUPPORTED_ESM_URL_SCHEME
+} from "@flex-development/errnode";
+import { ok } from "devlop";
+var get_source_default = getSource;
+async function getSource(id, options) {
+  const context = {
+    ...options,
+    error: false,
+    fs: options?.fs ?? fs,
+    handlers: {
+      "data:": data,
+      "file:": file,
+      "http:": https,
+      "https:": https,
+      "node:": node,
+      ...options?.handlers
+    },
+    req: { ...options?.req },
+    schemes: new Set(
+      options?.schemes ? [...options.schemes] : ["data", "file", "http", "https", "node"]
+    )
+  };
+  const url = toUrl(id);
+  const handle = context.handlers[url.protocol];
+  let code;
+  if (handle) {
+    code = await handle.call(context, url);
+  } else {
+    context.error = true;
+  }
+  if (context.error && !context.ignoreErrors) {
+    throw new ERR_UNSUPPORTED_ESM_URL_SCHEME(
+      url,
+      [...context.schemes],
+      process.platform === "win32"
+    );
+  }
+  if (code !== null && code !== void 0) code = String(code);
+  return code;
+}
+function data(url) {
+  const [mime, data2 = ""] = url.pathname.split(",");
+  ok(url.protocol === "data:", "expected `data:` URL");
+  ok(mime !== void 0, "expected `mime` to be a string");
+  return Buffer.from(
+    decodeURIComponent(data2),
+    mime.endsWith("base64") ? "base64" : "utf8"
+  );
+}
+async function file(url) {
+  ok(url.protocol === "file:", "expected `file:` URL");
+  let code = null;
+  if (await isFile(url, this.fs)) code = await this.fs.readFile(url);
+  return code;
+}
+async function https(url) {
+  ok(/^https?:$/.test(url.protocol), "expected `http:` or `https:` URL");
+  return (await fetch(url.href, this.req)).text();
+}
+function node(url) {
+  return void ok(url.protocol === "node:", "expected `node:` URL");
+}
+export {
+  get_source_default as default
+};

package/dist/lib/index.d.mts

@@ -0,0 +1,40 @@
+/**
+ * @file Entry Point - Library
+ * @module mlly/lib
+ *
+ * @todo `detectModuleSyntax` (esast integration)
+ * @todo `findDynamicImports` (esast integration)
+ * @todo `findExports` (esast integration)
+ * @todo `findImports` (esast integration)
+ * @todo `findRequires` (esast integration)
+ * @todo `findSpecifiers` (esast integration)
+ * @todo `findStaticImports` (esast integration)
+ * @todo `resolveAliases` (esast integration)
+ * @todo `resolveModules` (esast integration)
+ */
+export { default as canParseUrl } from '#lib/can-parse-url';
+export { default as cwd } from '#lib/cwd';
+export { default as defaultConditions } from '#lib/default-conditions';
+export { default as defaultExtensions } from '#lib/default-extensions';
+export { default as defaultMainFields } from '#lib/default-main-fields';
+export { default as extensionFormatMap } from '#lib/extension-format-map';
+export { default as formats } from '#lib/formats';
+export { default as getSource } from '#lib/get-source';
+export { default as isAbsoluteSpecifier } from '#lib/is-absolute-specifier';
+export { default as isArrayIndex } from '#lib/is-array-index';
+export { default as isBareSpecifier } from '#lib/is-bare-specifier';
+export { default as isDirectory } from '#lib/is-directory';
+export { default as isFile } from '#lib/is-file';
+export { default as isImportsSubpath } from '#lib/is-imports-subpath';
+export { default as isRelativeSpecifier } from '#lib/is-relative-specifier';
+export { default as lookupPackageScope } from '#lib/lookup-package-scope';
+export { default as patternKeyCompare } from '#lib/pattern-key-compare';
+export { default as patternMatch } from '#lib/pattern-match';
+export { default as readPackageJson } from '#lib/read-package-json';
+export { default as resolveAlias } from '#lib/resolve-alias';
+export { default as resolveModule } from '#lib/resolve-module';
+export * from '#lib/resolver';
+export * as resolver from '#lib/resolver';
+export { default as root } from '#lib/root';
+export { default as toRelativeSpecifier } from '#lib/to-relative-specifier';
+export { default as toUrl } from '#lib/to-url';

package/dist/lib/index.mjs

@@ -0,0 +1,53 @@
+import { default as default2 } from "#lib/can-parse-url";
+import { default as default3 } from "#lib/cwd";
+import { default as default4 } from "#lib/default-conditions";
+import { default as default5 } from "#lib/default-extensions";
+import { default as default6 } from "#lib/default-main-fields";
+import { default as default7 } from "#lib/extension-format-map";
+import { default as default8 } from "#lib/formats";
+import { default as default9 } from "#lib/get-source";
+import { default as default10 } from "#lib/is-absolute-specifier";
+import { default as default11 } from "#lib/is-array-index";
+import { default as default12 } from "#lib/is-bare-specifier";
+import { default as default13 } from "#lib/is-directory";
+import { default as default14 } from "#lib/is-file";
+import { default as default15 } from "#lib/is-imports-subpath";
+import { default as default16 } from "#lib/is-relative-specifier";
+import { default as default17 } from "#lib/lookup-package-scope";
+import { default as default18 } from "#lib/pattern-key-compare";
+import { default as default19 } from "#lib/pattern-match";
+import { default as default20 } from "#lib/read-package-json";
+import { default as default21 } from "#lib/resolve-alias";
+import { default as default22 } from "#lib/resolve-module";
+export * from "#lib/resolver";
+import * as resolver from "#lib/resolver";
+import { default as default23 } from "#lib/root";
+import { default as default24 } from "#lib/to-relative-specifier";
+import { default as default25 } from "#lib/to-url";
+export {
+  default2 as canParseUrl,
+  default3 as cwd,
+  default4 as defaultConditions,
+  default5 as defaultExtensions,
+  default6 as defaultMainFields,
+  default7 as extensionFormatMap,
+  default8 as formats,
+  default9 as getSource,
+  default10 as isAbsoluteSpecifier,
+  default11 as isArrayIndex,
+  default12 as isBareSpecifier,
+  default13 as isDirectory,
+  default14 as isFile,
+  default15 as isImportsSubpath,
+  default16 as isRelativeSpecifier,
+  default17 as lookupPackageScope,
+  default18 as patternKeyCompare,
+  default19 as patternMatch,
+  default20 as readPackageJson,
+  default21 as resolveAlias,
+  default22 as resolveModule,
+  resolver,
+  default23 as root,
+  default24 as toRelativeSpecifier,
+  default25 as toUrl
+};

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

@@ -0,0 +1,23 @@
+/**
+ * @file isAbsoluteSpecifier
+ * @module mlly/lib/isAbsoluteSpecifier
+ */
+import type { ModuleId } from '@flex-development/mlly';
+/**
+ * Check if `specifier` is an *absolute specifier*.
+ *
+ * ::: warning
+ * Only checks specifier syntax. Does **not** guarantee the specifier references
+ * a file that exists.
+ * :::
+ *
+ * @see {@linkcode ModuleId}
+ * @see https://nodejs.org/api/esm.html#terminology
+ *
+ * @param {ModuleId} specifier
+ *  Specifier to check
+ * @return {boolean}
+ *  `true` if `specifier` is absolute specifier, `false` otherwise
+ */
+declare function isAbsoluteSpecifier(specifier: ModuleId): boolean;
+export default isAbsoluteSpecifier;

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

@@ -0,0 +1,9 @@
+import canParseUrl from "#lib/can-parse-url";
+import pathe from "@flex-development/pathe";
+function isAbsoluteSpecifier(specifier) {
+  return typeof specifier === "string" ? specifier.startsWith("file:") ? canParseUrl(specifier) : pathe.isAbsolute(specifier) : specifier.protocol === "file:" && canParseUrl(specifier);
+}
+var is_absolute_specifier_default = isAbsoluteSpecifier;
+export {
+  is_absolute_specifier_default as default
+};

package/dist/lib/is-array-index.d.mts

@@ -0,0 +1,17 @@
+/**
+ * @file isArrayIndex
+ * @module mlly/lib/isArrayIndex
+ */
+import type { Numeric } from '@flex-development/mlly';
+/**
+ * Check if `value` is a valid array index.
+ *
+ * @see {@linkcode Numeric}
+ *
+ * @param {unknown} value
+ *  Key to check
+ * @return {value is Numeric}
+ *  `true` if `value` is valid array index, `false` otherwise
+ */
+declare function isArrayIndex(value: unknown): value is Numeric;
+export default isArrayIndex;