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

package/dist/interfaces/options-resolve.d.mts

@@ -2,59 +2,14 @@
  * @file Interfaces - ResolveOptions
  * @module mlly/interfaces/ResolveOptions
  */
-/// <reference types="node" />
-import type { Ext, SpecifierType } from '../types/index.mjs';
-import type { EmptyString } from '@flex-development/tutils';
-import type { URL } from 'node:url';
+import type ResolveModuleOptions from './options-resolve-module.mjs';
 /**
- * Module resolution options.
+ * Resolution options.
+ *
+ * @see {@linkcode ResolveModuleOptions}
+ *
+ * @extends {ResolveModuleOptions}
  */
-interface ResolveOptions {
-    /**
-     * Export conditions.
-     *
-     * **Note**: Should be sorted by priority.
-     *
-     * @see https://nodejs.org/api/packages.html#conditional-exports
-     *
-     * @default CONDITIONS
-     */
-    conditions?: Set<string> | string[] | readonly string[];
-    /**
-     * Remove or replace file extension.
-     *
-     * **Note**: {@link type} must be set to `relative`.
-     *
-     * @see {@link Ext}
-     */
-    ext?: Ext | false | ((specifier: string, resolved: string) => EmptyString | Ext | PromiseLike<EmptyString | Ext>);
-    /**
-     * Module extensions to probe for.
-     *
-     * **Note**: Should be sorted by priority.
-     *
-     * @default RESOLVE_EXTENSIONS
-     */
-    extensions?: string[] | readonly string[];
-    /**
-     * Parent module URL or path to resolve from.
-     *
-     * @default import.meta.url
-     */
-    parent?: URL | string;
-    /**
-     * Keep symlinks instead of resolving them.
-     *
-     * @default false
-     */
-    preserveSymlinks?: boolean;
-    /**
-     * Module specifier type or a function to determine module specifier type.
-     *
-     * @see {@link SpecifierType}
-     *
-     * @default 'absolute'
-     */
-    type?: SpecifierType | ((resolved: string) => PromiseLike<SpecifierType> | SpecifierType);
+interface ResolveOptions extends ResolveModuleOptions {
 }
 export type { ResolveOptions as default };

package/dist/interfaces/package-scope.d.mts

@@ -0,0 +1,25 @@
+/**
+ * @file Interfaces - PackageScope
+ * @module mlly/interfaces/PackageScope
+ */
+import type { PackageJson } from '@flex-development/pkg-types';
+/**
+ * Object representing a package scope.
+ *
+ * @see {@linkcode PackageJson}
+ */
+interface PackageScope {
+    /**
+     * URL of directory containing `package.json` file.
+     */
+    dir: string;
+    /**
+     * URL of `package.json` file.
+     */
+    pkg: string;
+    /**
+     * `package.json` object.
+     */
+    pkgjson: PackageJson;
+}
+export type { PackageScope as default };

package/dist/interfaces/parsed-data-url.d.mts

@@ -0,0 +1,56 @@
+/**
+ * @file Interfaces - ParsedDataUrl
+ * @module mlly/interfaces/ParsedDataUrl
+ */
+/// <reference types="node" />
+import type { MimeType, Protocol } from '../types/index.mjs';
+import type { EmptyString, LiteralUnion } from '@flex-development/tutils';
+import type { URL } from 'node:url';
+/**
+ * Object representing a [`data:` URL][1].
+ *
+ * [1]: https://developer.mozilla.org/docs/Web/HTTP/Basics_of_HTTP/Data_URLs
+ *
+ * @see {@linkcode Protocol}
+ * @see {@linkcode MimeType}
+ * @see https://nodejs.org/api/esm.html#data-imports
+ */
+interface ParsedDataUrl {
+    /**
+     * [base64][1] encoding check.
+     *
+     * [1]: https://developer.mozilla.org/docs/Glossary/Base64
+     */
+    base64: boolean;
+    /**
+     * Data portion of URL.
+     *
+     * If {@linkcode base64} is `true`, `data` is base64-encoded.
+     */
+    data: LiteralUnion<EmptyString, string>;
+    /**
+     * Serialized `data:` URL.
+     *
+     * @see https://nodejs.org/api/url.html#urlhref
+     */
+    href: URL['href'];
+    /**
+     * MIME type.
+     *
+     * @see https://developer.mozilla.org/docs/Web/HTTP/Basics_of_HTTP/MIME_types
+     */
+    mime: LiteralUnion<MimeType, string>;
+    /**
+     * Path portion of URL.
+     *
+     * @see https://nodejs.org/api/url.html#urlpathname
+     */
+    pathname: URL['pathname'];
+    /**
+     * Protocol portion of URL.
+     *
+     * @see https://nodejs.org/api/url.html#urlprotocol
+     */
+    protocol: Extract<Protocol, 'data:'>;
+}
+export type { ParsedDataUrl as default };

package/dist/interfaces/parsed-module-id.d.mts

@@ -0,0 +1,80 @@
+/**
+ * @file Interfaces - ParsedModuleId
+ * @module mlly/interfaces/ParsedModuleId
+ */
+import type { Protocol } from '../types/index.mjs';
+import type { SemanticVersion } from '@flex-development/pkg-types';
+import type { EmptyString, LiteralUnion } from '@flex-development/tutils';
+/**
+ * Object representing a ECMAScript module id.
+ *
+ * @see {@linkcode Protocol}
+ * @see {@linkcode SemanticVersion}
+ */
+interface ParsedModuleId {
+    /**
+     * Subpath import (internal specifier) check.
+     *
+     * @see https://nodejs.org/api/packages.html#imports
+     * @see https://nodejs.org/api/packages.html#subpath-imports
+     */
+    internal: boolean;
+    /**
+     * One of the following:
+     *
+     * - Possible [subpath export][1] (includes leading `'.'`)
+     * - Possible [subpath import][2]
+     * - URL [`host`][3], [`pathname`][4], and [`port`][5]
+     * - Raw module id ({@linkcode raw})
+     *
+     * [1]: https://nodejs.org/api/packages.html#subpath-exports
+     * [2]: https://nodejs.org/api/packages.html#subpath-imports
+     * [3]: https://nodejs.org/api/url.html#urlhost
+     * [4]: https://nodejs.org/api/url.html#urlpathname
+     * [5]: https://nodejs.org/api/url.html#urlport
+     */
+    path: string;
+    /**
+     * Package name if module id begins with valid package name (e.g. is a [bare
+     * specifier][1]).
+     *
+     * If the module id is a bare specifier *and* [internal][2], this value will
+     * instead be the first path segement in the module id (i.e. `'#src'` given
+     * `'#src/foo'`). This **may or may not** be the subpath defined by the
+     * package maintainer.
+     *
+     * [1]: https://nodejs.org/api/esm.html#terminology
+     * [2]: https://nodejs.org/api/packages.html#subpath-imports
+     */
+    pkg: LiteralUnion<EmptyString, string>;
+    /**
+     * URL scheme if module id is a URL.
+     */
+    protocol: LiteralUnion<EmptyString | Protocol, string>;
+    /**
+     * Raw module id.
+     */
+    raw: string;
+    /**
+     * Package scope if module id begins with valid package name (e.g. is a [bare
+     * specifier][1]).
+     *
+     * [1]: https://nodejs.org/api/esm.html#terminology
+     */
+    scope: LiteralUnion<EmptyString, string>;
+    /**
+     * Package version if specified and module id begins with valid package name
+     * (e.g. is a [bare specifier][1]).
+     *
+     * **Note**: Version follows [Semantic Versioning 2.0.0][2] specification.
+     *
+     * [1]: https://nodejs.org/api/esm.html#terminology
+     * [2]: https://semver.org/spec/v2.0.0.html
+     */
+    version: LiteralUnion<EmptyString | SemanticVersion, string>;
+    /**
+     * Package {@linkcode version} prefix.
+     */
+    version_prefix: LiteralUnion<EmptyString | 'v', string>;
+}
+export type { ParsedModuleId as default };

package/dist/interfaces/parsed-subpath.d.mts

@@ -0,0 +1,40 @@
+/**
+ * @file Interfaces - ParsedSubpath
+ * @module mlly/interfaces/ParsedSubpath
+ */
+import type { EmptyString, LiteralUnion } from '@flex-development/tutils';
+/**
+ * Object representing a package subpath.
+ *
+ * @see https://nodejs.org/api/packages.html#subpath-exports
+ * @see https://nodejs.org/api/packages.html#subpath-imports
+ */
+interface ParsedSubpath {
+    /**
+     * Subpath without entry prefix ({@linkcode key}).
+     */
+    base: LiteralUnion<EmptyString, string>;
+    /**
+     * Subpath import check.
+     *
+     * @see https://nodejs.org/api/packages.html#imports
+     * @see https://nodejs.org/api/packages.html#subpath-imports
+     */
+    internal: boolean;
+    /**
+     * Subpath defined in `package.json` file.
+     *
+     * @see https://nodejs.org/api/packages.html#exports
+     * @see https://nodejs.org/api/packages.html#imports
+     */
+    key: string;
+    /**
+     * Subpath passed by user in module specifier.
+     */
+    raw: string;
+    /**
+     * Module specifier passed by user.
+     */
+    specifier: string;
+}
+export type { ParsedSubpath as default };

package/dist/interfaces/statement-export.d.mts

@@ -2,30 +2,43 @@
  * @file Interfaces - ExportStatement
  * @module mlly/interfaces/ExportStatement
  */
-import type { Declaration } from '../types/index.mjs';
+import type { StatementKind } from '../enums/index.mjs';
+import type { Declaration, SyntaxKindExport } from '../types/index.mjs';
+import type { Nullable } from '@flex-development/tutils';
 import type Statement from './statement.mjs';
 /**
- * Export statement object schema.
+ * Export statement object.
  *
- * @see {@link Declaration}
- * @see {@link Statement}
+ * @see {@linkcode Declaration}
+ * @see {@linkcode Statement}
+ * @see {@linkcode SyntaxKindExport}
  *
  * @extends {Statement}
  */
 interface ExportStatement extends Statement {
     /**
      * Export declaration, if any.
-     *
-     * @see {@link Declaration}
      */
-    declaration: Declaration | undefined;
+    declaration: Nullable<Declaration>;
     /**
      * Export names.
      */
     exports: string[];
     /**
-     * Export statement type.
+     * Statement kind.
      */
-    type: 'declaration' | 'default' | 'named' | 'star';
+    kind: StatementKind.EXPORT;
+    /**
+     * Modifier keywords.
+     */
+    modifiers: string[];
+    /**
+     * Statement syntax kind.
+     */
+    syntax: SyntaxKindExport;
+    /**
+     * Type-only export statement check.
+     */
+    type: boolean;
 }
 export type { ExportStatement as default };

package/dist/interfaces/statement-import.d.mts

@@ -2,11 +2,14 @@
  * @file Interfaces - ImportStatement
  * @module mlly/interfaces/ImportStatement
  */
+import type { StatementKind } from '../enums/index.mjs';
+import type { SyntaxKindImport } from '../types/index.mjs';
 import type Statement from './statement.mjs';
 /**
- * Import statement object schema.
+ * Import statement object.
  *
- * @see {@link Statement}
+ * @see {@linkcode Statement}
+ * @see {@linkcode SyntaxKindImport}
  *
  * @extends {Statement}
  */
@@ -15,13 +18,21 @@ interface ImportStatement extends Statement {
      * Import names.
      */
     imports: string[];
+    /**
+     * Statement kind.
+     */
+    kind: StatementKind.IMPORT;
     /**
      * Module specifier.
      */
     specifier: NonNullable<Statement['specifier']>;
     /**
-     * Import statement type.
+     * Module specifier syntax type.
+     */
+    specifier_syntax: NonNullable<Statement['specifier_syntax']>;
+    /**
+     * Statement syntax kind.
      */
-    type: 'default' | 'dynamic' | 'named' | 'star';
+    syntax: SyntaxKindImport;
 }
 export type { ImportStatement as default };

package/dist/interfaces/statement-require.d.mts

@@ -2,11 +2,14 @@
  * @file Interfaces - RequireStatement
  * @module mlly/interfaces/RequireStatement
  */
+import type { StatementKind } from '../enums/index.mjs';
+import type { SyntaxKindRequire } from '../types/index.mjs';
 import type Statement from './statement.mjs';
 /**
- * Require statement object schema.
+ * Require statement object.
  *
- * @see {@link Statement}
+ * @see {@linkcode Statement}
+ * @see {@linkcode SyntaxKindRequire}
  *
  * @extends {Statement}
  */
@@ -15,13 +18,21 @@ interface RequireStatement extends Statement {
      * Import names.
      */
     imports: string[];
+    /**
+     * Statement kind.
+     */
+    kind: StatementKind.REQUIRE;
     /**
      * Module specifier.
      */
     specifier: NonNullable<Statement['specifier']>;
     /**
-     * Import statement type.
+     * Module specifier syntax type.
+     */
+    specifier_syntax: NonNullable<Statement['specifier_syntax']>;
+    /**
+     * Statement syntax kind.
      */
-    type: 'require';
+    syntax: SyntaxKindRequire;
 }
 export type { RequireStatement as default };

package/dist/interfaces/statement.d.mts

@@ -2,11 +2,15 @@
  * @file Interfaces - Statement
  * @module mlly/interfaces/Statement
  */
-import type { StatementType } from '../types/index.mjs';
+import type { SpecifierKind, SpecifierSyntaxKind, StatementKind, StatementSyntaxKind } from '../enums/index.mjs';
+import type { Nullable } from '@flex-development/tutils';
 /**
- * CommonJS or ESM statement object schema.
+ * CommonJS or ESM statement object.
  *
- * @see {@link StatementType}
+ * @see {@linkcode SpecifierKind}
+ * @see {@linkcode SpecifierSyntaxKind}
+ * @see {@linkcode StatementKind}
+ * @see {@linkcode StatementSyntaxKind}
  */
 interface Statement {
     /**
@@ -14,20 +18,32 @@ interface Statement {
      */
     code: string;
     /**
-     * Ending index of {@link code} in source content.
+     * End index of {@linkcode code} in source content.
      */
     end: number;
+    /**
+     * Statement kind.
+     */
+    kind: StatementKind;
     /**
      * Module specifier.
      */
-    specifier: string | undefined;
+    specifier: Nullable<string>;
+    /**
+     * Module specifier type.
+     */
+    specifier_kind: Nullable<SpecifierKind>;
+    /**
+     * Module specifier syntax type.
+     */
+    specifier_syntax: Nullable<SpecifierSyntaxKind>;
     /**
-     * Starting index of {@link code} in source content.
+     * Start index of {@linkcode code} in source content.
      */
     start: number;
     /**
-     * Statement type.
+     * Statement syntax kind.
      */
-    type: StatementType;
+    syntax: StatementSyntaxKind;
 }
 export type { Statement as default };

package/dist/internal/escape-reg-exp.d.mts

@@ -0,0 +1,16 @@
+/**
+ * @file Internal - escapeRegExp
+ * @module mlly/internal/escapeRegExp
+ */
+/**
+ * Escapes special characters in the given regex `pattern`.
+ *
+ * A backslash escape (`\\`) is used when valid. A `\x2d` escape is used when
+ * the former would be disallowed by stricter Unicode pattern grammar.
+ *
+ * @param {string} pattern - Regex pattern to escape
+ * @return {string} `pattern` with special characters escaped
+ * @throws {NodeError<TypeError>} If `pattern` is not a string
+ */
+declare const escapeRegExp: (pattern: string) => string;
+export default escapeRegExp;

package/dist/internal/escape-reg-exp.mjs

@@ -0,0 +1,10 @@
+import validateString from "./validate-string.mjs";
+const escapeRegExp = (pattern) => {
+  validateString(pattern, "pattern");
+  return pattern.replace(/[$()*+.?[\\\]^{|}]/g, "\\$&").replace(/-/g, "\\x2d");
+};
+var escape_reg_exp_default = escapeRegExp;
+export {
+  escape_reg_exp_default as default
+};
+//# sourceMappingURL=escape-reg-exp.mjs.map

package/dist/internal/escape-reg-exp.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/internal/escape-reg-exp.ts"],
+  "mappings": "AAMA,OAAO,oBAAoB;AAY3B,MAAM,eAAe,CAAC,YAA4B;AAChD,iBAAe,SAAS,SAAS;AACjC,SAAO,QAAQ,QAAQ,uBAAuB,MAAM,EAAE,QAAQ,MAAM,OAAO;AAC7E;AAEA,IAAO,yBAAQ;",
+  "names": []
+}

package/dist/internal/format-type-map.d.mts

@@ -0,0 +1,17 @@
+/**
+ * @file Internal - FORMAT_TYPE_MAP
+ * @module mlly/internal/FORMAT_TYPE_MAP
+ */
+import { AssertType, Format } from '../enums/index.mjs';
+/**
+ * Module format to `import` assertion type map.
+ *
+ * **Note**:  It's unclear whether or not the HTML spec will require assertion
+ * types for WebAssembly modules.
+ *
+ * @see https://github.com/WebAssembly/esm-integration/issues/42
+ *
+ * @const {Map<Format, AssertType>} FORMAT_TYPE_MAP
+ */
+declare const FORMAT_TYPE_MAP: Map<Format, AssertType>;
+export default FORMAT_TYPE_MAP;

package/dist/internal/format-type-map.mjs

@@ -0,0 +1,13 @@
+import { AssertType, Format } from "../enums/index.mjs";
+const FORMAT_TYPE_MAP = /* @__PURE__ */ new Map([
+  [Format.BUILTIN, AssertType.IMPLICIT],
+  [Format.COMMONJS, AssertType.IMPLICIT],
+  [Format.JSON, AssertType.JSON],
+  [Format.MODULE, AssertType.IMPLICIT],
+  [Format.WASM, AssertType.IMPLICIT]
+]);
+var format_type_map_default = FORMAT_TYPE_MAP;
+export {
+  format_type_map_default as default
+};
+//# sourceMappingURL=format-type-map.mjs.map

package/dist/internal/format-type-map.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/internal/format-type-map.ts"],
+  "mappings": "AAKA,SAAS,YAAY,cAAc;AAYnC,MAAM,kBAA2C,oBAAI,IAAwB;AAAA,EAC3E,CAAC,OAAO,SAAS,WAAW,QAAQ;AAAA,EACpC,CAAC,OAAO,UAAU,WAAW,QAAQ;AAAA,EACrC,CAAC,OAAO,MAAM,WAAW,IAAI;AAAA,EAC7B,CAAC,OAAO,QAAQ,WAAW,QAAQ;AAAA,EACnC,CAAC,OAAO,MAAM,WAAW,QAAQ;AACnC,CAAC;AAED,IAAO,0BAAQ;",
+  "names": []
+}

package/dist/internal/get-specifier-kind.d.mts

@@ -0,0 +1,17 @@
+/**
+ * @file Internal - getSpecifierKind
+ * @module mlly/internal/getSpecifierKind
+ */
+import { SpecifierKind } from '../enums/index.mjs';
+import type { Nullable } from '@flex-development/tutils';
+/**
+ * Determines a specifier type for the given module `specifier`.
+ *
+ * @see {@linkcode SpecifierKind}
+ *
+ * @param {string} specifier - Module specifier to evaluate
+ * @return {Nullable<SpecifierKind>} Module `specifier` type or `null`
+ * @throws {NodeError<TypeError>} If `specifier` is not a string
+ */
+declare const getSpecifierKind: (specifier: string) => Nullable<SpecifierKind>;
+export default getSpecifierKind;

package/dist/internal/get-specifier-kind.mjs

@@ -0,0 +1,14 @@
+import { SpecifierKind } from "../enums/index.mjs";
+import validateString from "./validate-string.mjs";
+import isAbsoluteSpecifier from "../utils/is-absolute-specifier.mjs";
+import isRelativeSpecifier from "../utils/is-relative-specifier.mjs";
+const getSpecifierKind = (specifier) => {
+  validateString(specifier, "specifier");
+  specifier = specifier.trim().replace(/^["']|["']$/g, "");
+  return specifier ? isAbsoluteSpecifier(specifier) ? SpecifierKind.ABSOLUTE : isRelativeSpecifier(specifier) ? SpecifierKind.RELATIVE : SpecifierKind.BARE : null;
+};
+var get_specifier_kind_default = getSpecifierKind;
+export {
+  get_specifier_kind_default as default
+};
+//# sourceMappingURL=get-specifier-kind.mjs.map

package/dist/internal/get-specifier-kind.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/internal/get-specifier-kind.ts"],
+  "mappings": "AAKA,SAAS,qBAAqB;AAC9B,OAAO,oBAAoB;AAC3B,OAAO,yBAAyB;AAChC,OAAO,yBAAyB;AAahC,MAAM,mBAAmB,CAAC,cAA+C;AACvE,iBAAe,WAAW,WAAW;AAIrC,cAAY,UAAU,KAAK,EAAE,QAAQ,gBAAgB,EAAE;AAEvD,SAAO,YACH,oBAAoB,SAAS,IAC3B,cAAc,WACd,oBAAoB,SAAS,IAC7B,cAAc,WACd,cAAc,OAChB;AACN;AAEA,IAAO,6BAAQ;",
+  "names": []
+}

package/dist/internal/get-subpaths.d.mts

@@ -0,0 +1,25 @@
+/**
+ * @file Internal - getSubpaths
+ * @module mlly/internal/getSubpaths
+ */
+import type { ModuleId } from '../types/index.mjs';
+import type { Exports, Imports } from '@flex-development/pkg-types';
+/**
+ * Returns an array containing subpaths defined in the given package `context`,
+ * a `package.json` [`exports`][1] or [`imports`][2] field.
+ *
+ * If `context` is using [exports sugar][3], the array will contain a single
+ * subpath, `'.'`.
+ *
+ * [1]: https://nodejs.org/api/packages.html#exports
+ * [2]: https://nodejs.org/api/packages.html#imports
+ * [3]: https://nodejs.org/api/packages.html#exports-sugar
+ *
+ * @param {Exports | Imports | undefined} context - Package context
+ * @param {boolean} internal - Package `imports` hint
+ * @param {ModuleId} pkg - URL of relevant `package.json` file
+ * @param {ModuleId} parent - URL of module to resolve from
+ * @return {string[]} Subpaths defined in `context`
+ */
+declare const getSubpaths: (context: Exports | Imports | undefined, internal: boolean, pkg: ModuleId, parent: ModuleId) => string[];
+export default getSubpaths;

package/dist/internal/get-subpaths.mjs

@@ -0,0 +1,10 @@
+import isExportsSugar from "../utils/is-exports-sugar.mjs";
+import { isNIL } from "@flex-development/tutils";
+const getSubpaths = (context, internal, pkg, parent) => {
+  return isNIL(context) ? [] : !internal && isExportsSugar(context, pkg, parent) ? ["."] : Object.keys(context);
+};
+var get_subpaths_default = getSubpaths;
+export {
+  get_subpaths_default as default
+};
+//# sourceMappingURL=get-subpaths.mjs.map

package/dist/internal/get-subpaths.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/internal/get-subpaths.ts"],
+  "mappings": "AAMA,OAAO,oBAAoB;AAE3B,SAAS,aAAa;AAmBtB,MAAM,cAAc,CAClB,SACA,UACA,KACA,WACa;AACb,SAAO,MAAM,OAAO,IAChB,CAAC,IACD,CAAC,YAAY,eAAe,SAAS,KAAK,MAAM,IAChD,CAAC,GAAG,IACJ,OAAO,KAAK,OAA4C;AAC9D;AAEA,IAAO,uBAAQ;",
+  "names": []
+}

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

@@ -0,0 +1,15 @@
+/**
+ * @file Internals - isArrayIndex
+ * @module mlly/internal/isArrayIndex
+ */
+/**
+ * Checks if if the given `key` is a numeric property key as defined in ECMA-262
+ * [6.1.7 Array Index][1].
+ *
+ * [1]: https://tc39.es/ecma262/#integer-index
+ *
+ * @param {string} key - Property key to evaluate
+ * @return {key is Numeric} `true` if `key` is numeric property key
+ */
+declare const isArrayIndex: (key: string) => key is `${number}`;
+export default isArrayIndex;

package/dist/internal/is-array-index.mjs

@@ -0,0 +1,9 @@
+const isArrayIndex = (key) => {
+  const num = +key;
+  return `${num}` !== key ? false : num >= 0 && num < 4294967295;
+};
+var is_array_index_default = isArrayIndex;
+export {
+  is_array_index_default as default
+};
+//# sourceMappingURL=is-array-index.mjs.map

package/dist/internal/is-array-index.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/internal/is-array-index.ts"],
+  "mappings": "AAgBA,MAAM,eAAe,CAAC,QAAgC;AAMpD,QAAM,MAAc,CAAC;AAErB,SAAO,GAAG,UAAU,MAAM,QAAQ,OAAO,KAAK,MAAM;AACtD;AAEA,IAAO,yBAAQ;",
+  "names": []
+}