@visulima/fs 4.1.0 → 5.0.0-alpha.10

package/dist/packem_shared/readJson5Sync-8WS2yUok.js

@@ -0,0 +1,15 @@
+import JSON5 from 'json5';
+import readFileSync from './readFileSync-gm9yfIhh.js';
+
+function readJson5Sync(path, reviver, options) {
+  if (reviver && typeof reviver === "object") {
+    options = reviver;
+    reviver = void 0;
+  }
+  const { beforeParse, buffer, compression, encoding = "utf8", flag } = options ?? {};
+  const content = readFileSync(path, { buffer, compression, encoding, flag });
+  const input = typeof beforeParse === "function" ? beforeParse(content) : content;
+  return JSON5.parse(input, reviver);
+}
+
+export { readJson5Sync as default };

package/dist/packem_shared/{readJsonSync-BTlwqLNV.js → readJsonSync-BMEmCcJ6.js}

@@ -1,6 +1,6 @@
 import { toPath } from '@visulima/path/utils';
-import parseJson from './parseJson-C8xb-3LR.js';
-import readFileSync from './readFileSync-BDgEnnqT.js';
+import parseJson from './parseJson-BIp89Xjo.js';
+import readFileSync from './readFileSync-gm9yfIhh.js';
 
 function readJsonSync(path, reviver, options) {
   if (typeof reviver === "object") {

package/dist/packem_shared/readJsonc-j-OS-APg.js

@@ -0,0 +1,28 @@
+import { toPath } from '@visulima/path/utils';
+import { parse, printParseErrorCode } from 'jsonc-parser';
+import JSONError from './JSONError-BkHRnInH.js';
+import readFile from './readFile-Iz7kvCCk.js';
+import { i as indexToLineColumn, c as codeFrame } from './indexToLineColumn-BUb0GPKl-BF770uX7.js';
+
+const throwIfJsoncErrors = (errors, input, filePath, codeFrameOptions) => {
+  if (errors.length === 0) {
+    return;
+  }
+  const first = errors[0];
+  const location = indexToLineColumn(input, first.offset);
+  const jsonError = new JSONError(`${printParseErrorCode(first.error)} at offset ${first.offset}`);
+  jsonError.fileName = filePath;
+  jsonError.codeFrame = codeFrame(input, { start: location }, { tabWidth: false, ...codeFrameOptions });
+  throw jsonError;
+};
+const readJsonc = async (path, options) => {
+  const { allowEmptyContent, allowTrailingComma = true, beforeParse, buffer, color, compression, disallowComments, encoding = "utf8", flag } = options ?? {};
+  const content = await readFile(path, { buffer, compression, encoding, flag });
+  const input = typeof beforeParse === "function" ? beforeParse(content) : content;
+  const errors = [];
+  const result = parse(input, errors, { allowEmptyContent, allowTrailingComma, disallowComments });
+  throwIfJsoncErrors(errors, input, toPath(path), { color });
+  return result;
+};
+
+export { readJsonc as default, throwIfJsoncErrors };

package/dist/packem_shared/readJsoncSync-Aw6EMlWO.js

@@ -0,0 +1,16 @@
+import { toPath } from '@visulima/path/utils';
+import { parse } from 'jsonc-parser';
+import readFileSync from './readFileSync-gm9yfIhh.js';
+import { throwIfJsoncErrors } from './readJsonc-j-OS-APg.js';
+
+const readJsoncSync = (path, options) => {
+  const { allowEmptyContent, allowTrailingComma = true, beforeParse, buffer, color, compression, disallowComments, encoding = "utf8", flag } = options ?? {};
+  const content = readFileSync(path, { buffer, compression, encoding, flag });
+  const input = typeof beforeParse === "function" ? beforeParse(content) : content;
+  const errors = [];
+  const result = parse(input, errors, { allowEmptyContent, allowTrailingComma, disallowComments });
+  throwIfJsoncErrors(errors, input, toPath(path), { color });
+  return result;
+};
+
+export { readJsoncSync as default };

package/dist/packem_shared/readToml-B2MHaSes.js

@@ -0,0 +1,9 @@
+import { parse } from 'smol-toml';
+import readFile from './readFile-Iz7kvCCk.js';
+
+const readToml = async (path, options) => {
+  const content = await readFile(path, { encoding: "utf8", ...options });
+  return parse(content);
+};
+
+export { readToml as default };

package/dist/packem_shared/readTomlSync-DNbK8NEb.js

@@ -0,0 +1,9 @@
+import { parse } from 'smol-toml';
+import readFileSync from './readFileSync-gm9yfIhh.js';
+
+const readTomlSync = (path, options) => {
+  const content = readFileSync(path, { encoding: "utf8", ...options });
+  return parse(content);
+};
+
+export { readTomlSync as default };

package/dist/packem_shared/{readYaml-Cj6HxRoa.js → readYaml-D5q2a0e1.js}

@@ -1,5 +1,5 @@
 import { parse } from 'yaml';
-import readFile from './readFile-BcK0rkht.js';
+import readFile from './readFile-Iz7kvCCk.js';
 
 async function readYaml(path, reviver, options) {
   const { buffer, compression, encoding = "utf8", flag, ...parseOptions } = options ?? {};

package/dist/packem_shared/{readYamlSync-D3_iAKVv.js → readYamlSync-BKX-PAfq.js}

@@ -1,5 +1,5 @@
 import { parse } from 'yaml';
-import readFileSync from './readFileSync-BDgEnnqT.js';
+import readFileSync from './readFileSync-gm9yfIhh.js';
 
 function readYamlSync(path, reviver, options) {
   const { buffer, compression, encoding = "utf8", flag, ...parseOptions } = options ?? {};

package/dist/packem_shared/{remove-_oDY3uKo.js → remove-C8_gl3jF.js}

@@ -22,6 +22,7 @@ const {
   rm
 } = __cjs_getBuiltinModule("node:fs/promises");
 import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-8HANmVjk.js';
+import { b as buildRmOptions } from './build-rm-options-Cl3VDY4O.js';
 
 const remove = async (path, options = {}) => {
   assertValidFileOrDirectoryPath(path);
@@ -30,7 +31,7 @@ const remove = async (path, options = {}) => {
   } catch {
   }
   try {
-    await rm(path, { force: true, maxRetries: options?.maxRetries, recursive: true, retryDelay: options?.retryDelay });
+    await rm(path, buildRmOptions(options));
   } catch {
   }
 };

package/dist/packem_shared/{removeSync-DETRj7Qn.js → removeSync-BJR_wTwN.js}

@@ -22,6 +22,7 @@ const {
   rmSync
 } = __cjs_getBuiltinModule("node:fs");
 import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-8HANmVjk.js';
+import { b as buildRmOptions } from './build-rm-options-Cl3VDY4O.js';
 
 const removeSync = (path, options = {}) => {
   assertValidFileOrDirectoryPath(path);
@@ -30,7 +31,7 @@ const removeSync = (path, options = {}) => {
   } catch {
   }
   try {
-    rmSync(path, { force: true, maxRetries: options?.maxRetries, recursive: true, retryDelay: options?.retryDelay });
+    rmSync(path, buildRmOptions(options));
   } catch {
   }
 };

package/dist/packem_shared/{sanitize-lOzE6k2A.js → sanitize-BZoLN9Fg.js}

@@ -73,7 +73,7 @@ const cleanWindowsName = (name) => {
     const extension = name.slice(lastDotIndex);
     let cleanedBaseName = baseName;
     while (cleanedBaseName.length > 0) {
-      const char = cleanedBaseName[cleanedBaseName.length - 1];
+      const char = cleanedBaseName.at(-1);
       if (char === void 0 || !TRIM_CHARS.has(char)) {
         break;
       }
@@ -86,7 +86,7 @@ const cleanWindowsName = (name) => {
   }
   let cleaned = name;
   while (cleaned.length > 0) {
-    const char = cleaned[cleaned.length - 1];
+    const char = cleaned.at(-1);
     if (char === void 0 || !TRIM_CHARS.has(char)) {
       break;
     }
@@ -104,7 +104,7 @@ const isWindowsReservedName = (name) => {
   }
   let trimmed = name;
   while (trimmed.length > 0) {
-    const char = trimmed[trimmed.length - 1];
+    const char = trimmed.at(-1);
     if (char === void 0 || !TRIM_CHARS.has(char)) {
       break;
     }

package/dist/packem_shared/{stripJsonComments-21XWVDwP.js → stripJsonComments-vo4k0mpF.js}

@@ -1,4 +1,4 @@
-import { INTERNAL_STRIP_JSON_REGEX } from './F_OK-BalxCn9n.js';
+import { INTERNAL_STRIP_JSON_REGEX } from './F_OK-MldBaGxb.js';
 
 const stripJsonComments = (jsonString, { whitespace = true } = {}) => (
   // This regular expression translates to:

package/dist/packem_shared/types.d-BrSrwTmO.d.ts

@@ -0,0 +1,145 @@
+import { PathLike, Dirent } from 'node:fs';
+import { GlobOptions as GlobOptions$1 } from 'tinyglobby';
+import { DocumentOptions, ParseOptions, SchemaOptions, ToJSOptions, CreateNodeOptions, ToStringOptions } from './options';
+declare const F_OK: number;
+declare const R_OK: number;
+declare const W_OK: number;
+declare const X_OK: number;
+declare const FIND_UP_STOP: symbol;
+type ColorizeMethod = (value: string) => string;
+type JsoncParseOptions = {
+  allowEmptyContent?: boolean;
+  allowTrailingComma?: boolean;
+  disallowComments?: boolean;
+};
+type JsoncFormattingOptions = {
+  eol?: string;
+  insertFinalNewline?: boolean;
+  insertSpaces?: boolean;
+  keepLines?: boolean;
+  tabSize?: number;
+};
+type IniEncodeOptions = {
+  align?: boolean;
+  bracketedArray?: boolean;
+  newline?: boolean;
+  platform?: string;
+  section?: string;
+  sort?: boolean;
+  whitespace?: boolean;
+};
+type Json5Replacer = (number | string)[] | ((this: unknown, key: string, value: unknown) => unknown) | null;
+type GlobOptions = Omit<GlobOptions$1, "patterns">;
+interface WalkOptions {
+  extensions?: string[];
+  followSymlinks?: boolean;
+  includeDirs?: boolean;
+  includeFiles?: boolean;
+  includeSymlinks?: boolean;
+  match?: (RegExp | string)[];
+  maxDepth?: number;
+  skip?: (RegExp | string)[];
+}
+interface WalkEntry extends Pick<Dirent, "isDirectory" | "isFile" | "isSymbolicLink" | "name"> {
+  path: string;
+}
+type CompressionType = "brotli" | "gzip" | "none";
+type ReadFileEncoding = "ascii" | "base64" | "base64url" | "hex" | "latin1" | "ucs-2" | "ucs2" | "utf-8" | "utf-16le" | "utf8" | "utf16le";
+type ReadFileOptions<C> = {
+  buffer?: boolean;
+  compression?: C;
+  encoding?: ReadFileEncoding;
+  flag?: number | string;
+};
+type ContentType<O = undefined> = O extends {
+  buffer: true;
+} ? Buffer : string;
+type JsonReviver = Parameters<(typeof JSON)["parse"]>["1"];
+type CodeFrameLocation = {
+  column?: number;
+  line: number;
+};
+type CodeFrameOptions = {
+  color?: {
+    gutter?: ColorizeMethod;
+    marker?: ColorizeMethod;
+    message?: ColorizeMethod;
+  };
+};
+type ReadJsonOptions = CodeFrameOptions & {
+  beforeParse?: (source: string) => string;
+};
+type WriteFileOptions = {
+  chown?: {
+    gid: number;
+    uid: number;
+  };
+  encoding?: BufferEncoding | null;
+  flag?: string;
+  mode?: number;
+  overwrite?: boolean;
+  recursive?: boolean;
+};
+type JsonReplacer = (number | string)[] | ((this: unknown, key: string, value: unknown) => unknown) | null;
+type YamlReplacer = JsonReplacer;
+type WriteJsonOptions = WriteFileOptions & {
+  detectIndent?: boolean;
+  indent?: number | string;
+  replacer?: JsonReplacer;
+  stringify?: (data: unknown, replacer: JsonReplacer, space: number | string | undefined) => string;
+};
+type FindUpOptions = {
+  allowSymlinks?: boolean;
+  cwd?: URL | string;
+  stopAt?: URL | string;
+  type?: "directory" | "file";
+};
+type FindUpNameFnResult = PathLike | Promise<PathLike | typeof FIND_UP_STOP> | typeof FIND_UP_STOP | undefined;
+type FindUpName = string[] | string | ((directory: string) => FindUpNameFnResult);
+type FindUpNameSyncFnResult = PathLike | typeof FIND_UP_STOP | undefined;
+type FindUpNameSync = string[] | string | ((directory: string) => FindUpNameSyncFnResult);
+type RetryOptions = {
+  maxRetries?: number;
+  retryDelay?: number;
+};
+type ReadYamlOptions<C> = DocumentOptions & ParseOptions & ReadFileOptions<C> & SchemaOptions & ToJSOptions;
+type YamlReviver = (key: unknown, value: unknown) => unknown;
+type WriteYamlExtras = {
+  replacer?: JsonReplacer;
+  space?: number | string;
+};
+type WriteYamlOptions = CreateNodeOptions & DocumentOptions & ParseOptions & SchemaOptions & ToStringOptions & WriteFileOptions & WriteYamlExtras;
+type ReadTomlOptions<C> = ReadFileOptions<C>;
+type WriteTomlOptions = WriteFileOptions;
+type ReadJsoncExtras = {
+  beforeParse?: (source: string) => string;
+};
+type ReadJsoncOptions<C> = CodeFrameOptions & JsoncParseOptions & ReadFileOptions<C> & ReadJsoncExtras;
+type WriteJsoncOptions = WriteFileOptions & {
+  detectIndent?: boolean;
+  formattingOptions?: JsoncFormattingOptions;
+  indent?: number | string;
+  preserveComments?: boolean;
+  replacer?: JsonReplacer;
+};
+type Json5Reviver = (this: unknown, key: string, value: unknown) => unknown;
+type ReadJson5Extras = {
+  beforeParse?: (source: string) => string;
+};
+type ReadJson5Options<C> = CodeFrameOptions & ReadFileOptions<C> & ReadJson5Extras;
+type WriteJson5Options = WriteFileOptions & {
+  detectIndent?: boolean;
+  indent?: number | string;
+  quote?: string;
+  replacer?: Json5Replacer;
+};
+type ReadIniOptions<C> = ReadFileOptions<C> & {
+  bracketedArray?: boolean;
+};
+type IniLineEnding = "\n" | "\r\n";
+type WriteIniExtras = {
+  eol?: IniLineEnding;
+  preserveStyle?: boolean;
+};
+type WriteIniOptions = IniEncodeOptions & WriteFileOptions & WriteIniExtras;
+export { CodeFrameLocation as A, FIND_UP_STOP as B, CodeFrameOptions as C, F_OK as D, FindUpNameFnResult as E, FindUpName as F, GlobOptions as G, FindUpNameSyncFnResult as H, IniEncodeOptions as I, JsonReviver as J, R_OK as K, ReadFileEncoding as L, W_OK as M, ReadTomlOptions as R, WriteTomlOptions as W, X_OK as X, YamlReviver as Y, CompressionType as a, ReadYamlOptions as b, WriteYamlOptions as c, JsonReplacer as d, YamlReplacer as e, ReadJsoncOptions as f, WriteJsoncOptions as g, JsoncFormattingOptions as h, JsoncParseOptions as i, ReadIniOptions as j, WriteIniOptions as k, IniLineEnding as l, ReadJson5Options as m, Json5Reviver as n, WriteJson5Options as o, Json5Replacer as p, WalkOptions as q, FindUpOptions as r, FindUpNameSync as s, WalkEntry as t, ReadFileOptions as u, ContentType as v, ReadJsonOptions as w, RetryOptions as x, WriteFileOptions as y, WriteJsonOptions as z };

package/dist/packem_shared/{walk-BhTbpr3y.js → walk-CSZgCuDx.js}

@@ -24,7 +24,7 @@ const {
 } = __cjs_getBuiltinModule("node:fs/promises");
 import { resolve, join, normalize, basename } from '@visulima/path';
 import { toPath } from '@visulima/path/utils';
-import WalkError from './WalkError-DUdQd6FT.js';
+import WalkError from './WalkError-DER5A43G.js';
 import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-8HANmVjk.js';
 import { g as globToRegExp, w as walkInclude } from './walk-include-CZco7BvN.js';
 
@@ -54,9 +54,16 @@ async function* walk(directory, {
   if (maxDepth < 0) {
     return;
   }
-  const mappedMatch = match ? match.map((pattern) => typeof pattern === "string" ? globToRegExp(pattern) : pattern) : void 0;
-  const mappedSkip = skip ? skip.map((pattern) => typeof pattern === "string" ? globToRegExp(pattern) : pattern) : void 0;
-  directory = resolve(toPath(directory));
+  const mappedMatch = match ? match.map(
+    // eslint-disable-next-line no-confusing-arrow
+    (pattern) => typeof pattern === "string" ? globToRegExp(pattern) : pattern
+  ) : void 0;
+  const mappedSkip = skip ? skip.map(
+    // eslint-disable-next-line no-confusing-arrow
+    (pattern) => typeof pattern === "string" ? globToRegExp(pattern) : pattern
+  ) : void 0;
+  const resolvedDirectory = resolve(toPath(directory));
+  directory = resolvedDirectory;
   if (includeDirectories && walkInclude(directory, extensions, mappedMatch, mappedSkip)) {
     yield await _createWalkEntry(directory);
   }
@@ -64,26 +71,28 @@ async function* walk(directory, {
     return;
   }
   try {
-    for await (const entry of await readdir(directory, {
+    const entries = await readdir(directory, {
       withFileTypes: true
-    })) {
+    });
+    for (const entry of entries) {
       let path = join(directory, entry.name);
       if (entry.isSymbolicLink()) {
         if (followSymlinks) {
           path = await realpath(path);
         } else if (includeSymlinks && walkInclude(path, extensions, mappedMatch, mappedSkip)) {
           yield {
-            isDirectory: entry.isDirectory,
-            isFile: entry.isFile,
-            isSymbolicLink: entry.isSymbolicLink,
+            isDirectory: () => entry.isDirectory(),
+            isFile: () => entry.isFile(),
+            isSymbolicLink: () => entry.isSymbolicLink(),
             name: entry.name,
             path
           };
+          continue;
         } else {
           continue;
         }
       }
-      if (entry.isSymbolicLink() || entry.isDirectory()) {
+      if (entry.isDirectory()) {
         yield* walk(path, {
           extensions,
           followSymlinks,

package/dist/packem_shared/{walkSync-DDBq95s8.js → walkSync-C4Cy28xb.js}

@@ -24,7 +24,7 @@ const {
 } = __cjs_getBuiltinModule("node:fs");
 import { resolve, join, normalize, basename } from '@visulima/path';
 import { toPath } from '@visulima/path/utils';
-import WalkError from './WalkError-DUdQd6FT.js';
+import WalkError from './WalkError-DER5A43G.js';
 import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-8HANmVjk.js';
 import { g as globToRegExp, w as walkInclude } from './walk-include-CZco7BvN.js';
 
@@ -32,9 +32,9 @@ const _createWalkEntry = (path) => {
   const normalizePath = normalize(path);
   const info = statSync(normalizePath);
   return {
-    isDirectory: info.isDirectory,
-    isFile: info.isFile,
-    isSymbolicLink: info.isSymbolicLink,
+    isDirectory: () => info.isDirectory(),
+    isFile: () => info.isFile(),
+    isSymbolicLink: () => info.isSymbolicLink(),
     name: basename(normalizePath),
     path: normalizePath
   };
@@ -53,9 +53,16 @@ function* walkSync(directory, {
   if (maxDepth < 0) {
     return;
   }
-  const mappedMatch = match ? match.map((pattern) => typeof pattern === "string" ? globToRegExp(pattern) : pattern) : void 0;
-  const mappedSkip = skip ? skip.map((pattern) => typeof pattern === "string" ? globToRegExp(pattern) : pattern) : void 0;
-  directory = resolve(toPath(directory));
+  const mappedMatch = match ? match.map(
+    // eslint-disable-next-line no-confusing-arrow
+    (pattern) => typeof pattern === "string" ? globToRegExp(pattern) : pattern
+  ) : void 0;
+  const mappedSkip = skip ? skip.map(
+    // eslint-disable-next-line no-confusing-arrow
+    (pattern) => typeof pattern === "string" ? globToRegExp(pattern) : pattern
+  ) : void 0;
+  const resolvedDirectory = resolve(toPath(directory));
+  directory = resolvedDirectory;
   if (includeDirectories && walkInclude(directory, extensions, mappedMatch, mappedSkip)) {
     yield _createWalkEntry(directory);
   }
@@ -63,26 +70,28 @@ function* walkSync(directory, {
     return;
   }
   try {
-    for (const entry of readdirSync(directory, {
+    const entries = readdirSync(directory, {
       withFileTypes: true
-    })) {
+    });
+    for (const entry of entries) {
       let path = join(directory, entry.name);
       if (entry.isSymbolicLink()) {
         if (followSymlinks) {
           path = realpathSync(path);
         } else if (includeSymlinks && walkInclude(path, extensions, mappedMatch, mappedSkip)) {
           yield {
-            isDirectory: entry.isDirectory,
-            isFile: entry.isFile,
-            isSymbolicLink: entry.isSymbolicLink,
+            isDirectory: () => entry.isDirectory(),
+            isFile: () => entry.isFile(),
+            isSymbolicLink: () => entry.isSymbolicLink(),
             name: entry.name,
             path: normalize(path)
           };
+          continue;
         } else {
           continue;
         }
       }
-      if (entry.isSymbolicLink() || entry.isDirectory()) {
+      if (entry.isDirectory()) {
         yield* walkSync(path, {
           extensions,
           followSymlinks,
@@ -95,9 +104,9 @@ function* walkSync(directory, {
         });
       } else if (entry.isFile() && includeFiles && walkInclude(path, extensions, mappedMatch, mappedSkip)) {
         yield {
-          isDirectory: entry.isDirectory,
-          isFile: entry.isFile,
-          isSymbolicLink: entry.isSymbolicLink,
+          isDirectory: () => entry.isDirectory(),
+          isFile: () => entry.isFile(),
+          isSymbolicLink: () => entry.isSymbolicLink(),
           name: entry.name,
           path: normalize(path)
         };

package/dist/packem_shared/{writeFile-NT1fLEEe.js → writeFile-B8HX0JIQ.js}

@@ -28,8 +28,8 @@ const {
 } = __cjs_getBuiltinModule("node:fs/promises");
 import { dirname } from '@visulima/path';
 import { toPath } from '@visulima/path/utils';
-import { F_OK } from './F_OK-BalxCn9n.js';
-import isAccessible from './isAccessible-iOp0Bou6.js';
+import { F_OK } from './F_OK-MldBaGxb.js';
+import isAccessible from './isAccessible-DuVrTNFV.js';
 import assertValidFileContents from './assertValidFileContents-BmcLtsGd.js';
 import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-8HANmVjk.js';
 import { t as toUint8Array } from './to-uint-8-array-Dz2nF1y1.js';
@@ -58,9 +58,7 @@ const writeFile = async (path, content, options) => {
     await writeFile$1(temporaryPath, toUint8Array(content), { encoding: options.encoding, flag: options.flag });
     if (pathExists && !options.overwrite) {
       stat$1 = await stat(path);
-      if (options.chown === void 0) {
-        options.chown = { gid: stat$1.gid, uid: stat$1.uid };
-      }
+      options.chown ??= { gid: stat$1.gid, uid: stat$1.uid };
       await rename(path, `${path}.bak`);
     }
     if (options.chown) {

package/dist/packem_shared/{writeFileSync-Bj5UDSf0.js → writeFileSync-DB8vv8xR.js}

@@ -28,8 +28,8 @@ const {
 } = __cjs_getBuiltinModule("node:fs");
 import { dirname } from '@visulima/path';
 import { toPath } from '@visulima/path/utils';
-import { F_OK } from './F_OK-BalxCn9n.js';
-import isAccessibleSync from './isAccessibleSync-38BmiIcx.js';
+import { F_OK } from './F_OK-MldBaGxb.js';
+import isAccessibleSync from './isAccessibleSync-DI8mM0fA.js';
 import assertValidFileContents from './assertValidFileContents-BmcLtsGd.js';
 import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-8HANmVjk.js';
 import { t as toUint8Array } from './to-uint-8-array-Dz2nF1y1.js';
@@ -58,9 +58,7 @@ const writeFileSync = (path, content, options) => {
     writeFileSync$1(temporaryPath, toUint8Array(content), { encoding: options.encoding, flag: options.flag });
     if (pathExists && !options.overwrite) {
       stat = statSync(path);
-      if (options.chown === void 0) {
-        options.chown = { gid: stat.gid, uid: stat.uid };
-      }
+      options.chown ??= { gid: stat.gid, uid: stat.uid };
       renameSync(path, `${path}.bak`);
     }
     if (options.chown) {

package/dist/packem_shared/writeIni-i55QrL8y.js

@@ -0,0 +1,65 @@
+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 { parse, stringify } from 'ini';
+import { R_OK } from './F_OK-MldBaGxb.js';
+import isAccessible from './isAccessible-DuVrTNFV.js';
+import { d as detectIniStyle, m as mergeIniPreservingLines } from './ini-preserve-Dq_Q_Jgb.js';
+import writeFile from './writeFile-B8HX0JIQ.js';
+
+const writeIni = async (path, data, options = {}) => {
+  const { eol, preserveStyle = true, whitespace, ...rest } = options;
+  const { align, bracketedArray, newline, platform, section, sort, ...writeOptions } = rest;
+  let resolvedEol = eol;
+  let resolvedWhitespace = whitespace;
+  let existingText;
+  let oldData;
+  const accessible = preserveStyle ? await isAccessible(path, R_OK) : false;
+  if (accessible) {
+    try {
+      existingText = await readFile(path, "utf8");
+      oldData = parse(existingText, { bracketedArray: bracketedArray ?? true });
+      const detected = detectIniStyle(existingText);
+      resolvedEol ??= detected.eol;
+      resolvedWhitespace ??= detected.whitespace;
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  const encodeOptions = { align, bracketedArray, newline, platform, section, sort, whitespace: resolvedWhitespace };
+  const freshStringify = (value, sectionName) => stringify(value, sectionName === void 0 ? encodeOptions : { ...encodeOptions, section: sectionName });
+  let output;
+  if (existingText !== void 0 && oldData) {
+    output = mergeIniPreservingLines(existingText, oldData, data, freshStringify, {
+      eol: resolvedEol ?? "\n"});
+  } else {
+    output = freshStringify(data, section);
+    if (resolvedEol === "\r\n") {
+      output = output.replaceAll(/\r?\n/g, "\r\n");
+    }
+  }
+  await writeFile(path, output, writeOptions);
+};
+
+export { writeIni as default };

package/dist/packem_shared/writeIniSync-CLqJE5t3.js

@@ -0,0 +1,64 @@
+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 { parse, stringify } from 'ini';
+import { R_OK } from './F_OK-MldBaGxb.js';
+import isAccessibleSync from './isAccessibleSync-DI8mM0fA.js';
+import { d as detectIniStyle, m as mergeIniPreservingLines } from './ini-preserve-Dq_Q_Jgb.js';
+import writeFileSync from './writeFileSync-DB8vv8xR.js';
+
+const writeIniSync = (path, data, options = {}) => {
+  const { eol, preserveStyle = true, whitespace, ...rest } = options;
+  const { align, bracketedArray, newline, platform, section, sort, ...writeOptions } = rest;
+  let resolvedEol = eol;
+  let resolvedWhitespace = whitespace;
+  let existingText;
+  let oldData;
+  if (preserveStyle && isAccessibleSync(path, R_OK)) {
+    try {
+      existingText = readFileSync(path, "utf8");
+      oldData = parse(existingText, { bracketedArray: bracketedArray ?? true });
+      const detected = detectIniStyle(existingText);
+      resolvedEol ??= detected.eol;
+      resolvedWhitespace ??= detected.whitespace;
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  const encodeOptions = { align, bracketedArray, newline, platform, section, sort, whitespace: resolvedWhitespace };
+  const freshStringify = (value, sectionName) => stringify(value, sectionName === void 0 ? encodeOptions : { ...encodeOptions, section: sectionName });
+  let output;
+  if (existingText !== void 0 && oldData) {
+    output = mergeIniPreservingLines(existingText, oldData, data, freshStringify, {
+      eol: resolvedEol ?? "\n"});
+  } else {
+    output = freshStringify(data, section);
+    if (resolvedEol === "\r\n") {
+      output = output.replaceAll(/\r?\n/g, "\r\n");
+    }
+  }
+  writeFileSync(path, output, writeOptions);
+};
+
+export { writeIniSync as default };