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

package/dist/utils/has-cjs-syntax.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/has-cjs-syntax.ts"],
+  "mappings": "AAKA,OAAO,oBAAoB;AAsB3B,MAAM,eAAe,CAAC,SAA0B;AAC9C,iBAAe,MAAM,MAAM;AAS3B,QAAM,mBACJ;AAEF,SAAO,CAAC,CAAC,KAAK,MAAM,gBAAgB;AACtC;AAEA,IAAO,yBAAQ;",
+  "names": []
+}

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

@@ -1,6 +1,6 @@
 /**
  * @file hasESMSyntax
- * @module mlly/lib/hasESMSyntax
+ * @module mlly/utils/hasESMSyntax
  */
 /**
  * Detects if `code` contains ESM syntax. Ignores matches in comments.
@@ -11,8 +11,11 @@
  * - `import` (default, dynamic, named, star)
  * - `import.meta.(env|resolve|url)`
  *
- * @param {string} code - Code to check
+ * @see https://regex101.com/r/xfreyy
+ *
+ * @param {string} code - Code to evaluate
  * @return {boolean} `true` if `code` contains esm syntax, `false` otherwise
+ * @throws {NodeError<TypeError>} If `code` is not a string
  */
 declare const hasESMSyntax: (code: string) => boolean;
 export default hasESMSyntax;

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

@@ -0,0 +1,11 @@
+import validateString from "../internal/validate-string.mjs";
+const hasESMSyntax = (code) => {
+  validateString(code, "code");
+  const ESM_SYNTAX_REGEX = /(?<!(?:\/\/|\*).*)((?:export|import)[\s\w*,{}]*(?=\sfrom)|export\b\s*(?:[*{]|async function|(?:abstract\s)?class|const|default|enum|function|interface|let|type|var)|await import|import\.meta\.(?:env(?:\.\w+)?|resolve|url))/gm;
+  return !!code.match(ESM_SYNTAX_REGEX);
+};
+var has_esm_syntax_default = hasESMSyntax;
+export {
+  has_esm_syntax_default as default
+};
+//# sourceMappingURL=has-esm-syntax.mjs.map

package/dist/utils/has-esm-syntax.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/has-esm-syntax.ts"],
+  "mappings": "AAKA,OAAO,oBAAoB;AAkB3B,MAAM,eAAe,CAAC,SAA0B;AAC9C,iBAAe,MAAM,MAAM;AAS3B,QAAM,mBACJ;AAEF,SAAO,CAAC,CAAC,KAAK,MAAM,gBAAgB;AACtC;AAEA,IAAO,yBAAQ;",
+  "names": []
+}

package/dist/utils/index.d.mts

@@ -0,0 +1,42 @@
+/**
+ * @file Utilities
+ * @module mlly/utils
+ */
+export { default as compareSubpaths } from './compare-subpaths.mjs';
+export { default as CONDITIONS } from './conditions.mjs';
+export { default as detectSyntax } from './detect-syntax.mjs';
+export { default as EXTENSION_FORMAT_MAP } from './extension-format-map.mjs';
+export { default as extractStatements } from './extract-statements.mjs';
+export { default as fillModules } from './fill-modules.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 findSubpath } from './find-subpath.mjs';
+export { default as getFormat } from './get-format.mjs';
+export { default as getSource } from './get-source.mjs';
+export { default as hasCJSSyntax } from './has-cjs-syntax.mjs';
+export { default as hasESMSyntax } from './has-esm-syntax.mjs';
+export { default as isAbsoluteSpecifier } from './is-absolute-specifier.mjs';
+export { default as isBareSpecifier } from './is-bare-specifier.mjs';
+export { default as isExportsSugar } from './is-exports-sugar.mjs';
+export { default as isRelativeSpecifier } from './is-relative-specifier.mjs';
+export { default as lookupPackageScope } from './lookup-package-scope.mjs';
+export { default as parseDataURL } from './parse-data-url.mjs';
+export { default as parseModuleId } from './parse-module-id.mjs';
+export { default as parseSubpath } from './parse-subpath.mjs';
+export { default as PATTERN_CHARACTER } from './pattern-character.mjs';
+export { default as readPackageJson } from './read-package-json.mjs';
+export { default as resolveAlias } from './resolve-alias.mjs';
+export { default as resolveAliases } from './resolve-aliases.mjs';
+export { default as RESOLVE_EXTENSIONS } from './resolve-extensions.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 toNodeURL } from './to-node-url.mjs';
+export { default as toRelativeSpecifier } from './to-relative-specifier.mjs';
+export { default as toURL } from './to-url.mjs';
+export { default as validateAssertions } from './validate-assertions.mjs';
+export { default as validateExports } from './validate-exports.mjs';

package/dist/utils/index.mjs

@@ -0,0 +1,79 @@
+import { default as default2 } from "./compare-subpaths.mjs";
+import { default as default3 } from "./conditions.mjs";
+import { default as default4 } from "./detect-syntax.mjs";
+import { default as default5 } from "./extension-format-map.mjs";
+import { default as default6 } from "./extract-statements.mjs";
+import { default as default7 } from "./fill-modules.mjs";
+import { default as default8 } from "./find-dynamic-imports.mjs";
+import { default as default9 } from "./find-exports.mjs";
+import { default as default10 } from "./find-requires.mjs";
+import { default as default11 } from "./find-static-imports.mjs";
+import { default as default12 } from "./find-subpath.mjs";
+import { default as default13 } from "./get-format.mjs";
+import { default as default14 } from "./get-source.mjs";
+import { default as default15 } from "./has-cjs-syntax.mjs";
+import { default as default16 } from "./has-esm-syntax.mjs";
+import { default as default17 } from "./is-absolute-specifier.mjs";
+import { default as default18 } from "./is-bare-specifier.mjs";
+import { default as default19 } from "./is-exports-sugar.mjs";
+import { default as default20 } from "./is-relative-specifier.mjs";
+import { default as default21 } from "./lookup-package-scope.mjs";
+import { default as default22 } from "./parse-data-url.mjs";
+import { default as default23 } from "./parse-module-id.mjs";
+import { default as default24 } from "./parse-subpath.mjs";
+import { default as default25 } from "./pattern-character.mjs";
+import { default as default26 } from "./read-package-json.mjs";
+import { default as default27 } from "./resolve-alias.mjs";
+import { default as default28 } from "./resolve-aliases.mjs";
+import { default as default29 } from "./resolve-extensions.mjs";
+import { default as default30 } from "./resolve-module.mjs";
+import { default as default31 } from "./resolve-modules.mjs";
+import { default as default32 } from "./to-absolute-specifier.mjs";
+import { default as default33 } from "./to-bare-specifier.mjs";
+import { default as default34 } from "./to-data-url.mjs";
+import { default as default35 } from "./to-node-url.mjs";
+import { default as default36 } from "./to-relative-specifier.mjs";
+import { default as default37 } from "./to-url.mjs";
+import { default as default38 } from "./validate-assertions.mjs";
+import { default as default39 } from "./validate-exports.mjs";
+export {
+  default3 as CONDITIONS,
+  default5 as EXTENSION_FORMAT_MAP,
+  default25 as PATTERN_CHARACTER,
+  default29 as RESOLVE_EXTENSIONS,
+  default2 as compareSubpaths,
+  default4 as detectSyntax,
+  default6 as extractStatements,
+  default7 as fillModules,
+  default8 as findDynamicImports,
+  default9 as findExports,
+  default10 as findRequires,
+  default11 as findStaticImports,
+  default12 as findSubpath,
+  default13 as getFormat,
+  default14 as getSource,
+  default15 as hasCJSSyntax,
+  default16 as hasESMSyntax,
+  default17 as isAbsoluteSpecifier,
+  default18 as isBareSpecifier,
+  default19 as isExportsSugar,
+  default20 as isRelativeSpecifier,
+  default21 as lookupPackageScope,
+  default22 as parseDataURL,
+  default23 as parseModuleId,
+  default24 as parseSubpath,
+  default26 as readPackageJson,
+  default27 as resolveAlias,
+  default28 as resolveAliases,
+  default30 as resolveModule,
+  default31 as resolveModules,
+  default32 as toAbsoluteSpecifier,
+  default33 as toBareSpecifier,
+  default34 as toDataURL,
+  default35 as toNodeURL,
+  default36 as toRelativeSpecifier,
+  default37 as toURL,
+  default38 as validateAssertions,
+  default39 as validateExports
+};
+//# sourceMappingURL=index.mjs.map

package/dist/utils/index.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/index.ts"],
+  "mappings": "AAKA,SAAoB,WAAXA,gBAAkC;AAC3C,SAAoB,WAAXA,gBAA6B;AACtC,SAAoB,WAAXA,gBAA+B;AACxC,SAAoB,WAAXA,gBAAuC;AAChD,SAAoB,WAAXA,gBAAoC;AAC7C,SAAoB,WAAXA,gBAA8B;AACvC,SAAoB,WAAXA,gBAAqC;AAC9C,SAAoB,WAAXA,gBAA8B;AACvC,SAAoB,WAAXA,iBAA+B;AACxC,SAAoB,WAAXA,iBAAoC;AAC7C,SAAoB,WAAXA,iBAA8B;AACvC,SAAoB,WAAXA,iBAA4B;AACrC,SAAoB,WAAXA,iBAA4B;AACrC,SAAoB,WAAXA,iBAA+B;AACxC,SAAoB,WAAXA,iBAA+B;AACxC,SAAoB,WAAXA,iBAAsC;AAC/C,SAAoB,WAAXA,iBAAkC;AAC3C,SAAoB,WAAXA,iBAAiC;AAC1C,SAAoB,WAAXA,iBAAsC;AAC/C,SAAoB,WAAXA,iBAAqC;AAC9C,SAAoB,WAAXA,iBAA+B;AACxC,SAAoB,WAAXA,iBAAgC;AACzC,SAAoB,WAAXA,iBAA+B;AACxC,SAAoB,WAAXA,iBAAoC;AAC7C,SAAoB,WAAXA,iBAAkC;AAC3C,SAAoB,WAAXA,iBAA+B;AACxC,SAAoB,WAAXA,iBAAiC;AAC1C,SAAoB,WAAXA,iBAAqC;AAC9C,SAAoB,WAAXA,iBAAgC;AACzC,SAAoB,WAAXA,iBAAiC;AAC1C,SAAoB,WAAXA,iBAAsC;AAC/C,SAAoB,WAAXA,iBAAkC;AAC3C,SAAoB,WAAXA,iBAA4B;AACrC,SAAoB,WAAXA,iBAA4B;AACrC,SAAoB,WAAXA,iBAAsC;AAC/C,SAAoB,WAAXA,iBAAwB;AACjC,SAAoB,WAAXA,iBAAqC;AAC9C,SAAoB,WAAXA,iBAAkC;",
+  "names": ["default"]
+}

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

@@ -0,0 +1,19 @@
+/**
+ * @file isAbsoluteSpecifier
+ * @module mlly/utils/isAbsoluteSpecifier
+ */
+/**
+ * Checks if the given `specifier` is an absolute specifier.
+ *
+ * ::: warning
+ * Only checks specifier syntax. Does **not** guarantee the specifier references
+ * a file that exists.
+ * :::
+ *
+ * @see https://nodejs.org/api/esm.html#terminology
+ *
+ * @param {string} specifier - Specifier to evaluate
+ * @return {boolean} `true` if `specifier` is absolute specifier
+ */
+declare const isAbsoluteSpecifier: (specifier: string) => boolean;
+export default isAbsoluteSpecifier;

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

@@ -0,0 +1,25 @@
+import pathe from "@flex-development/pathe";
+import { URL } from "node:url";
+const isAbsoluteSpecifier = (specifier) => {
+  let absolute = false;
+  switch (true) {
+    case pathe.isAbsolute(specifier):
+      absolute = true;
+      break;
+    case specifier.startsWith("file:"):
+      try {
+        new URL(specifier);
+        absolute = true;
+      } catch {
+      }
+      break;
+    default:
+      absolute = false;
+  }
+  return absolute;
+};
+var is_absolute_specifier_default = isAbsoluteSpecifier;
+export {
+  is_absolute_specifier_default as default
+};
+//# sourceMappingURL=is-absolute-specifier.mjs.map

package/dist/utils/is-absolute-specifier.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/is-absolute-specifier.ts"],
+  "mappings": "AAKA,OAAO,WAAW;AAClB,SAAS,WAAW;AAepB,MAAM,sBAAsB,CAAC,cAA+B;AAM1D,MAAI,WAAoB;AAGxB,UAAQ,MAAM;AAAA,IACZ,KAAK,MAAM,WAAW,SAAS;AAC7B,iBAAW;AACX;AAAA,IACF,KAAK,UAAU,WAAW,OAAO;AAC/B,UAAI;AACF,YAAI,IAAI,SAAS;AACjB,mBAAW;AAAA,MACb,QAAuB;AAAA,MAAO;AAC9B;AAAA,IACF;AACE,iBAAW;AAAA,EACf;AAEA,SAAO;AACT;AAEA,IAAO,gCAAQ;",
+  "names": []
+}

package/dist/utils/is-bare-specifier.d.mts

@@ -0,0 +1,19 @@
+/**
+ * @file isBareSpecifier
+ * @module mlly/utils/isBareSpecifier
+ */
+/**
+ * Checks if the given `specifier` is a bare specifier.
+ *
+ * ::: warning
+ * Only checks specifier syntax. Does **not** guarantee the specifier references
+ * a file that exists.
+ * :::
+ *
+ * @see https://nodejs.org/api/esm.html#terminology
+ *
+ * @param {string} specifier - Specifier to evaluate
+ * @return {boolean} `true` if `specifier` is bare specifier
+ */
+declare const isBareSpecifier: (specifier: string) => boolean;
+export default isBareSpecifier;

package/dist/utils/is-bare-specifier.mjs

@@ -0,0 +1,10 @@
+import isAbsoluteSpecifier from "./is-absolute-specifier.mjs";
+import isRelativeSpecifier from "./is-relative-specifier.mjs";
+const isBareSpecifier = (specifier) => {
+  return specifier.trim().length > 0 && !isAbsoluteSpecifier(specifier) && !isRelativeSpecifier(specifier);
+};
+var is_bare_specifier_default = isBareSpecifier;
+export {
+  is_bare_specifier_default as default
+};
+//# sourceMappingURL=is-bare-specifier.mjs.map

package/dist/utils/is-bare-specifier.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/is-bare-specifier.ts"],
+  "mappings": "AAKA,OAAO,yBAAyB;AAChC,OAAO,yBAAyB;AAehC,MAAM,kBAAkB,CAAC,cAA+B;AACtD,SACE,UAAU,KAAK,EAAE,SAAS,KAC1B,CAAC,oBAAoB,SAAS,KAC9B,CAAC,oBAAoB,SAAS;AAElC;AAEA,IAAO,4BAAQ;",
+  "names": []
+}

package/dist/utils/is-exports-sugar.d.mts

@@ -0,0 +1,25 @@
+/**
+ * @file isExportsSugar
+ * @module mlly/utils/isExportsSugar
+ */
+import type { ModuleId } from '../types/index.mjs';
+import type { Exports } from '@flex-development/pkg-types';
+/**
+ * Checks if the given package [`exports`][1] value is using [exports sugar][2].
+ *
+ * [1]: https://nodejs.org/api/packages.html#exports
+ * [2]: https://nodejs.org/api/packages.html#exports-sugar
+ *
+ * @see {@linkcode Exports}
+ * @see {@linkcode ModuleId}
+ *
+ * @param {Exports | undefined} exports - Package `exports`
+ * @param {ModuleId} pkg - URL of relevant `package.json` file
+ * @param {ModuleId} parent - URL of module to resolve from
+ * @return {boolean} `true` if `exports` is using exports sugar
+ * @throws {NodeError<Error | TypeError>} If either `pkg` or `parent` is not an
+ * instance of {@linkcode URL} or a string, or if `exports` configuration or
+ * schema is invalid
+ */
+declare const isExportsSugar: (exports: Exports | undefined, pkg: ModuleId, parent: ModuleId) => boolean;
+export default isExportsSugar;

package/dist/utils/is-exports-sugar.mjs

@@ -0,0 +1,26 @@
+import { isNIL } from "@flex-development/tutils";
+import validateExports from "./validate-exports.mjs";
+const isExportsSugar = (exports, pkg, parent) => {
+  var _a;
+  let sugar = false;
+  switch (true) {
+    case Array.isArray(exports):
+    case typeof exports === "string":
+      sugar = true;
+      break;
+    case isNIL(exports):
+    case typeof exports !== "object":
+      sugar = false;
+      break;
+    default:
+      exports = exports;
+      validateExports(exports, pkg, parent);
+      sugar = !((_a = Object.getOwnPropertyNames(exports)[0]) == null ? void 0 : _a.startsWith("."));
+  }
+  return sugar;
+};
+var is_exports_sugar_default = isExportsSugar;
+export {
+  is_exports_sugar_default as default
+};
+//# sourceMappingURL=is-exports-sugar.mjs.map

package/dist/utils/is-exports-sugar.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/is-exports-sugar.ts"],
+  "mappings": "AAQA,SAAS,aAAa;AACtB,OAAO,qBAAqB;AAmB5B,MAAM,iBAAiB,CACrB,SACA,KACA,WACY;AAhCd;AAwCE,MAAI,QAAiB;AAGrB,UAAQ,MAAM;AAAA,IACZ,KAAK,MAAM,QAAQ,OAAO;AAAA,IAC1B,KAAK,OAAO,YAAY;AACtB,cAAQ;AACR;AAAA,IACF,KAAK,MAAM,OAAO;AAAA,IAClB,KAAK,OAAO,YAAY;AACtB,cAAQ;AACR;AAAA,IACF;AACE,gBAAU;AAWV,sBAAgB,SAAS,KAAK,MAAM;AAGpC,cAAQ,GAAC,YAAO,oBAAoB,OAAO,EAAE,CAAC,MAArC,mBAAwC,WAAW;AAAA,EAChE;AAEA,SAAO;AACT;AAEA,IAAO,2BAAQ;",
+  "names": []
+}

package/dist/utils/is-relative-specifier.d.mts

@@ -0,0 +1,20 @@
+/**
+ * @file isRelativeSpecifier
+ * @module mlly/utils/isRelativeSpecifier
+ */
+/**
+ * Checks if the given `specifier` is a relative specifier.
+ *
+ * ::: warning
+ * Only checks specifier syntax. Does **not** guarantee the specifier references
+ * a file that exists.
+ * :::
+ *
+ * @see https://nodejs.org/api/esm.html#terminology
+ *
+ * @param {string} specifier - Specifier to evaluate
+ * @return {boolean} `true` if `specifier` is relative specifier
+ * @throws {NodeError<TypeError>} If `specifier` is not a string
+ */
+declare const isRelativeSpecifier: (specifier: string) => boolean;
+export default isRelativeSpecifier;

package/dist/utils/is-relative-specifier.mjs

@@ -0,0 +1,11 @@
+import validateString from "../internal/validate-string.mjs";
+import pathe from "@flex-development/pathe";
+const isRelativeSpecifier = (specifier) => {
+  validateString(specifier, "specifier");
+  return specifier.startsWith(".") ? specifier.length === 1 || specifier[1] === pathe.sep ? true : specifier[1] === "." && (specifier.length === 2 || specifier[2] === pathe.sep) : false;
+};
+var is_relative_specifier_default = isRelativeSpecifier;
+export {
+  is_relative_specifier_default as default
+};
+//# sourceMappingURL=is-relative-specifier.mjs.map

package/dist/utils/is-relative-specifier.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/is-relative-specifier.ts"],
+  "mappings": "AAKA,OAAO,oBAAoB;AAE3B,OAAO,WAAW;AAgBlB,MAAM,sBAAsB,CAAC,cAA+B;AAC1D,iBAAe,WAAW,WAAW;AACrC,SAAO,UAAU,WAAW,GAAG,IAC3B,UAAU,WAAW,KAAK,UAAU,CAAC,MAAM,MAAM,MAC/C,OACA,UAAU,CAAC,MAAM,QAChB,UAAU,WAAW,KAAK,UAAU,CAAC,MAAM,MAAM,OACpD;AACN;AAEA,IAAO,gCAAQ;",
+  "names": []
+}

package/dist/utils/lookup-package-scope.d.mts

@@ -0,0 +1,26 @@
+/**
+ * @file lookupPackageScope
+ * @module mlly/utils/lookupPackageScope
+ */
+import type { PackageScope } from '../interfaces/index.mjs';
+import type { ModuleId } from '../types/index.mjs';
+import type { Nullable } from '@flex-development/tutils';
+/**
+ * Finds a `package.json` file for the given module `id`. Ends the search at the
+ * given end point **after** checking for a `package.json` file.
+ *
+ * Returns `null` if a `package.json` file is not found.
+ *
+ * @see {@linkcode ModuleId}
+ * @see {@linkcode PackageScope}
+ *
+ * @param {ModuleId} id - Id of module to get package scope for
+ * @param {ModuleId?} [stopdir=pathe.sep] - Directory to end search
+ * @param {string?} [specifier] - Module specifier passed by user
+ * @param {ModuleId?} [parent] - Id of module to resolve from
+ * @return {?PackageScope} Package scope result or `null`
+ * @throws {NodeError<TypeError>} If either `id` or `stopdir` is not an instance
+ * of {@linkcode URL} or a string
+ */
+declare const lookupPackageScope: (id: ModuleId, stopdir?: ModuleId, specifier?: string, parent?: ModuleId) => Nullable<PackageScope>;
+export default lookupPackageScope;

package/dist/utils/lookup-package-scope.mjs

@@ -0,0 +1,38 @@
+import validateURLString from "../internal/validate-url-string.mjs";
+import pathe from "@flex-development/pathe";
+import { pathToFileURL } from "node:url";
+import readPackageJson from "./read-package-json.mjs";
+import toURL from "./to-url.mjs";
+const lookupPackageScope = (id, stopdir = pathe.sep, specifier, parent) => {
+  validateURLString(id, "id");
+  validateURLString(stopdir, "stopdir");
+  stopdir = toURL(stopdir).pathname;
+  let dir = toURL(id).pathname;
+  let scope = null;
+  while (dir && !dir.endsWith("node_modules")) {
+    if (pathe.relative(stopdir, dir).startsWith("../"))
+      break;
+    const pkgjson = readPackageJson(
+      dir,
+      specifier,
+      parent
+    );
+    if (pkgjson) {
+      scope = {
+        dir: pathToFileURL(dir = pathe.resolve(process.cwd(), dir)).href,
+        pkg: pathToFileURL(pathe.join(dir, "package.json")).href,
+        pkgjson
+      };
+      break;
+    }
+    if (dir === stopdir.replace(/\/$/, ""))
+      break;
+    dir = pathe.dirname(dir);
+  }
+  return scope;
+};
+var lookup_package_scope_default = lookupPackageScope;
+export {
+  lookup_package_scope_default as default
+};
+//# sourceMappingURL=lookup-package-scope.mjs.map

package/dist/utils/lookup-package-scope.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/lookup-package-scope.ts"],
+  "mappings": "AAMA,OAAO,uBAAuB;AAG9B,OAAO,WAAW;AAGlB,SAAS,qBAAqB;AAC9B,OAAO,qBAAqB;AAC5B,OAAO,WAAW;AAmBlB,MAAM,qBAAqB,CACzB,IACA,UAAoB,MAAM,KAC1B,WACA,WAC2B;AAC3B,oBAAkB,IAAI,IAAI;AAC1B,oBAAkB,SAAS,SAAS;AAGpC,YAAU,MAAM,OAAO,EAAE;AAOzB,MAAI,MAAc,MAAM,EAAE,EAAE;AAO5B,MAAI,QAAgC;AAGpC,SAAO,OAAO,CAAC,IAAI,SAAS,cAAc,GAAG;AAE3C,QAAI,MAAM,SAAS,SAAS,GAAG,EAAE,WAAW,KAAK;AAAG;AAOpD,UAAM,UAAiC;AAAA,MACrC;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAGA,QAAI,SAAS;AACX,cAAQ;AAAA,QACN,KAAK,cAAe,MAAM,MAAM,QAAQ,QAAQ,IAAI,GAAG,GAAG,CAAE,EAAE;AAAA,QAC9D,KAAK,cAAc,MAAM,KAAK,KAAK,cAAc,CAAC,EAAE;AAAA,QACpD;AAAA,MACF;AAEA;AAAA,IACF;AAGA,QAAI,QAAQ,QAAQ,QAAQ,OAAO,EAAE;AAAG;AAGxC,UAAM,MAAM,QAAQ,GAAG;AAAA,EACzB;AAEA,SAAO;AACT;AAEA,IAAO,+BAAQ;",
+  "names": []
+}

package/dist/utils/parse-data-url.d.mts

@@ -0,0 +1,25 @@
+/**
+ * @file parseDataURL
+ * @module mlly/utils/parseDataURL
+ */
+import type { ParsedDataUrl } from '../interfaces/index.mjs';
+import type { URL } from 'node:url';
+/**
+ * Parses a [`data:` URL][1].
+ *
+ * If valid, returns an object representing the given `url`.
+ *
+ * **Note**: A [MIME type][2] string is required.
+ *
+ * [1]: https://developer.mozilla.org/docs/Web/HTTP/Basics_of_HTTP/Data_URLs
+ * [2]: https://developer.mozilla.org/docs/Web/HTTP/Basics_of_HTTP/MIME_types
+ *
+ * @see https://nodejs.org/api/esm.html#data-imports
+ *
+ * @param {URL | string} url - URL to evaluate
+ * @return {ParsedDataUrl} Object representing `url`
+ * @throws {ErrInvalidUrl | NodeError<TypeError>} If `url` is not a string or
+ * instance of {@linkcode URL}, or if `url` not a valid `data:` URL
+ */
+declare const parseDataURL: (url: URL | string) => ParsedDataUrl;
+export default parseDataURL;

package/dist/utils/parse-data-url.mjs

@@ -0,0 +1,25 @@
+import {
+  ERR_INVALID_URL
+} from "@flex-development/errnode";
+import toURL from "./to-url.mjs";
+const parseDataURL = (url) => {
+  url = toURL(url);
+  const regex = /^(?<protocol>data:)(?<mime>[^/]+\/[^,;]+)[^,]*?(?:;(?<base64>base64))?,(?<data>[\S\s]*?)$/;
+  const match = regex.exec(url.href);
+  if (!match)
+    throw new ERR_INVALID_URL(url.href);
+  const [, , mime = "", base64, data = ""] = match;
+  return {
+    base64: !!base64,
+    data: data.trim(),
+    href: url.href,
+    mime,
+    pathname: url.pathname,
+    protocol: url.protocol
+  };
+};
+var parse_data_url_default = parseDataURL;
+export {
+  parse_data_url_default as default
+};
+//# sourceMappingURL=parse-data-url.mjs.map

package/dist/utils/parse-data-url.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/parse-data-url.ts"],
+  "mappings": "AAMA;AAAA,EACE;AAAA,OAGK;AAGP,OAAO,WAAW;AAmBlB,MAAM,eAAe,CAAC,QAAqC;AAEzD,QAAM,MAAM,GAAG;AAUf,QAAM,QACJ;AAOF,QAAM,QAAmC,MAAM,KAAK,IAAI,IAAI;AAG5D,MAAI,CAAC;AAAO,UAAM,IAAI,gBAAgB,IAAI,IAAI;AAG9C,QAAM,CAAC,EAAE,EAAE,OAAO,IAAI,QAAQ,OAAO,EAAE,IAAI;AAE3C,SAAO;AAAA,IACL,QAAQ,CAAC,CAAC;AAAA,IACV,MAAM,KAAK,KAAK;AAAA,IAChB,MAAM,IAAI;AAAA,IACV;AAAA,IACA,UAAU,IAAI;AAAA,IACd,UAAU,IAAI;AAAA,EAChB;AACF;AAEA,IAAO,yBAAQ;",
+  "names": []
+}

package/dist/utils/parse-module-id.d.mts

@@ -0,0 +1,22 @@
+/**
+ * @file parseModuleId
+ * @module mlly/lib/parseModuleId
+ */
+import type { ParseModuleIdOptions, ParsedModuleId } from '../interfaces/index.mjs';
+import type { ModuleId } from '../types/index.mjs';
+/**
+ * Creates an object representation the given module `id`.
+ *
+ * @see {@linkcode ModuleId}
+ * @see {@linkcode ParseModuleIdOptions}
+ * @see {@linkcode ParsedModuleId}
+ *
+ * @param {ModuleId} id - Module id to parse
+ * @param {ParseModuleIdOptions?} [options={}] - Parsing options
+ * @return {ParsedModuleId} Object representing `id`
+ * @throws {NodeError<TypeError>} If `id` is not an instance of {@linkcode URL}
+ * or a string, if `id` includes encoded path separators, or if `id` is invalid
+ * according to `options.internal` or `options.pkgname`
+ */
+declare const parseModuleId: (id: ModuleId, options?: ParseModuleIdOptions) => ParsedModuleId;
+export default parseModuleId;

package/dist/utils/parse-module-id.mjs

@@ -0,0 +1,122 @@
+import ENCODED_SEP_REGEX from "../internal/regex-encoded-sep.mjs";
+import INTERNAL_SPECIFIER_REGEX from "../internal/regex-internal-specifier.mjs";
+import PACKAGE_PATH_REGEX from "../internal/regex-package-path.mjs";
+import validateURLString from "../internal/validate-url-string.mjs";
+import {
+  ERR_INVALID_MODULE_SPECIFIER
+} from "@flex-development/errnode";
+import { isBuiltin } from "@flex-development/is-builtin";
+import pathe from "@flex-development/pathe";
+import { URL, fileURLToPath } from "node:url";
+import isBareSpecifier from "./is-bare-specifier.mjs";
+import isRelativeSpecifier from "./is-relative-specifier.mjs";
+import toNodeURL from "./to-node-url.mjs";
+const parseModuleId = (id, options = {}) => {
+  const {
+    internal = id instanceof URL ? false : id.startsWith("#"),
+    pkgname = false
+  } = options;
+  validateURLString(id, "id");
+  id = id instanceof URL ? id.href : id.trim();
+  let error;
+  let parsed = {
+    internal: false,
+    path: id,
+    pkg: "",
+    protocol: "",
+    raw: id,
+    scope: "",
+    version: "",
+    version_prefix: ""
+  };
+  switch (true) {
+    case ENCODED_SEP_REGEX.test(id):
+      error = `must not include encoded '${pathe.sep}' or '\\' characters`;
+      break;
+    case isBuiltin(id):
+      const { href, protocol, pathname } = new URL(toNodeURL(id));
+      parsed = {
+        internal: false,
+        path: pathname.replace(/^\S+?(?=\/|$)/, ""),
+        pkg: href.replace(/\/.*$/, ""),
+        protocol: id.startsWith("node:") ? protocol : "",
+        raw: id,
+        scope: "",
+        version: "",
+        version_prefix: ""
+      };
+      break;
+    case INTERNAL_SPECIFIER_REGEX.test(id):
+      const [, root = ""] = INTERNAL_SPECIFIER_REGEX.exec(id);
+      parsed = {
+        internal: true,
+        path: id,
+        pkg: root,
+        protocol: "",
+        raw: id,
+        scope: "",
+        version: "",
+        version_prefix: ""
+      };
+      break;
+    case PACKAGE_PATH_REGEX.test(id):
+      const [
+        ,
+        pkg = "",
+        scope = "",
+        version_prefix = "",
+        version = "",
+        subpath = ""
+      ] = PACKAGE_PATH_REGEX.exec(id);
+      parsed = {
+        internal: false,
+        path: "." + subpath,
+        pkg,
+        protocol: "",
+        raw: id,
+        scope,
+        version,
+        version_prefix
+      };
+      break;
+    case /^[\w-]{2,}:/.test(id):
+      try {
+        const { host, protocol: protocol2, pathname: pathname2 } = new URL(id);
+        parsed = {
+          internal: false,
+          path: host + pathname2,
+          pkg: "",
+          protocol: protocol2,
+          raw: id,
+          scope: "",
+          version: "",
+          version_prefix: ""
+        };
+      } catch {
+        error = "is not a valid URL";
+      }
+      break;
+    case isBareSpecifier(id):
+    case isRelativeSpecifier(id):
+    case pathe.isAbsolute(id):
+      break;
+    default:
+      error = "";
+      break;
+  }
+  error = ENCODED_SEP_REGEX.test(id) ? error : internal && !INTERNAL_SPECIFIER_REGEX.test(id) ? "is not a valid internal imports specifier name" : pkgname && !PACKAGE_PATH_REGEX.test(id) ? "does not start with a valid package name" : error;
+  if (error !== void 0) {
+    let { parent } = options;
+    if (parent !== void 0) {
+      validateURLString(parent, "options.parent");
+      parent = fileURLToPath(parent);
+    }
+    throw new ERR_INVALID_MODULE_SPECIFIER(id, error, parent);
+  }
+  return parsed;
+};
+var parse_module_id_default = parseModuleId;
+export {
+  parse_module_id_default as default
+};
+//# sourceMappingURL=parse-module-id.mjs.map