@visulima/fs 5.0.0-alpha.3 → 5.0.0-alpha.31

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

package/dist/toml.d.ts

@@ -0,0 +1,63 @@
+import { a as CompressionType, d as ReadTomlOptions, e as WriteTomlOptions } from "./packem_shared/types.d-C1ygRkw1.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-Dawx4pqK.js";import{default as t}from"./packem_shared/readTomlSync-hnDlOU7g.js";import{default as l}from"./packem_shared/writeToml-BFD91-Sv.js";import{default as d}from"./packem_shared/writeTomlSync-D30hzuuu.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 { C as CodeFrameOptions, J as JsonReviver } from "./packem_shared/types.d-C1ygRkw1.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-Cvp9ycba.js";import{default as a}from"./packem_shared/assertValidFileContents-CbIN7sy7.js";import{default as f}from"./packem_shared/assertValidFileOrDirectoryPath-BTlt945W.js";import{default as m}from"./packem_shared/parseJson-vUriP0eD.js";import{default as d}from"./packem_shared/stripJsonComments-gXl-1fAs.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 { a as CompressionType, R as ReadYamlOptions, Y as YamlReviver, W as WriteYamlOptions, b as JsonReplacer } from "./packem_shared/types.d-C1ygRkw1.js";
+export { type c as YamlReplacer } from "./packem_shared/types.d-C1ygRkw1.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-DuXAtLKY.js";import{default as f}from"./packem_shared/readYamlSync-KlhBWm72.js";import{default as m}from"./packem_shared/writeYaml-BD9JVGkk.js";import{default as d}from"./packem_shared/writeYamlSync-BobkRsmd.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.3",
+  "version": "5.0.0-alpha.31",
   "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,10 @@
     "write-dir",
     "write-file",
     "write-safe",
-    "yaml",
-    "size",
-    "brotli",
-    "gzip"
+    "yaml"
   ],
-  "homepage": "https://www.visulima.com/docs/package/fs",
-  "bugs": {
-    "url": "https://github.com/visulima/visulima/issues"
-  },
+  "homepage": "https://visulima.com/packages/fs/",
+  "bugs": "https://github.com/visulima/visulima/issues",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/visulima/visulima.git",
@@ -96,6 +100,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,6 +124,22 @@
       "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": [
@@ -113,19 +149,34 @@
     "LICENSE.md"
   ],
   "dependencies": {
-    "@visulima/path": "3.0.0-alpha.4",
-    "type-fest": "^5.3.1"
+    "@visulima/path": "3.0.0-alpha.12"
   },
   "peerDependencies": {
-    "yaml": "^2.7.1"
+    "ini": "^7.0.0",
+    "json5": "^2.2.3",
+    "jsonc-parser": "^3.3.1",
+    "smol-toml": "^1.6.1",
+    "yaml": "2.9.0"
   },
   "peerDependenciesMeta": {
+    "ini": {
+      "optional": true
+    },
+    "json5": {
+      "optional": true
+    },
+    "jsonc-parser": {
+      "optional": true
+    },
+    "smol-toml": {
+      "optional": true
+    },
     "yaml": {
       "optional": true
     }
   },
   "engines": {
-    "node": ">=22.13 <=25.x"
+    "node": "^22.14.0 || >=24.10.0"
   },
   "os": [
     "darwin",

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;

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

@@ -1,27 +0,0 @@
-/**
- * Asynchronously ensures that a file exists.
- * If the directory structure for the file does not exist, it is created.
- * If the file already exists, it is not modified.
- * @param filePath The path to the file. Can be a string or a URL object.
- * @returns A Promise that resolves when the file has been created or confirmed to exist.
- * @throws Will throw an error if the path exists and is not a file.
- * @throws Will throw an error if directory or file creation fails for reasons other than the path not existing initially.
- * @example
- * ```typescript
- * import { ensureFile } from "@visulima/fs";
- *
- * (async () => {
- *   try {
- *     await ensureFile("path/to/my/file.txt");
- *     console.log("File ensured!");
- *
- *     await ensureFile(new URL("file:///path/to/another/file.log"));
- *     console.log("Another file ensured!");
- *   } catch (error) {
- *     console.error("Failed to ensure file:", error);
- *   }
- * })();
- * ```
- */
-declare const ensureFile: (filePath: URL | string) => Promise<void>;
-export default ensureFile;

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

@@ -1,16 +0,0 @@
-/**
- * Ensures that the hard link exists.
- * If the directory structure does not exist, it is created.
- * @param source The path to the source file or directory.
- * @param destination The path to the destination link.
- * @example
- * ```javascript
- * import { ensureLinkSync } from "@visulima/fs";
- * import { join } from "node:path";
- *
- * // ensure the link /tmp/foo/bar-link.txt points to /tmp/foo/bar.txt
- * ensureLinkSync(join("/tmp", "foo", "bar.txt"), join("/tmp", "foo", "bar-link.txt"));
- * ```
- */
-declare const ensureLinkSync: (source: URL | string, destination: URL | string) => void;
-export default ensureLinkSync;