locter 2.2.1 → 4.0.0-beta.0

package/dist/index.d.mts

@@ -0,0 +1,563 @@
+import { BaseError, ErrorOptions } from "@ebec/core";
+import { createJiti } from "jiti";
+import { ToStringOptions } from "yaml";
+//#region src/errors/base.d.ts
+type LocterErrorOptions = ErrorOptions & {
+  path?: string;
+};
+type LocterErrorInput = string | LocterErrorOptions;
+declare const LOCTER_ERROR_MARKER: unique symbol;
+declare class LocterError extends BaseError {
+  static [Symbol.hasInstance](input: unknown): boolean;
+  readonly path?: string;
+  constructor(input?: LocterErrorInput);
+}
+//#endregion
+//#region src/errors/load.d.ts
+declare const LOCTER_LOAD_ERROR_MARKER: unique symbol;
+declare class LocterLoadError extends LocterError {
+  static [Symbol.hasInstance](input: unknown): boolean;
+  constructor(input?: LocterErrorInput);
+}
+//#endregion
+//#region src/errors/not-found.d.ts
+declare const LOCTER_NOT_FOUND_ERROR_MARKER: unique symbol;
+declare class LocterNotFoundError extends LocterError {
+  static [Symbol.hasInstance](input: unknown): boolean;
+  constructor(input?: LocterErrorInput);
+}
+//#endregion
+//#region src/errors/unknown-extension.d.ts
+declare const LOCTER_UNKNOWN_EXTENSION_ERROR_MARKER: unique symbol;
+declare class LocterUnknownExtensionError extends LocterError {
+  static [Symbol.hasInstance](input: unknown): boolean;
+  constructor(input?: LocterErrorInput);
+}
+//#endregion
+//#region src/errors/wrap.d.ts
+declare function wrapLoaderError(input: unknown, path: string): LocterError;
+declare function wrapWriteError(input: unknown, path: string): LocterError;
+//#endregion
+//#region src/errors/write.d.ts
+declare const LOCTER_WRITE_ERROR_MARKER: unique symbol;
+declare class LocterWriteError extends LocterError {
+  static [Symbol.hasInstance](input: unknown): boolean;
+  constructor(input?: LocterErrorInput);
+}
+//#endregion
+//#region src/locator/types.d.ts
+type LocatorInfo = {
+  directory: string;
+  name: string;
+  extension?: string;
+  path: string;
+};
+type LocatorOptions = {
+  cwd: string[];
+  ignore: string[];
+  onlyFiles: boolean;
+  onlyDirectories: boolean;
+  dot: boolean;
+};
+type LocatorOptionsInput = Partial<Omit<LocatorOptions, 'cwd' | 'ignore'>> & {
+  cwd?: string | string[];
+  ignore?: string | string[];
+};
+//#endregion
+//#region src/locator/async.d.ts
+declare function locateMany(pattern: string | string[], options?: LocatorOptionsInput): Promise<LocatorInfo[]>;
+declare function locate(pattern: string | string[], options?: LocatorOptionsInput): Promise<LocatorInfo | undefined>;
+//#endregion
+//#region src/locator/sync.d.ts
+declare function locateManySync(pattern: string | string[], options?: LocatorOptionsInput): LocatorInfo[];
+declare function locateSync(pattern: string | string[], options?: LocatorOptionsInput): LocatorInfo | undefined;
+//#endregion
+//#region src/locator/up.d.ts
+type LocatorUpOptionsInput = Omit<LocatorOptionsInput, 'cwd'> & {
+  cwd?: string;
+  stopAt?: string;
+};
+declare function locateUp(pattern: string | string[], options?: LocatorUpOptionsInput): Promise<LocatorInfo | undefined>;
+declare function locateUpSync(pattern: string | string[], options?: LocatorUpOptionsInput): LocatorInfo | undefined;
+//#endregion
+//#region src/locator/utils.d.ts
+declare function isLocatorInfo(input: unknown): input is LocatorInfo;
+declare function buildFilePath(input: LocatorInfo | string): string;
+//#endregion
+//#region src/utils/twin.d.ts
+/**
+ * Internal protocol to derive the parallel sync + async public surfaces
+ * from one shared body. A body is a generator that yields effect pairs —
+ * an async and a sync thunk for the same operation — and the two drivers
+ * (runTwinAsync / runTwinSync) execute the side they stand for. Effect
+ * errors are re-entered into the body via `Generator.throw`, so try/catch
+ * inside a body behaves identically in both variants.
+ *
+ * Deliberately NOT exported from the utils barrel — this is internal
+ * plumbing, not public API.
+ */
+type TwinOp<T = unknown> = {
+  async: () => Promise<T>;
+  sync: () => T;
+};
+type TwinBody<R> = Generator<TwinOp<any>, R, any>;
+//#endregion
+//#region src/format/type.d.ts
+interface IReader {
+  read: (input: string) => Promise<any>;
+  readSync: (input: string) => any;
+}
+interface IWriter {
+  write: (path: string, value: unknown) => Promise<void>;
+  writeSync: (path: string, value: unknown) => void;
+}
+//#endregion
+//#region src/format/text-file/reader.d.ts
+/**
+ * Base class for readers of text-based file formats: reads the file as
+ * UTF-8, delegates to `parse`, and wraps I/O and parse errors in typed
+ * LocterError subclasses. Subclasses implement `parse` only — both
+ * `read` variants are derived from the same body.
+ */
+declare abstract class TextFileReader implements IReader {
+  abstract parse(content: string): any;
+  read(input: string): Promise<any>;
+  readSync(input: string): any;
+  protected body(input: string): TwinBody<any>;
+}
+//#endregion
+//#region src/format/text-file/writer.d.ts
+/**
+ * Base class for writers of text-based file formats: serializes via
+ * `stringify`, creates missing parent directories, writes the file as
+ * UTF-8 (always terminated by a single trailing newline), and wraps
+ * failures in LocterWriteError. Subclasses implement `stringify` only —
+ * both `write` variants are derived from the same body.
+ */
+declare abstract class TextFileWriter implements IWriter {
+  /**
+   * Opt-in: when true, the body reads the target file first (undefined
+   * if absent) and passes its content to `stringify` as `existing` —
+   * the hook behind format-preserving write-back (YAML comment
+   * grafting, JSON indent detection).
+   */
+  protected get usesExistingContent(): boolean;
+  abstract stringify(value: unknown, existing?: string): string;
+  write(input: string, value: unknown): Promise<void>;
+  writeSync(input: string, value: unknown): void;
+  protected body(input: string, value: unknown): TwinBody<void>;
+}
+//#endregion
+//#region src/format/built-in/conf/reader.d.ts
+declare class ConfReader extends TextFileReader {
+  parse(contents: string): Record<string, any>;
+}
+//#endregion
+//#region src/format/built-in/conf/writer.d.ts
+/**
+ * Serializes an object to `key=value` lines (the inverse of ConfReader):
+ * nested objects become dot-separated keys, arrays become repeated
+ * `key[]=` lines. Round-trips are structural, not textual — comments,
+ * blank lines, and line order of an existing file are not preserved,
+ * and a string that parses as another type (e.g. '123') reads back as
+ * that type.
+ */
+declare class ConfWriter extends TextFileWriter {
+  stringify(value: unknown): string;
+}
+//#endregion
+//#region src/format/built-in/json/reader.d.ts
+declare class JSONReader extends TextFileReader {
+  parse(content: string): any;
+}
+//#endregion
+//#region src/format/built-in/json/writer.d.ts
+type JSONWriterOptions = {
+  /**
+   * Indentation of the emitted JSON. A number of spaces, a literal
+   * indent string, or 'auto' — detect the indentation of the existing
+   * target file and keep it (falls back to 4 for new files).
+   *
+   * @default 4
+   */
+  indent?: number | string | 'auto';
+};
+declare class JSONWriter extends TextFileWriter {
+  protected options: JSONWriterOptions;
+  constructor(options?: JSONWriterOptions);
+  protected get usesExistingContent(): boolean;
+  stringify(value: unknown, existing?: string): string;
+}
+//#endregion
+//#region src/format/built-in/module/constants.d.ts
+/**
+ * Single source of truth for the extensions handled by the module loader:
+ * consumed by BOTH the built-in routing registry and the jiti config.
+ */
+declare const MODULE_FILE_EXTENSIONS: readonly [".js", ".mjs", ".mts", ".cjs", ".cts", ".ts"];
+//#endregion
+//#region src/format/built-in/module/type.d.ts
+type ModuleExportFilterFn = (key: string, value: unknown) => boolean;
+type ModuleExport = {
+  key: string;
+  value: any;
+};
+type ModuleLoadOptions = {
+  withFilePrefix?: boolean;
+};
+type ModuleLoadFn = (id: string) => unknown | Promise<unknown>;
+type ModuleLoadSyncFn = (id: string) => unknown;
+type ModuleReaderOptions = {
+  /**
+   * Custom asynchronous module loader. When set, this replaces the
+   * built-in `await import(id)` call. Useful for test runners (e.g. Vitest)
+   * where dynamic imports inside `node_modules/locter` would otherwise
+   * escape the runner's module graph — defining this in user space lets
+   * the runner rewrite the `import()`.
+   */
+  load?: ModuleLoadFn;
+  /**
+   * Custom synchronous module loader. When set, this replaces the built-in
+   * `require(id)` call.
+   */
+  loadSync?: ModuleLoadSyncFn;
+};
+//#endregion
+//#region src/format/built-in/module/reader.d.ts
+type Jiti = ReturnType<typeof createJiti>;
+declare class ModuleReader implements IReader {
+  protected instance: Jiti;
+  protected loadFn?: ModuleLoadFn;
+  protected loadSyncFn?: ModuleLoadSyncFn;
+  constructor(options?: ModuleReaderOptions);
+  /**
+   * Returns the previous configuration, so callers can restore it.
+   */
+  configure(options: ModuleReaderOptions): ModuleReaderOptions;
+  /**
+   * Returns the raw module value (import / require / jiti output) —
+   * normalization to a module record happens once, at the
+   * FormatRegistry boundary.
+   *
+   * read/readSync are deliberately NOT derived from a shared body
+   * (unlike every other sync/async twin in this package): their
+   * recovery paths differ. The async variant falls back to loadSync
+   * under ts-node (jiti's async path does not cooperate with ts-node)
+   * and to the jiti instance otherwise; the sync variant only has the
+   * jiti fallback. The divergence is pinned by the fallback tests in
+   * test/unit/format/module.spec.ts.
+   */
+  read(input: string): Promise<any>;
+  readSync(input: string): any;
+  load(data: LocatorInfo | string, options?: ModuleLoadOptions): Promise<unknown>;
+  loadSync(data: LocatorInfo | string, options?: ModuleLoadOptions): unknown;
+  private build;
+}
+//#endregion
+//#region src/format/built-in/module/utils.d.ts
+/**
+ * True when the value is a record produced by locter's read()/toModuleRecord.
+ * Detection is brand-based; a plain object with an `__esModule` key is NOT
+ * a module record.
+ */
+declare function isModuleRecord(input: unknown): input is Record<string, any>;
+declare function getModuleExport(data: Record<string, any>, filterFn: ModuleExportFilterFn): ModuleExport | undefined;
+//#endregion
+//#region src/format/built-in/yaml/reader.d.ts
+declare class YAMLReader extends TextFileReader {
+  parse(content: string): any;
+}
+//#endregion
+//#region src/format/built-in/yaml/writer.d.ts
+type YAMLWriterOptions = ToStringOptions;
+/**
+ * Writes YAML preserving hand-edited structure where possible: when the
+ * target file already exists, the new value is grafted into its parsed
+ * document, so comments and anchors attached to surviving keys survive
+ * the write-back. New files are plain `yaml.stringify` output. An
+ * existing file that fails to parse throws (wrapped as LocterWriteError)
+ * instead of being silently overwritten.
+ */
+declare class YAMLWriter extends TextFileWriter {
+  protected options: YAMLWriterOptions;
+  constructor(options?: YAMLWriterOptions);
+  protected get usesExistingContent(): boolean;
+  stringify(value: unknown, existing?: string): string;
+}
+//#endregion
+//#region src/format/built-in/registry.d.ts
+/**
+ * Every built-in format, in one place. Keys are the format ids; each entry
+ * couples routing and construction. The id union, the extension → format
+ * table, lazy caching, and the typed `builtInReader()` accessor are all
+ * DERIVED from this object. Adding a format = adding one entry.
+ *
+ * Intentionally NOT re-exported from any barrel (internal API).
+ */
+declare const BUILT_IN_PRESETS: {
+  readonly module: {
+    readonly extensions: readonly [".js", ".mjs", ".mts", ".cjs", ".cts", ".ts"];
+    readonly reader: () => ModuleReader;
+  };
+  readonly conf: {
+    readonly extensions: readonly [".conf"];
+    readonly reader: () => ConfReader;
+    readonly writer: () => ConfWriter;
+  };
+  readonly json: {
+    readonly extensions: readonly [".json"];
+    readonly reader: () => JSONReader;
+    readonly writer: () => JSONWriter;
+  };
+  readonly yaml: {
+    readonly extensions: readonly [".yml", ".yaml"];
+    readonly reader: () => YAMLReader;
+    readonly writer: () => YAMLWriter;
+  };
+};
+type BuiltInFormatId = keyof typeof BUILT_IN_PRESETS;
+type BuiltInReaderOf<K extends BuiltInFormatId> = ReturnType<(typeof BUILT_IN_PRESETS)[K]['reader']>;
+/**
+ * Built-in format ids whose preset declares a writer — derived at the type
+ * level, so builtInWriter('module') is a compile error, not a runtime one.
+ */
+type WritableBuiltInFormatId = { [K in BuiltInFormatId]: (typeof BUILT_IN_PRESETS)[K] extends {
+  writer: () => IWriter;
+} ? K : never; }[BuiltInFormatId];
+type BuiltInWriterOf<K extends WritableBuiltInFormatId> = ReturnType<(typeof BUILT_IN_PRESETS)[K]['writer']>;
+//#endregion
+//#region src/format/registry/type.d.ts
+/**
+ * Lazy reader construction. Invoked on the first input that matches the
+ * rule it was registered for; the first successfully constructed reader
+ * is cached (a factory that throws is retried on the next match).
+ */
+type ReaderFactory = () => IReader;
+/**
+ * Lazy writer construction — same lifecycle as ReaderFactory.
+ */
+type WriterFactory = () => IWriter;
+/**
+ * A user-registered dispatch rule. Rules are matched in registration order,
+ * BEFORE the built-in extension table (i.e. user rules override built-ins).
+ * Rules only ever see file paths — bare module specifiers (no extension)
+ * are always routed to the module reader first.
+ *
+ * The reader and writer slots are independent: read dispatch only
+ * considers rules with a reader, write dispatch only rules with a writer.
+ * A reader-only rule for '.json' overrides how '.json' is read without
+ * shadowing the built-in JSON writer (and vice versa). At least one slot
+ * is required.
+ */
+type Rule = {
+  /**
+   * Stable identity. Registering an existing id REPLACES that rule in
+   * place (position preserved, cached instance evicted). Built-in ids
+   * ('module', 'conf', 'json', 'yaml') are reserved. Omitted → auto-generated.
+   */
+  id?: string;
+  test: RegExp | string[];
+  reader?: IReader | ReaderFactory;
+  writer?: IWriter | WriterFactory;
+};
+/**
+ * Normalized registration record — returned by register()/entries().
+ */
+type FormatRegistration = {
+  id: string;
+  test: RegExp | string[];
+  /**
+   * true for entries derived from the built-in registry; those cannot
+   * be unregistered (but can be shadowed by user rules).
+   */
+  builtIn: boolean;
+};
+/**
+ * One built-in format: routing (extensions) + instantiation (reader and
+ * optional writer), inseparable by construction. A preset without a
+ * writer is a read-only format (e.g. module).
+ */
+type FormatPreset = {
+  /** Extensions (with leading dot) routed to this format. Must be disjoint across presets. */
+  extensions: readonly string[];
+  /** Lazy reader factory — invoked at most once per FormatRegistry instance. */
+  reader: () => IReader;
+  /** Lazy writer factory — invoked at most once per FormatRegistry instance. */
+  writer?: () => IWriter;
+};
+//#endregion
+//#region src/format/registry/module.d.ts
+type FormatRegistryOptions = {
+  /**
+   * Seed user rules (matched before built-ins, in array order).
+   */
+  rules?: Rule[];
+};
+/**
+ * A rule compiled to memoizing per-slot accessors. Caller-owned Rule
+ * objects are never mutated; factory caching lives in the closures.
+ */
+type CompiledRule = {
+  id: string;
+  test: RegExp | string[];
+  getReader?: () => IReader;
+  getWriter?: () => IWriter;
+};
+declare class FormatRegistry {
+  /**
+   * User rules only — built-ins live in the extension table instead.
+   */
+  protected rules: CompiledRule[];
+  /**
+   * Lazy per-instance cache of built-in reader instances.
+   */
+  protected builtInReaderCache: Map<BuiltInFormatId, IReader>;
+  /**
+   * Lazy per-instance cache of built-in writer instances.
+   */
+  protected builtInWriterCache: Map<BuiltInFormatId, IWriter>;
+  /**
+   * extension → built-in format id, precomputed once from BUILT_IN_PRESETS.
+   */
+  protected builtInExtensions: Map<string, BuiltInFormatId>;
+  protected ruleCounter: number;
+  constructor(options?: FormatRegistryOptions);
+  register(rule: Rule): FormatRegistration;
+  /**
+   * Remove a user-registered rule by id. Built-in ids cannot be
+   * unregistered (returns false).
+   */
+  unregister(id: string): boolean;
+  has(id: string): boolean;
+  /**
+   * All registrations in effective match order: user rules
+   * (registration order) first, then the built-ins.
+   */
+  entries(): FormatRegistration[];
+  /**
+   * Restore the registry to its construction state: drop all user rules
+   * and evict every cached reader instance (including a module reader
+   * configured via setModuleReader / configure).
+   */
+  reset(): void;
+  read(input: LocatorInfo | string): Promise<any>;
+  readSync(input: LocatorInfo | string): any;
+  /**
+   * Shared body of read/readSync: dispatch, read, normalize, wrap.
+   */
+  protected readBody(input: LocatorInfo | string): TwinBody<any>;
+  write(input: LocatorInfo | string, value: unknown): Promise<void>;
+  writeSync(input: LocatorInfo | string, value: unknown): void;
+  /**
+   * Shared body of write/writeSync: dispatch, unwrap records, write, wrap.
+   * The inverse boundary of readBody: a record produced by read() (brand
+   * detected) is unwrapped to its `.default` value; anything else is
+   * written as-is.
+   */
+  protected writeBody(input: LocatorInfo | string, value: unknown): TwinBody<void>;
+  /**
+   * The single normalization boundary: every read result becomes a module
+   * record (`.default` is always the loaded value, top-level keys stay
+   * accessible as named exports). Provenance decides how: module-reader
+   * output may legitimately already be a record (`__esModule` is meaningful
+   * there); any other reader returns arbitrary parsed data, which is always
+   * wrapped — even if it happens to contain an `__esModule` key.
+   */
+  protected toRecord(output: unknown, reader: IReader): any;
+  /**
+   * Typed accessor for the LIVE built-in reader instance (lazy, cached).
+   */
+  builtInReader<K extends BuiltInFormatId>(id: K): BuiltInReaderOf<K>;
+  /**
+   * Typed accessor for the LIVE built-in writer instance (lazy, cached).
+   * Only writable format ids are accepted — read-only formats (module)
+   * are a compile error.
+   */
+  builtInWriter<K extends WritableBuiltInFormatId>(id: K): BuiltInWriterOf<K>;
+  /**
+   * Dispatch order:
+   *   1. bare specifier (no extension)  → module reader, always
+   *   2. user rules, registration order → first match wins (can override built-ins)
+   *   3. built-in extension table
+   *   4. undefined → read/readSync throw LocterUnknownExtensionError
+   */
+  findReader(input: string): IReader | undefined;
+  /**
+   * Write-side dispatch. No bare-specifier step (there is nothing to
+   * write to); only rules with a writer slot participate, then built-in
+   * presets that declare a writer.
+   */
+  findWriter(input: string): IWriter | undefined;
+  protected findRule(input: string, filter: (rule: CompiledRule) => boolean): CompiledRule | undefined;
+  protected findBuiltInId(input: string): BuiltInFormatId | undefined;
+  protected unknownExtensionError(input: string): LocterUnknownExtensionError;
+  protected compile(id: string, rule: Rule): CompiledRule;
+  protected generateRuleId(): string;
+}
+//#endregion
+//#region src/format/registry/singleton.d.ts
+declare function useFormatRegistry(): FormatRegistry;
+//#endregion
+//#region src/format/helpers.d.ts
+declare function registerFormat(rule: Rule): FormatRegistration;
+/**
+ * Remove a rule from the process-global registry by its id
+ * (as returned by registerFormat). Built-in ids cannot be unregistered.
+ */
+declare function unregisterFormat(id: string): boolean;
+declare function read(input: LocatorInfo | string): Promise<any>;
+declare function readSync(input: LocatorInfo | string): any;
+declare function write(input: LocatorInfo | string, value: unknown): Promise<void>;
+declare function writeSync(input: LocatorInfo | string, value: unknown): void;
+/**
+ * Override the built-in module reader's `import` / `require` calls.
+ *
+ * Useful for test runners (e.g. Vitest) where the dynamic `import()` inside
+ * `node_modules/locter` would bypass the runner's module graph. Calling this
+ * from user code (e.g. a Vitest setup file) lets the runner rewrite the
+ * `import()` so loaded modules share identity with statically imported ones.
+ *
+ * Returns a restore function that re-applies the previous configuration —
+ * handy for scoped overrides (e.g. test teardown). The restore function is
+ * scoped to the exact reader instance it configured: after a registry
+ * reset() (which discards that instance) it becomes a no-op instead of
+ * re-applying stale configuration to the fresh instance.
+ *
+ * @example
+ * ```ts
+ * // vitest setup file
+ * import { setModuleReader } from 'locter';
+ *
+ * setModuleReader({
+ *     load: (id) => import(id),
+ * });
+ * ```
+ */
+declare function setModuleReader(options: ModuleReaderOptions): () => void;
+//#endregion
+//#region src/format/package-field.d.ts
+type ReadPackageFieldOptions = {
+  cwd?: string;
+  walkUp?: boolean;
+  stopAt?: string;
+};
+type WritePackageFieldOptions = ReadPackageFieldOptions;
+declare function readPackageField<T = unknown>(field: string, options?: ReadPackageFieldOptions): Promise<T | undefined>;
+declare function readPackageFieldSync<T = unknown>(field: string, options?: ReadPackageFieldOptions): T | undefined;
+/**
+ * Set a top-level field of the nearest `package.json` (same locate
+ * semantics as readPackageField) and write it back, preserving the
+ * file's existing indentation. Passing `undefined` removes the field.
+ * Throws LocterNotFoundError when no package.json could be located.
+ */
+declare function writePackageField(field: string, value: unknown, options?: WritePackageFieldOptions): Promise<void>;
+declare function writePackageFieldSync(field: string, value: unknown, options?: WritePackageFieldOptions): void;
+//#endregion
+//#region src/utils/runtime.d.ts
+declare function isJestRuntimeEnvironment(): boolean;
+declare function isVitestRuntimeEnvironment(): boolean;
+declare function isTsNodeRuntimeEnvironment(): boolean;
+declare function isTsxRuntimeEnvironment(): boolean;
+//#endregion
+export { ConfReader, ConfWriter, type FormatPreset, type FormatRegistration, FormatRegistry, type FormatRegistryOptions, type IReader, type IWriter, JSONReader, JSONWriter, type JSONWriterOptions, LOCTER_ERROR_MARKER, LOCTER_LOAD_ERROR_MARKER, LOCTER_NOT_FOUND_ERROR_MARKER, LOCTER_UNKNOWN_EXTENSION_ERROR_MARKER, LOCTER_WRITE_ERROR_MARKER, type LocatorInfo, type LocatorOptions, type LocatorOptionsInput, type LocatorUpOptionsInput, LocterError, type LocterErrorInput, type LocterErrorOptions, LocterLoadError, LocterNotFoundError, LocterUnknownExtensionError, LocterWriteError, MODULE_FILE_EXTENSIONS, type ModuleExport, type ModuleExportFilterFn, type ModuleLoadFn, type ModuleLoadOptions, type ModuleLoadSyncFn, ModuleReader, type ModuleReaderOptions, type ReadPackageFieldOptions, type ReaderFactory, type Rule, TextFileReader, TextFileWriter, type WritePackageFieldOptions, type WriterFactory, YAMLReader, YAMLWriter, type YAMLWriterOptions, buildFilePath, getModuleExport, isJestRuntimeEnvironment, isLocatorInfo, isModuleRecord, isTsNodeRuntimeEnvironment, isTsxRuntimeEnvironment, isVitestRuntimeEnvironment, locate, locateMany, locateManySync, locateSync, locateUp, locateUpSync, read, readPackageField, readPackageFieldSync, readSync, registerFormat, setModuleReader, unregisterFormat, useFormatRegistry, wrapLoaderError, wrapWriteError, write, writePackageField, writePackageFieldSync, writeSync };
+//# sourceMappingURL=index.d.mts.map