@visulima/fs 5.0.0-alpha.1 → 5.0.0-alpha.11

package/dist/packem_shared/{writeJsonSync-Cs21FE7v.js → writeJsonSync-BKZ_9Acr.js}

@@ -23,7 +23,7 @@ const {
 import { d as detectIndent } from './index-CHM-in-V.js';
 import { R_OK } from './F_OK-MldBaGxb.js';
 import isAccessibleSync from './isAccessibleSync-DI8mM0fA.js';
-import writeFileSync from './writeFileSync-CJp1kXQR.js';
+import writeFileSync from './writeFileSync-DB8vv8xR.js';
 
 const writeJsonSync = (path, data, options = {}) => {
   const { detectIndent: detectIndent$1, indent: indentOption, replacer, stringify = JSON.stringify, ...writeOptions } = { indent: "	", ...options };

package/dist/packem_shared/writeJsonc-BufH_oC5.js

@@ -0,0 +1,60 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  readFile
+} = __cjs_getBuiltinModule("node:fs/promises");
+import { d as detectIndent } from './index-CHM-in-V.js';
+import { R_OK } from './F_OK-MldBaGxb.js';
+import isAccessible from './isAccessible-DuVrTNFV.js';
+import { b as buildJsoncOutput } from './jsonc-merge-C6jWcfWh.js';
+import writeFile from './writeFile-B8HX0JIQ.js';
+
+const readExisting = async (path, detectIndent$1, fallbackIndent) => {
+  let existingText;
+  let indent = fallbackIndent;
+  let trailingNewline = "\n";
+  const accessible = await isAccessible(path, R_OK);
+  if (!accessible) {
+    return { indent, trailingNewline };
+  }
+  try {
+    existingText = await readFile(path, "utf8");
+    if (detectIndent$1) {
+      const { indent: detectedIndent } = detectIndent(existingText);
+      if (detectedIndent) {
+        indent = detectedIndent;
+      }
+    }
+    trailingNewline = existingText.endsWith("\n") ? "\n" : "";
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  return { existingText, indent, trailingNewline };
+};
+const writeJsonc = async (path, data, options = {}) => {
+  const { detectIndent, formattingOptions, indent: indentOption, preserveComments = true, replacer, ...writeOptions } = { indent: "	", ...options };
+  const { existingText, indent, trailingNewline } = await readExisting(path, detectIndent, indentOption);
+  const output = buildJsoncOutput(existingText, data, preserveComments, indent, trailingNewline, formattingOptions, replacer);
+  await writeFile(path, output, writeOptions);
+};
+
+export { writeJsonc as default };

package/dist/packem_shared/writeJsoncSync-DB9be1YL.js

@@ -0,0 +1,59 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  readFileSync
+} = __cjs_getBuiltinModule("node:fs");
+import { d as detectIndent } from './index-CHM-in-V.js';
+import { R_OK } from './F_OK-MldBaGxb.js';
+import isAccessibleSync from './isAccessibleSync-DI8mM0fA.js';
+import { b as buildJsoncOutput } from './jsonc-merge-C6jWcfWh.js';
+import writeFileSync from './writeFileSync-DB8vv8xR.js';
+
+const readExistingSync = (path, detectIndent$1, fallbackIndent) => {
+  let existingText;
+  let indent = fallbackIndent;
+  let trailingNewline = "\n";
+  if (!isAccessibleSync(path, R_OK)) {
+    return { indent, trailingNewline };
+  }
+  try {
+    existingText = readFileSync(path, "utf8");
+    if (detectIndent$1) {
+      const { indent: detectedIndent } = detectIndent(existingText);
+      if (detectedIndent) {
+        indent = detectedIndent;
+      }
+    }
+    trailingNewline = existingText.endsWith("\n") ? "\n" : "";
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  return { existingText, indent, trailingNewline };
+};
+const writeJsoncSync = (path, data, options = {}) => {
+  const { detectIndent, formattingOptions, indent: indentOption, preserveComments = true, replacer, ...writeOptions } = { indent: "	", ...options };
+  const { existingText, indent, trailingNewline } = readExistingSync(path, detectIndent, indentOption);
+  const output = buildJsoncOutput(existingText, data, preserveComments, indent, trailingNewline, formattingOptions, replacer);
+  writeFileSync(path, output, writeOptions);
+};
+
+export { writeJsoncSync as default };

package/dist/packem_shared/writeToml-DgTW_-7F.js

@@ -0,0 +1,8 @@
+import { stringify } from 'smol-toml';
+import writeFile from './writeFile-B8HX0JIQ.js';
+
+const writeToml = async (path, data, options) => {
+  await writeFile(path, stringify(data), options);
+};
+
+export { writeToml as default };

package/dist/packem_shared/writeTomlSync-DiBiE9ja.js

@@ -0,0 +1,8 @@
+import { stringify } from 'smol-toml';
+import writeFileSync from './writeFileSync-DB8vv8xR.js';
+
+const writeTomlSync = (path, data, options) => {
+  writeFileSync(path, stringify(data), options);
+};
+
+export { writeTomlSync as default };

package/dist/packem_shared/{writeYaml-n4xzYN9a.js → writeYaml-BWCOome-.js}

@@ -1,5 +1,5 @@
 import { stringify } from 'yaml';
-import writeFile from './writeFile-DSHERs0Z.js';
+import writeFile from './writeFile-B8HX0JIQ.js';
 
 async function writeYaml(path, data, replacer, options) {
   let stringifyOptions;
@@ -9,10 +9,10 @@ async function writeYaml(path, data, replacer, options) {
     stringifyOptions = replacer;
     effectiveReplacer = stringifyOptions.replacer;
     space = stringifyOptions.space;
-  } else if (typeof options === "object" && options !== null) {
+  } else if (typeof options === "object") {
     stringifyOptions = options;
     effectiveReplacer = replacer;
-    space = stringifyOptions.space ?? (typeof options === "number" || typeof options === "string" ? options : void 0);
+    space = stringifyOptions.space;
   } else {
     effectiveReplacer = replacer;
     space = options;

package/dist/packem_shared/{writeYamlSync-DnOEnP10.js → writeYamlSync-DBVnXmuY.js}

@@ -1,5 +1,5 @@
 import { stringify } from 'yaml';
-import writeFileSync from './writeFileSync-CJp1kXQR.js';
+import writeFileSync from './writeFileSync-DB8vv8xR.js';
 
 function writeYamlSync(path, data, replacer, options) {
   let stringifyOptions;
@@ -9,10 +9,10 @@ function writeYamlSync(path, data, replacer, options) {
     stringifyOptions = replacer;
     effectiveReplacer = stringifyOptions.replacer;
     space = stringifyOptions.space;
-  } else if (typeof options === "object" && options !== null) {
+  } else if (typeof options === "object") {
     stringifyOptions = options;
     effectiveReplacer = replacer;
-    space = stringifyOptions.space ?? (typeof options === "number" || typeof options === "string" ? options : void 0);
+    space = stringifyOptions.space;
   } else {
     effectiveReplacer = replacer;
     space = options;

package/dist/size.d.ts

@@ -1,256 +1,12 @@
-import { Readable } from "node:stream";
-import { URL } from "node:url";
-import type { BrotliOptions, ZlibOptions } from "node:zlib";
-/**
- * Input type for size calculation functions.
- * Can be a Buffer, Readable stream, URL object, or string (file path or content).
- */
+import { Readable } from 'node:stream';
+import { URL } from 'node:url';
+import { BrotliOptions, ZlibOptions } from 'node:zlib';
 type SizeInput = Buffer | Readable | URL | string;
-/**
- * Input type for synchronous size calculation functions.
- * Can be a Buffer, URL object, or string (file path or content).
- */
 type SizeInputSync = Buffer | URL | string;
-/**
- * Asynchronously calculates the gzipped size of the given input.
- * The input can be a Buffer, a Readable stream, a URL object pointing to a file, or a string (file path or content).
- * Uses memory-efficient streaming for files and streams to avoid loading entire contents into memory.
- * @param input The input data to gzip and measure.
- * @param [options] Optional Zlib options for gzip compression.
- * @returns A promise that resolves with the gzipped size in bytes.
- * @example
- * ```javascript
- * import { gzipSize } from "@visulima/fs";
- * import { Readable } from "node:stream";
- * import { writeFile, unlink } from "node:fs/promises";
- * import { join } from "node:path";
- *
- * const text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
- * const filePath = join("temp-file.txt");
- *
- * async function main() {
- *   // From Buffer
- *   const buffer = Buffer.from(text);
- *   console.log(`Gzip size of buffer: ${await gzipSize(buffer)} bytes`);
- *
- *   // From string (content)
- *   console.log(`Gzip size of string content: ${await gzipSize(text)} bytes`);
- *
- *   // From file path
- *   await writeFile(filePath, text);
- *   console.log(`Gzip size of file: ${await gzipSize(filePath)} bytes`);
- *
- *   // From URL
- *   const fileUrl = new URL(`file://${filePath}`);
- *   console.log(`Gzip size of URL: ${await gzipSize(fileUrl)} bytes`);
- *
- *   // From Readable stream
- *   const stream = Readable.from(text);
- *   console.log(`Gzip size of stream: ${await gzipSize(stream)} bytes`);
- *
- *   await unlink(filePath); // Clean up temp file
- * }
- *
- * main().catch(console.error);
- * ```
- */
-export declare const gzipSize: (input: SizeInput, options?: ZlibOptions) => Promise<number>;
-/**
- * Asynchronously calculates the Brotli compressed size of the given input.
- * The input can be a Buffer, a Readable stream, a URL object pointing to a file, or a string (file path or content).
- * Uses memory-efficient streaming for files and streams to avoid loading entire contents into memory.
- * @param input The input data to compress with Brotli and measure.
- * @param [options] Optional Zlib options for Brotli compression.
- * @returns A promise that resolves with the Brotli compressed size in bytes.
- * @example
- * ```javascript
- * import { brotliSize } from "@visulima/fs";
- * import { Readable } from "node:stream";
- * import { writeFile, unlink } from "node:fs/promises";
- * import { join } from "node:path";
- *
- * const text = "This is a test string for Brotli compression efficiency.";
- * const filePath = join("temp-brotli-file.txt");
- *
- * async function main() {
- *   // From Buffer
- *   const buffer = Buffer.from(text);
- *   console.log(`Brotli size of buffer: ${await brotliSize(buffer)} bytes`);
- *
- *   // From string (content)
- *   console.log(`Brotli size of string content: ${await brotliSize(text)} bytes`);
- *
- *   // From file path
- *   await writeFile(filePath, text);
- *   console.log(`Brotli size of file: ${await brotliSize(filePath)} bytes`);
- *
- *   // From URL
- *   const fileUrl = new URL(`file://${filePath}`);
- *   console.log(`Brotli size of URL: ${await brotliSize(fileUrl)} bytes`);
- *
- *   // From Readable stream
- *   const stream = Readable.from(text);
- *   console.log(`Brotli size of stream: ${await brotliSize(stream)} bytes`);
- *
- *   await unlink(filePath); // Clean up temp file
- * }
- *
- * main().catch(console.error);
- * ```
- */
-export declare const brotliSize: (input: SizeInput, options?: BrotliOptions) => Promise<number>;
-/**
- * Asynchronously calculates the raw (uncompressed) size of the given input.
- * The input can be a Buffer, a Readable stream, a URL object pointing to a file, or a string (file path or content).
- * Uses memory-efficient streaming for files and streams to avoid loading entire contents into memory.
- * @param input The input data to measure.
- * @returns A promise that resolves with the raw size in bytes.
- * @example
- * ```javascript
- * import { rawSize } from "@visulima/fs";
- * import { Readable } from "node:stream";
- * import { writeFile, unlink } from "node:fs/promises";
- * import { join } from "node:path";
- *
- * const text = "Hello, World!";
- * const filePath = join("temp-raw-file.txt");
- *
- * async function main() {
- *   // From Buffer
- *   const buffer = Buffer.from(text);
- *   console.log(`Raw size of buffer: ${await rawSize(buffer)} bytes`);
- *
- *   // From string (content)
- *   console.log(`Raw size of string content: ${await rawSize(text)} bytes`);
- *
- *   // From file path
- *   await writeFile(filePath, text);
- *   console.log(`Raw size of file: ${await rawSize(filePath)} bytes`);
- *
- *   // From URL
- *   const fileUrl = new URL(`file://${filePath}`);
- *   console.log(`Raw size of URL: ${await rawSize(fileUrl)} bytes`);
- *
- *   // From Readable stream
- *   const stream = Readable.from(text);
- *   console.log(`Raw size of stream: ${await rawSize(stream)} bytes`);
- *
- *   await unlink(filePath); // Clean up temp file
- * }
- *
- * main().catch(console.error);
- * ```
- */
-export declare const rawSize: (input: SizeInput) => Promise<number>;
-/**
- * Synchronously calculates the gzipped size of the given input.
- * The input can be a Buffer, a URL object pointing to a file, or a string (file path or content).
- * Note: For Readable streams or very large files, consider using the asynchronous `gzipSize` function for better performance and to avoid blocking.
- * @param input The input data to gzip and measure.
- * @param [options] Optional Zlib options for gzip compression.
- * @returns The gzipped size in bytes.
- * @example
- * ```javascript
- * import { gzipSizeSync } from "@visulima/fs";
- * import { writeFileSync, unlinkSync } from "node:fs";
- * import { join } from "node:path";
- *
- * const text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
- * const filePath = join("temp-sync-file.txt");
- *
- * // From Buffer
- * const buffer = Buffer.from(text);
- * console.log(`Sync Gzip size of buffer: ${gzipSizeSync(buffer)} bytes`);
- *
- * // From string (content)
- * console.log(`Sync Gzip size of string content: ${gzipSizeSync(text)} bytes`);
- *
- * // From file path
- * try {
- *   writeFileSync(filePath, text);
- *   console.log(`Sync Gzip size of file: ${gzipSizeSync(filePath)} bytes`);
- *
- *   // From URL
- *   const fileUrl = new URL(`file://${filePath}`);
- *   console.log(`Sync Gzip size of URL: ${gzipSizeSync(fileUrl)} bytes`);
- * } finally {
- *   try { unlinkSync(filePath); } catch {} // Clean up temp file
- * }
- * ```
- */
-export declare const gzipSizeSync: (input: SizeInputSync, options?: ZlibOptions) => number;
-/**
- * Synchronously calculates the Brotli compressed size of the given input.
- * The input can be a Buffer, a URL object pointing to a file, or a string (file path or content).
- * Note: For Readable streams or very large files, consider using the asynchronous `brotliSize` function for better performance and to avoid blocking.
- * @param input The input data to compress with Brotli and measure.
- * @param [options] Optional Zlib options for Brotli compression.
- * @returns The Brotli compressed size in bytes.
- * @example
- * ```javascript
- * import { brotliSizeSync } from "@visulima/fs";
- * import { writeFileSync, unlinkSync } from "node:fs";
- * import { join } from "node:path";
- *
- * const text = "This is a test string for Brotli compression efficiency, synchronously.";
- * const filePath = join("temp-brotli-sync-file.txt");
- *
- * // From Buffer
- * const buffer = Buffer.from(text);
- * console.log(`Sync Brotli size of buffer: ${brotliSizeSync(buffer)} bytes`);
- *
- * // From string (content)
- * console.log(`Sync Brotli size of string content: ${brotliSizeSync(text)} bytes`);
- *
- * // From file path
- * try {
- *   writeFileSync(filePath, text);
- *   console.log(`Sync Brotli size of file: ${brotliSizeSync(filePath)} bytes`);
- *
- *   // From URL
- *   const fileUrl = new URL(`file://${filePath}`);
- *   console.log(`Sync Brotli size of URL: ${brotliSizeSync(fileUrl)} bytes`);
- * } finally {
- *   try { unlinkSync(filePath); } catch {} // Clean up temp file
- * }
- * ```
- */
-export declare const brotliSizeSync: (input: SizeInputSync, options?: BrotliOptions) => number;
-/**
- * Synchronously calculates the raw (uncompressed) size of the given input.
- * The input can be a Buffer, a URL object pointing to a file, or a string (file path or content).
- * For file paths, it uses `statSync` to get the file size.
- * Note: For Readable streams or very large files, consider using the asynchronous `rawSize` function for better performance and to avoid blocking.
- * @param input The input data to measure.
- * @returns The raw size in bytes.
- * @example
- * ```javascript
- * import { rawSizeSync } from "@visulima/fs";
- * import { writeFileSync, unlinkSync } from "node:fs";
- * import { join } from "node:path";
- *
- * const text = "Hello, Synchronous World!";
- * const filePath = join("temp-raw-sync-file.txt");
- *
- * // From Buffer
- * const buffer = Buffer.from(text);
- * console.log(`Sync Raw size of buffer: ${rawSizeSync(buffer)} bytes`);
- *
- * // From string (content)
- * console.log(`Sync Raw size of string content: ${rawSizeSync(text)} bytes`);
- *
- * // From file path
- * try {
- *   writeFileSync(filePath, text);
- *   console.log(`Sync Raw size of file: ${rawSizeSync(filePath)} bytes`);
- *
- *   // From URL
- *   const fileUrl = new URL(`file://${filePath}`);
- *   console.log(`Sync Raw size of URL: ${rawSizeSync(fileUrl)} bytes`);
- * } finally {
- *   try { unlinkSync(filePath); } catch {} // Clean up temp file
- * }
- * ```
- */
-export declare const rawSizeSync: (input: SizeInputSync) => number;
-export {};
+declare const gzipSize: (input: SizeInput, options?: ZlibOptions) => Promise<number>;
+declare const brotliSize: (input: SizeInput, options?: BrotliOptions) => Promise<number>;
+declare const rawSize: (input: SizeInput) => Promise<number>;
+declare const gzipSizeSync: (input: SizeInputSync, options?: ZlibOptions) => number;
+declare const brotliSizeSync: (input: SizeInputSync, options?: BrotliOptions) => number;
+declare const rawSizeSync: (input: SizeInputSync) => number;
+export { brotliSize, brotliSizeSync, gzipSize, gzipSizeSync, rawSize, rawSizeSync };

package/dist/size.js

@@ -36,10 +36,10 @@ const {
   URL
 } = __cjs_getBuiltinModule("node:url");
 const {
-  gzipSync,
   brotliCompressSync,
-  createBrotliCompress,
-  createGzip
+  gzipSync,
+  createGzip,
+  createBrotliCompress
 } = __cjs_getBuiltinModule("node:zlib");
 import { toPath } from '@visulima/path/utils';
 
@@ -67,7 +67,9 @@ const getCompressedStreamSizeEfficient = async (stream, createCompressor) => {
     compressor.on("data", (chunk) => {
       totalSize += chunk.length;
     });
-    compressor.on("end", () => resolve2(totalSize));
+    compressor.on("end", () => {
+      resolve2(totalSize);
+    });
     compressor.on("error", reject);
     stream.on("error", reject);
     stream.pipe(compressor);

package/dist/toml.d.ts

@@ -0,0 +1,9 @@
+import { a as CompressionType, h as ReadTomlOptions, i as WriteTomlOptions } from "./packem_shared/types.d-CYpAhWov.js";
+import 'node:fs';
+import 'tinyglobby';
+import './options';
+declare const readToml: <R = Record<string, unknown>>(path: URL | string, options?: ReadTomlOptions<CompressionType>) => Promise<R>;
+declare const readTomlSync: (path: URL | string, options?: ReadTomlOptions<CompressionType>) => Record<string, unknown>;
+declare const writeToml: (path: URL | string, data: Record<string, unknown>, options?: WriteTomlOptions) => Promise<void>;
+declare const writeTomlSync: (path: URL | string, data: Record<string, unknown>, options?: WriteTomlOptions) => void;
+export { type ReadTomlOptions, type WriteTomlOptions, readToml, readTomlSync, writeToml, writeTomlSync };

package/dist/toml.js

@@ -0,0 +1,4 @@
+export { default as readToml } from './packem_shared/readToml-B2MHaSes.js';
+export { default as readTomlSync } from './packem_shared/readTomlSync-DNbK8NEb.js';
+export { default as writeToml } from './packem_shared/writeToml-DgTW_-7F.js';
+export { default as writeTomlSync } from './packem_shared/writeTomlSync-DiBiE9ja.js';

package/dist/utils.d.ts

@@ -1,6 +1,15 @@
-export { default as JSONError } from "./error/json-error.d.ts";
-export { default as assertValidFileContents } from "./utils/assert-valid-file-contents.d.ts";
-export { default as assertValidFileOrDirectoryPath } from "./utils/assert-valid-file-or-directory-path.d.ts";
-export { default as parseJson } from "./utils/parse-json.d.ts";
-export { default as stripJsonComments } from "./utils/strip-json-comments.d.ts";
-export { toPath } from "@visulima/path/utils";
+export { J as JSONError } from "./packem_shared/json-error.d-DgKaeuIf.js";
+import { JsonValue } from 'type-fest';
+import { C as CodeFrameOptions, J as JsonReviver } from "./packem_shared/types.d-CYpAhWov.js";
+export { toPath } from '@visulima/path/utils';
+import 'node:fs';
+import 'tinyglobby';
+import './options';
+declare const assertValidFileContents: (contents: any) => void;
+declare const assertValidFileOrDirectoryPath: (fileOrDirectoryPath: any) => void;
+declare function parseJson(string: string, filename?: string, options?: CodeFrameOptions): JsonValue;
+declare function parseJson(string: string, reviver: JsonReviver, fileName?: string, options?: CodeFrameOptions): JsonValue;
+declare const stripJsonComments: (jsonString: string, options?: {
+  whitespace?: boolean;
+}) => string;
+export { assertValidFileContents, assertValidFileOrDirectoryPath, parseJson, stripJsonComments };

package/dist/utils.js

@@ -1,6 +1,6 @@
 export { default as JSONError } from './packem_shared/JSONError-BkHRnInH.js';
 export { default as assertValidFileContents } from './packem_shared/assertValidFileContents-BmcLtsGd.js';
 export { default as assertValidFileOrDirectoryPath } from './packem_shared/assertValidFileOrDirectoryPath-8HANmVjk.js';
-export { default as parseJson } from './packem_shared/parseJson-C8xb-3LR.js';
+export { default as parseJson } from './packem_shared/parseJson-BIp89Xjo.js';
 export { default as stripJsonComments } from './packem_shared/stripJsonComments-vo4k0mpF.js';
 export { toPath } from '@visulima/path/utils';

package/dist/yaml.d.ts

@@ -1,5 +1,14 @@
-export { default as readYaml } from "./read/read-yaml.d.ts";
-export { default as readYamlSync } from "./read/read-yaml-sync.d.ts";
-export type { YamlReplacer } from "./types.d.ts";
-export { default as writeYaml } from "./write/write-yaml.d.ts";
-export { default as writeYamlSync } from "./write/write-yaml-sync.d.ts";
+import { a as CompressionType, R as ReadYamlOptions, Y as YamlReviver, W as WriteYamlOptions, b as JsonReplacer } from "./packem_shared/types.d-CYpAhWov.js";
+export { type c as YamlReplacer } from "./packem_shared/types.d-CYpAhWov.js";
+import 'node:fs';
+import 'tinyglobby';
+import './options';
+declare function readYaml<R = Record<string, unknown>>(path: URL | string, options?: ReadYamlOptions<CompressionType>): Promise<R>;
+declare function readYaml<R = Record<string, unknown>>(path: URL | string, reviver?: YamlReviver, options?: ReadYamlOptions<CompressionType>): Promise<R>;
+declare function readYamlSync(path: URL | string, options?: ReadYamlOptions<CompressionType>): Record<string, unknown>;
+declare function readYamlSync(path: URL | string, reviver?: YamlReviver, options?: ReadYamlOptions<CompressionType>): Record<string, unknown>;
+declare function writeYaml(path: URL | string, data: any, options?: WriteYamlOptions): Promise<void>;
+declare function writeYaml(path: URL | string, data: any, replacer?: JsonReplacer, options?: WriteYamlOptions | number | string): Promise<void>;
+declare function writeYamlSync(path: URL | string, data: any, options?: WriteYamlOptions): void;
+declare function writeYamlSync(path: URL | string, data: any, replacer?: JsonReplacer, options?: WriteYamlOptions | number | string): void;
+export { readYaml, readYamlSync, writeYaml, writeYamlSync };

package/dist/yaml.js

@@ -1,4 +1,4 @@
 export { default as readYaml } from './packem_shared/readYaml-D5q2a0e1.js';
-export { default as readYamlSync } from './packem_shared/readYamlSync-DMV4U-gi.js';
-export { default as writeYaml } from './packem_shared/writeYaml-n4xzYN9a.js';
-export { default as writeYamlSync } from './packem_shared/writeYamlSync-DnOEnP10.js';
+export { default as readYamlSync } from './packem_shared/readYamlSync-BKX-PAfq.js';
+export { default as writeYaml } from './packem_shared/writeYaml-BWCOome-.js';
+export { default as writeYamlSync } from './packem_shared/writeYamlSync-DBVnXmuY.js';