@visulima/fs 5.0.0-alpha.2 → 5.0.0-alpha.20

package/dist/size.js

@@ -1,144 +1 @@
-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,
-  statSync,
-  existsSync
-} = __cjs_getBuiltinModule("node:fs");
-const {
-  readFile
-} = __cjs_getBuiltinModule("node:fs/promises");
-const {
-  isAbsolute,
-  resolve
-} = __cjs_getBuiltinModule("node:path");
-const {
-  Readable
-} = __cjs_getBuiltinModule("node:stream");
-const {
-  URL
-} = __cjs_getBuiltinModule("node:url");
-const {
-  gzipSync,
-  brotliCompressSync,
-  createBrotliCompress,
-  createGzip
-} = __cjs_getBuiltinModule("node:zlib");
-import { toPath } from '@visulima/path/utils';
-
-const fileExists = (input) => {
-  if (isAbsolute(input)) {
-    return existsSync(input);
-  }
-  try {
-    return existsSync(resolve(input));
-  } catch {
-    return false;
-  }
-};
-const getStreamSizeEfficient = async (stream) => {
-  let totalSize = 0;
-  for await (const chunk of stream) {
-    totalSize += Buffer.from(chunk).length;
-  }
-  return totalSize;
-};
-const getCompressedStreamSizeEfficient = async (stream, createCompressor) => {
-  let totalSize = 0;
-  const compressor = createCompressor();
-  return await new Promise((resolve2, reject) => {
-    compressor.on("data", (chunk) => {
-      totalSize += chunk.length;
-    });
-    compressor.on("end", () => resolve2(totalSize));
-    compressor.on("error", reject);
-    stream.on("error", reject);
-    stream.pipe(compressor);
-  });
-};
-const processInputEfficiently = async (input, processor, streamProcessor) => {
-  if (input instanceof URL || typeof input === "string") {
-    const path = toPath(input);
-    if (fileExists(path)) {
-      const fileStream = Readable.from(await readFile(path));
-      return await streamProcessor(fileStream);
-    }
-    if (typeof input === "string") {
-      return processor(Buffer.from(input));
-    }
-  }
-  if (input instanceof Readable) {
-    return await streamProcessor(input);
-  }
-  return processor(input);
-};
-const gzipSize = async (input, options) => {
-  const streamProcessor = async (stream) => await getCompressedStreamSizeEfficient(stream, () => createGzip(options));
-  const bufferProcessor = (data) => gzipSync(data, options).length;
-  return await processInputEfficiently(input, bufferProcessor, streamProcessor);
-};
-const brotliSize = async (input, options) => {
-  const streamProcessor = async (stream) => await getCompressedStreamSizeEfficient(stream, () => createBrotliCompress(options));
-  const bufferProcessor = (data) => brotliCompressSync(data, options).length;
-  return await processInputEfficiently(input, bufferProcessor, streamProcessor);
-};
-const rawSize = async (input) => {
-  const streamProcessor = async (stream) => await getStreamSizeEfficient(stream);
-  const bufferProcessor = (data) => data.length;
-  return await processInputEfficiently(input, bufferProcessor, streamProcessor);
-};
-const gzipSizeSync = (input, options) => {
-  if (input instanceof URL || typeof input === "string") {
-    const path = toPath(input);
-    if (fileExists(path)) {
-      return gzipSync(readFileSync(path), options).length;
-    }
-    if (typeof input === "string") {
-      return gzipSync(Buffer.from(input), options).length;
-    }
-  }
-  return gzipSync(input, options).length;
-};
-const brotliSizeSync = (input, options) => {
-  if (input instanceof URL || typeof input === "string") {
-    const path = toPath(input);
-    if (fileExists(path)) {
-      return brotliCompressSync(readFileSync(path), options).length;
-    }
-    if (typeof input === "string") {
-      return brotliCompressSync(Buffer.from(input), options).length;
-    }
-  }
-  return brotliCompressSync(input, options).length;
-};
-const rawSizeSync = (input) => {
-  if (input instanceof URL || typeof input === "string") {
-    const path = toPath(input);
-    if (fileExists(path)) {
-      return statSync(path).size;
-    }
-    if (typeof input === "string") {
-      return Buffer.from(input).length;
-    }
-  }
-  return input.length;
-};
-
-export { brotliSize, brotliSizeSync, gzipSize, gzipSizeSync, rawSize, rawSizeSync };
+var w=Object.defineProperty;var p=(e,t)=>w(e,"name",{value:t,configurable:!0});import{createRequire as _}from"node:module";import{toPath as u}from"@visulima/path/utils";const P=_(import.meta.url),s=typeof globalThis<"u"&&typeof globalThis.process<"u"?globalThis.process:process,i=p(e=>{if(typeof s<"u"&&s.versions&&s.versions.node){const[t,r]=s.versions.node.split(".").map(Number);if(t>22||t===22&&r>=3||t===20&&r>=16)return s.getBuiltinModule(e)}return P(e)},"__cjs_getBuiltinModule"),{readFileSync:d,statSync:B,existsSync:S}=i("node:fs"),{readFile:v}=i("node:fs/promises"),{isAbsolute:j,resolve:E}=i("node:path"),{Readable:z}=i("node:stream"),{URL:c}=i("node:url"),{brotliCompressSync:a,createBrotliCompress:R,gzipSync:f,createGzip:q}=i("node:zlib");var x=Object.defineProperty,n=p((e,t)=>x(e,"name",{value:t,configurable:!0}),"t");const l=n(e=>{if(j(e))return S(e);try{return S(E(e))}catch{return!1}},"fileExists"),C=n(async e=>{let t=0;for await(const r of e)t+=Buffer.from(r).length;return t},"getStreamSizeEfficient"),h=n(async(e,t)=>{let r=0;const o=t();return await new Promise((g,m)=>{o.on("data",b=>{r+=b.length}),o.on("end",()=>{g(r)}),o.on("error",m),e.on("error",m),e.pipe(o)})},"getCompressedStreamSizeEfficient"),y=n(async(e,t,r)=>{if(e instanceof c||typeof e=="string"){const o=u(e);if(l(o)){const g=z.from(await v(o));return await r(g)}if(typeof e=="string")return t(Buffer.from(e))}return e instanceof z?await r(e):t(e)},"processInputEfficiently"),M=n(async(e,t)=>await y(e,n(r=>f(r,t).length,"bufferProcessor"),n(async r=>await h(r,()=>q(t)),"streamProcessor")),"gzipSize"),A=n(async(e,t)=>await y(e,n(r=>a(r,t).length,"bufferProcessor"),n(async r=>await h(r,()=>R(t)),"streamProcessor")),"brotliSize"),G=n(async e=>await y(e,n(t=>t.length,"bufferProcessor"),n(async t=>await C(t),"streamProcessor")),"rawSize"),L=n((e,t)=>{if(e instanceof c||typeof e=="string"){const r=u(e);if(l(r))return f(d(r),t).length;if(typeof e=="string")return f(Buffer.from(e),t).length}return f(e,t).length},"gzipSizeSync"),N=n((e,t)=>{if(e instanceof c||typeof e=="string"){const r=u(e);if(l(r))return a(d(r),t).length;if(typeof e=="string")return a(Buffer.from(e),t).length}return a(e,t).length},"brotliSizeSync"),O=n(e=>{if(e instanceof c||typeof e=="string"){const t=u(e);if(l(t))return B(t).size;if(typeof e=="string")return Buffer.from(e).length}return e.length},"rawSizeSync");export{A as brotliSize,N as brotliSizeSync,M as gzipSize,L as gzipSizeSync,G as rawSize,O as rawSizeSync};

package/dist/toml.d.ts

@@ -0,0 +1,63 @@
+import { C as CompressionType, b as ReadTomlOptions, c as WriteTomlOptions } from "./packem_shared/types.d-BB9TGb5v.js";
+import 'node:fs';
+import 'tinyglobby';
+/**
+* Asynchronously reads a TOML file and parses it into an object.
+* @template R The expected type of the parsed TOML object. Defaults to `Record<string, unknown>`.
+* @param path The path to the TOML file to read. Can be a file URL or a string path.
+* @param options Optional configuration for reading the file. See {@link ReadTomlOptions}.
+* @returns A promise that resolves with the parsed TOML object of type `R`.
+* @example
+* ```javascript
+* import { readToml } from "@visulima/fs/toml";
+* import { join } from "node:path";
+*
+* const config = await readToml(join("path", "to", "config.toml"));
+* ```
+*/
+declare const readToml: <R = Record<string, unknown>>(path: URL | string, options?: ReadTomlOptions<CompressionType>) => Promise<R>;
+/**
+* Synchronously reads a TOML file and parses it into an object.
+* @template R The expected type of the parsed TOML object. Defaults to `Record&lt;string, unknown>`.
+* @param path The path to the TOML file to read. Can be a file URL or a string path.
+* @param options Optional configuration for reading the file. See {@link ReadTomlOptions}.
+* @returns The parsed TOML object of type `R`.
+* @example
+* ```javascript
+* import { readTomlSync } from "@visulima/fs/toml";
+* import { join } from "node:path";
+*
+* const config = readTomlSync(join("path", "to", "config.toml"));
+* ```
+*/
+declare const readTomlSync: (path: URL | string, options?: ReadTomlOptions<CompressionType>) => Record<string, unknown>;
+/**
+* Asynchronously writes an object to a TOML file.
+* @param path The path to the TOML file to write. Can be a file URL or a string path.
+* @param data The data to serialize. Must be a plain object compatible with `smol-toml.stringify`.
+* @param options Optional configuration for writing the TOML file. See {@link WriteTomlOptions}.
+* @returns A promise that resolves when the TOML file has been written.
+* @example
+* ```javascript
+* import { writeToml } from "@visulima/fs/toml";
+* import { join } from "node:path";
+*
+* await writeToml(join("/tmp", "config.toml"), { name: "app", version: 1 });
+* ```
+*/
+declare const writeToml: (path: URL | string, data: Record<string, unknown>, options?: WriteTomlOptions) => Promise<void>;
+/**
+* Synchronously writes an object to a TOML file.
+* @param path The path to the TOML file to write. Can be a file URL or a string path.
+* @param data The data to serialize. Must be a plain object compatible with `smol-toml.stringify`.
+* @param options Optional configuration for writing the TOML file. See {@link WriteTomlOptions}.
+* @example
+* ```javascript
+* import { writeTomlSync } from "@visulima/fs/toml";
+* import { join } from "node:path";
+*
+* writeTomlSync(join("/tmp", "config.toml"), { name: "app", version: 1 });
+* ```
+*/
+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 @@
+import{default as r}from"./packem_shared/readToml-BO5CZK2P.js";import{default as t}from"./packem_shared/readTomlSync-1fKo0R52.js";import{default as l}from"./packem_shared/writeToml-Cj57wZ8B.js";import{default as d}from"./packem_shared/writeTomlSync-B34ZZp0e.js";export{r as readToml,t as readTomlSync,l as writeToml,d as writeTomlSync};

package/dist/utils.d.ts

@@ -1,6 +1,103 @@
-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-DVILOyHc.js";
+import { JsonValue } from 'type-fest';
+import { o as CodeFrameOptions, p as JsonReviver } from "./packem_shared/types.d-BB9TGb5v.js";
+export { toPath } from '@visulima/path/utils';
+import 'node:fs';
+import 'tinyglobby';
+/**
+* Asserts that the provided contents are valid for writing to a file.
+* Valid contents can be a string, an ArrayBuffer, or an ArrayBuffer view (e.g., Uint8Array).
+* @param contents The file contents to validate.
+* @throws {TypeError} If the contents are not a string, ArrayBuffer, or ArrayBuffer view.
+* @example
+* ```javascript
+* import { assertValidFileContents } from "@visulima/fs"; // Assuming this util is exported
+*
+* try {
+*   assertValidFileContents("Hello, world!");
+*   assertValidFileContents(new Uint8Array([72, 101, 108, 108, 111])); // "Hello"
+*   assertValidFileContents(new ArrayBuffer(8));
+*   console.log("File contents are valid.");
+* } catch (error) {
+*   console.error(error.message); // File contents must be a string, ArrayBuffer, or ArrayBuffer view.
+* }
+*
+* try {
+*   assertValidFileContents(123); // Invalid content type
+* } catch (error) {
+*   console.error(error.message); // File contents must be a string, ArrayBuffer, or ArrayBuffer view.
+* }
+* ```
+*/
+declare const assertValidFileContents: (contents: any) => void;
+/**
+* Asserts that the provided path is a valid file or directory path.
+* A valid path must be a non-empty string or a URL instance.
+* @param fileOrDirectoryPath The path to validate.
+* @throws {TypeError} If the path is not a non-empty string or a URL.
+* @example
+* ```javascript
+* import { assertValidFileOrDirectoryPath } from "@visulima/fs"; // Assuming this util is exported
+*
+* try {
+*   assertValidFileOrDirectoryPath("/path/to/file.txt");
+*   assertValidFileOrDirectoryPath(new URL("file:///path/to/file.txt"));
+*   console.log("Path is valid.");
+* } catch (error) {
+*   console.error(error.message); // Path must be a non-empty string or URL.
+* }
+*
+* try {
+*   assertValidFileOrDirectoryPath(""); // Invalid path
+* } catch (error) {
+*   console.error(error.message); // Path must be a non-empty string or URL.
+* }
+* ```
+*/
+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;
+/**
+* Strips comments from a JSON string.
+* Handles both single-line (//) and multi-line (/* ... */) comments.
+* @param jsonString The JSON string possibly containing comments.
+* @param [options] Optional configuration for stripping comments.
+* @param [options.whitespace] If `true` (default), comments are replaced with whitespace to preserve line numbers and character positions. If `false`, comments are removed entirely.
+* @returns The JSON string with comments stripped.
+* @example
+* ```javascript
+* import { stripJsonComments } from "@visulima/fs"; // Assuming this util is exported
+*
+* const jsonWithComments = `{
+*   // This is a single-line comment
+*   "name": "John Doe",
+*   "age": 30, /* This is a
+*   multi-line comment */
+*   "city": "New York"
+* }`;
+*
+* const stripped = stripJsonComments(jsonWithComments);
+* console.log(stripped);
+* // Output (with whitespace=true):
+* // {
+* //
+* //   "name": "John Doe",
+* //   "age": 30, /*
+* //
+* //   "city": "New York"
+* // }
+*
+* const strippedWithoutWhitespace = stripJsonComments(jsonWithComments, { whitespace: false });
+* console.log(strippedWithoutWhitespace);
+* // Output (with whitespace=false):
+* // {
+* //   "name": "John Doe",
+* //   "age": 30,
+* //   "city": "New York"
+* // }
+* ```
+*/
+declare const stripJsonComments: (jsonString: string, options?: {
+  whitespace?: boolean;
+}) => string;
+export { assertValidFileContents, assertValidFileOrDirectoryPath, parseJson, stripJsonComments };

package/dist/utils.js

@@ -1,6 +1 @@
-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 stripJsonComments } from './packem_shared/stripJsonComments-vo4k0mpF.js';
-export { toPath } from '@visulima/path/utils';
+import{default as e}from"./packem_shared/JSONError-D7h6PNWc.js";import{default as a}from"./packem_shared/assertValidFileContents-BZFnXa7K.js";import{default as f}from"./packem_shared/assertValidFileOrDirectoryPath-DgPIPmZT.js";import{default as m}from"./packem_shared/parseJson-Xx6vHYbv.js";import{default as d}from"./packem_shared/stripJsonComments-CzNR77MF.js";import{toPath as x}from"@visulima/path/utils";export{e as JSONError,a as assertValidFileContents,f as assertValidFileOrDirectoryPath,m as parseJson,d as stripJsonComments,x as toPath};

package/dist/yaml.d.ts

@@ -1,5 +1,13 @@
-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 { C as CompressionType, R as ReadYamlOptions, Y as YamlReviver, W as WriteYamlOptions, J as JsonReplacer } from "./packem_shared/types.d-BB9TGb5v.js";
+export { type a as YamlReplacer } from "./packem_shared/types.d-BB9TGb5v.js";
+import 'node:fs';
+import 'tinyglobby';
+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 @@
-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';
+import{default as r}from"./packem_shared/readYaml-DjK_Vqj1.js";import{default as f}from"./packem_shared/readYamlSync-C3h6KA2c.js";import{default as m}from"./packem_shared/writeYaml-BhQX2yN9.js";import{default as d}from"./packem_shared/writeYamlSync-DG01FBeC.js";export{r as readYaml,f as readYamlSync,m as writeYaml,d as writeYamlSync};

package/package.json

@@ -1,19 +1,20 @@
 {
   "name": "@visulima/fs",
-  "version": "5.0.0-alpha.2",
+  "version": "5.0.0-alpha.20",
   "description": "Human friendly file system utilities for Node.js",
   "keywords": [
     "anolilab",
+    "brotli",
     "detect-newline",
     "dir",
     "directory",
-    "eol",
     "empty-dir",
     "ensure",
-    "ensure-file",
     "ensure-dir",
+    "ensure-file",
     "ensure-link",
     "ensure-symlink",
+    "eol",
     "file",
     "files",
     "filesystem",
@@ -23,10 +24,14 @@
     "folder",
     "fs",
     "fs-safe",
+    "gzip",
+    "ini",
+    "json",
+    "json5",
+    "jsonc",
+    "jsonc-parser",
     "look",
     "look-up",
-    "json",
-    "read-json",
     "match",
     "package",
     "parent",
@@ -34,12 +39,16 @@
     "path",
     "read",
     "read-file",
+    "read-json",
     "read-yaml",
     "resolve",
     "safe",
     "search",
-    "std",
+    "size",
+    "smol-toml",
     "standard",
+    "std",
+    "toml",
     "up",
     "visulima",
     "walk",
@@ -48,15 +57,17 @@
     "write-dir",
     "write-file",
     "write-safe",
-    "yaml",
-    "size",
-    "brotli",
-    "gzip"
+    "yaml"
   ],
-  "homepage": "https://www.visulima.com/docs/package/fs",
+  "homepage": "https://visulima.com/packages/fs/",
   "bugs": {
     "url": "https://github.com/visulima/visulima/issues"
   },
+  "license": "MIT",
+  "author": {
+    "name": "Daniel Bannert",
+    "email": "d.bannert@anolilab.de"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/visulima/visulima.git",
@@ -72,13 +83,19 @@
       "url": "https://anolilab.com/support"
     }
   ],
-  "license": "MIT",
-  "author": {
-    "name": "Daniel Bannert",
-    "email": "d.bannert@anolilab.de"
-  },
-  "sideEffects": false,
+  "files": [
+    "dist/**",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE.md"
+  ],
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
   "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -96,6 +113,22 @@
       "types": "./dist/yaml.d.ts",
       "default": "./dist/yaml.js"
     },
+    "./toml": {
+      "types": "./dist/toml.d.ts",
+      "default": "./dist/toml.js"
+    },
+    "./jsonc": {
+      "types": "./dist/jsonc.d.ts",
+      "default": "./dist/jsonc.js"
+    },
+    "./json5": {
+      "types": "./dist/json5.d.ts",
+      "default": "./dist/json5.js"
+    },
+    "./ini": {
+      "types": "./dist/ini.d.ts",
+      "default": "./dist/ini.js"
+    },
     "./size": {
       "types": "./dist/size.d.ts",
       "default": "./dist/size.js"
@@ -104,36 +137,56 @@
       "types": "./dist/eol.d.ts",
       "default": "./dist/eol.js"
     },
+    "./glob": {
+      "types": "./dist/glob.d.ts",
+      "default": "./dist/glob.js"
+    },
+    "./glob-parent": {
+      "types": "./dist/glob-parent.d.ts",
+      "default": "./dist/glob-parent.js"
+    },
+    "./is-glob": {
+      "types": "./dist/is-glob.d.ts",
+      "default": "./dist/is-glob.js"
+    },
+    "./match": {
+      "types": "./dist/match.d.ts",
+      "default": "./dist/match.js"
+    },
     "./package.json": "./package.json"
   },
-  "files": [
-    "dist/**",
-    "README.md",
-    "CHANGELOG.md",
-    "LICENSE.md"
-  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "dependencies": {
-    "@visulima/path": "3.0.0-alpha.3",
-    "type-fest": "^5.3.0"
+    "@visulima/path": "3.0.0-alpha.10"
   },
   "peerDependencies": {
-    "yaml": "^2.7.1"
+    "ini": "^6.0.0",
+    "json5": "^2.2.3",
+    "jsonc-parser": "^3.3.1",
+    "smol-toml": "^1.6.1",
+    "yaml": "2.8.4"
   },
   "peerDependenciesMeta": {
+    "ini": {
+      "optional": true
+    },
+    "json5": {
+      "optional": true
+    },
+    "jsonc-parser": {
+      "optional": true
+    },
+    "smol-toml": {
+      "optional": true
+    },
     "yaml": {
       "optional": true
     }
   },
   "engines": {
-    "node": ">=22.13 <=25.x"
-  },
-  "os": [
-    "darwin",
-    "linux",
-    "win32"
-  ],
-  "publishConfig": {
-    "access": "public",
-    "provenance": true
+    "node": "^22.14.0 || >=24.10.0"
   }
 }

package/dist/constants.d.ts

@@ -1,42 +0,0 @@
-/**
- * Constant to check if the path is visible to the calling process.
- * Corresponds to `node:fs.constants.F_OK`.
- */
-export declare const F_OK: number;
-/**
- * Constant to check if the path is readable to the calling process.
- * Corresponds to `node:fs.constants.R_OK`.
- */
-export declare const R_OK: number;
-/**
- * Constant to check if the path is writable to the calling process.
- * Corresponds to `node:fs.constants.W_OK`.
- */
-export declare const W_OK: number;
-/**
- * Constant to check if the path is executable by the calling process.
- * Corresponds to `node:fs.constants.X_OK`.
- */
-export declare const X_OK: number;
-/**
- * A special symbol that can be returned by the matcher function in `findUp` or `findUpSync`
- * to stop the search process prematurely.
- */
-export declare const FIND_UP_STOP: symbol;
-/**
- * Regular expression for stripping comments from JSON.
- * Matches:
- * 1. Quoted strings: "example \"escaped\" string"
- * 2. Single-line comments: // comment
- * 3. Multi-line comments: /* comment *\/
- * @example
- * const json = `{
- *   // comment
- *   "key": "value" // comment
- * }`;
- * json.replace(INTERNAL_STRIP_JSON_REGEX, (match) =>
- *   /^"/.test(match) ? match : ''
- * );
- * // Result: { "key": "value" }
- */
-export declare const INTERNAL_STRIP_JSON_REGEX: RegExp;

package/dist/ensure/ensure-dir-sync.d.ts

@@ -1,14 +0,0 @@
-/**
- * Ensures that the directory exists.
- * If the directory structure does not exist, it is created. Like mkdir -p.
- * @param directory The path to the directory to ensure exists.
- * @example
- * ```javascript
- * import ensureDirSync from "@visulima/fs/ensure/ensure-dir-sync";
- *
- * ensureDirSync("/tmp/foo/bar/baz");
- * // Creates the directory structure /tmp/foo/bar/baz if it doesn't exist
- * ```
- */
-declare const ensureDirSync: (directory: URL | string) => void;
-export default ensureDirSync;

package/dist/ensure/ensure-dir.d.ts

@@ -1,14 +0,0 @@
-/**
- * Ensures that the directory exists.
- * If the directory structure does not exist, it is created. Like mkdir -p.
- * @param directory The path to the directory to ensure exists.
- * @example
- * ```javascript
- * import ensureDir from "@visulima/fs/ensure/ensure-dir";
- *
- * await ensureDir("/tmp/foo/bar/baz");
- * // Creates the directory structure /tmp/foo/bar/baz if it doesn't exist
- * ```
- */
-declare const ensureDir: (directory: URL | string) => Promise<void>;
-export default ensureDir;

package/dist/ensure/ensure-file-sync.d.ts

@@ -1,15 +0,0 @@
-/**
- * Ensures that the file exists.
- * If the file that is requested to be created is in directories that do not exist,
- * these directories are created. If the file already exists, it is NOT MODIFIED.
- * @param filePath The path to the file to ensure exists.
- * @example
- * ```javascript
- * import { ensureFileSync } from "@visulima/fs";
- *
- * ensureFileSync("/tmp/foo/bar/baz.txt");
- * // Creates the file /tmp/foo/bar/baz.txt and any missing parent directories if they don't exist
- * ```
- */
-declare const ensureFileSync: (filePath: URL | string) => void;
-export default ensureFileSync;