@visulima/fs 4.1.0 → 5.0.0-alpha.10

package/dist/packem_shared/{parseJson-C8xb-3LR.js → indexToLineColumn-BUb0GPKl-BF770uX7.js}

@@ -1,11 +1,9 @@
-import JSONError from './JSONError-BkHRnInH.js';
-
 const normalizeLF = (code) => code.replaceAll(/\r\n|\r(?!\n)|\n/gu, "\n");
-const _process = globalThis.process || /* @__PURE__ */ Object.create(null);
+const rawProcess = globalThis.process ?? /* @__PURE__ */ Object.create(null);
 const processShims = {
   versions: {}
 };
-const process = new Proxy(_process, {
+const process = /* @__PURE__ */ new Proxy(rawProcess, {
   get(target, property) {
     if (property in target) {
       return target[property];
@@ -80,9 +78,9 @@ const codeFrame = (source, loc, options) => {
       ...options?.color
     }
   };
-  const hasColumns = loc.start && typeof loc.start.column === "number";
+  const hasColumns = typeof loc.start.column === "number";
   let lines = normalizeLF(source).split("\n");
-  if (typeof config?.tabWidth === "number") {
+  if (typeof config.tabWidth === "number") {
     lines = lines.map((ln) => ln.replaceAll("	", " ".repeat(config.tabWidth)));
   }
   const { end, markerLines, start } = getMarkerLines(loc, lines, config.linesAbove, config.linesBelow);
@@ -91,7 +89,7 @@ const codeFrame = (source, loc, options) => {
   let frame = lines.slice(start, end).map((line, index) => {
     const number = start + 1 + index;
     const hasMarker = markerLines[number];
-    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+    const paddedNumber = ` ${String(number)}`.slice(-numberMaxWidth);
     const lastMarkerLine = !markerLines[number + 1];
     const gutter = ` ${paddedNumber}${config.showGutter ? " |" : ""}`;
     if (hasMarker) {
@@ -137,9 +135,10 @@ const binarySearch = (element, array) => {
   }
   return m;
 };
+const LINE_BREAK_REGEX = /\n|\r(?!\n)/;
 const getLineStartIndexes = (string_) => (
   // eslint-disable-next-line unicorn/no-array-reduce
-  string_.split(/\n|\r(?!\n)/).reduce(
+  string_.split(LINE_BREAK_REGEX).reduce(
     (accumulator, current) => {
       accumulator.push(accumulator.at(-1) + current.length + 1);
       return accumulator;
@@ -169,63 +168,4 @@ const indexToLineColumn = (input, index, options) => {
   };
 };
 
-const getCodePoint = (character) => String.raw`\u{${character.codePointAt(0).toString(16)}}`;
-const generateCodeFrame = (source, location, options) => codeFrame(
-  source,
-  { start: location },
-  {
-    tabWidth: false,
-    ...options
-  }
-);
-const getErrorLocation = (source, message) => {
-  const match = /in JSON at position (?<index>\d+)(?: \(line (?<line>\d+) column (?<column>\d+)\))?$/.exec(message);
-  if (!match) {
-    return void 0;
-  }
-  let { column, index, line } = match.groups;
-  if (line && column) {
-    return { column: Number(column), line: Number(line) };
-  }
-  index = Number(index);
-  if (index === source.length) {
-    index = source.length - 1;
-  }
-  return indexToLineColumn(source, index);
-};
-const addCodePointToUnexpectedToken = (message) => message.replace(
-  // The token is always quoted after Node.js 20, but we handle both cases for compatibility
-  // eslint-disable-next-line regexp/no-potentially-useless-backreference
-  /(?<=^Unexpected token )(?<quote>')?(.)\k<quote>/,
-  (_, _quote, token) => `"${token}"(${getCodePoint(token)})`
-);
-function parseJson(string, reviver, fileName, options) {
-  if (typeof reviver === "string") {
-    if (typeof fileName === "object") {
-      options = fileName;
-    }
-    fileName = reviver;
-    reviver = void 0;
-  }
-  let message;
-  try {
-    return JSON.parse(string, reviver);
-  } catch (error) {
-    message = error.message;
-  }
-  let location;
-  if (string) {
-    location = getErrorLocation(string, message);
-    message = addCodePointToUnexpectedToken(message);
-  } else {
-    message += " while parsing empty string";
-  }
-  const jsonError = new JSONError(message);
-  jsonError.fileName = fileName;
-  if (location) {
-    jsonError.codeFrame = generateCodeFrame(string, location, options);
-  }
-  throw jsonError;
-}
-
-export { parseJson as default };
+export { codeFrame as c, indexToLineColumn as i };

package/dist/packem_shared/ini-preserve-Dq_Q_Jgb.js

@@ -0,0 +1,251 @@
+const BLANK_OR_COMMENT_REGEX = /^\s*(?:[;#].*)?$/;
+const SECTION_HEADER_REGEX = /^\s*\[([^\]]+)\]\s*$/;
+const LINE_SPLIT_REGEX = /\r?\n/;
+const TRAILING_EOL_REGEX = /\r?\n$/;
+const ENTRY_REGEX = /^[^=]+=/;
+const isWhitespace = (character) => character === " " || character === "	";
+const splitLeadingWhitespace = (source) => {
+  let index = 0;
+  while (index < source.length && isWhitespace(source[index])) {
+    index += 1;
+  }
+  return { indent: source.slice(0, index), rest: source.slice(index) };
+};
+const splitTrailingWhitespace = (source) => {
+  let index = source.length;
+  while (index > 0 && isWhitespace(source[index - 1])) {
+    index -= 1;
+  }
+  return { rest: source.slice(0, index), trailing: source.slice(index) };
+};
+const parseKeyValue = (raw) => {
+  const equalsIndex = raw.indexOf("=");
+  if (equalsIndex === -1) {
+    return void 0;
+  }
+  const leftSide = raw.slice(0, equalsIndex);
+  const rightSide = raw.slice(equalsIndex + 1);
+  const { indent, rest: keyAndBefore } = splitLeadingWhitespace(leftSide);
+  const { rest: key, trailing: before } = splitTrailingWhitespace(keyAndBefore);
+  if (key === "" || key.startsWith(";") || key.startsWith("#") || key.startsWith("[")) {
+    return void 0;
+  }
+  const { indent: after, rest: valueAndTrailing } = splitLeadingWhitespace(rightSide);
+  const { rest: value, trailing } = splitTrailingWhitespace(valueAndTrailing);
+  return { after, before, indent, key, trailing, value };
+};
+const countStyleMatches = (text) => {
+  let spaced = 0;
+  let unspaced = 0;
+  for (const line of text.split(LINE_SPLIT_REGEX)) {
+    if (BLANK_OR_COMMENT_REGEX.test(line) || SECTION_HEADER_REGEX.test(line)) {
+      continue;
+    }
+    const parts = parseKeyValue(line);
+    if (!parts) {
+      continue;
+    }
+    if (parts.before === " " && parts.after === " ") {
+      spaced += 1;
+    } else if (parts.before === "" && parts.after === "") {
+      unspaced += 1;
+    }
+  }
+  return { spaced, unspaced };
+};
+const getSection = (data, section) => {
+  if (!data) {
+    return void 0;
+  }
+  if (section === void 0) {
+    return data;
+  }
+  let cursor = data;
+  for (const part of section.split(".")) {
+    if (cursor && typeof cursor === "object" && !Array.isArray(cursor)) {
+      cursor = cursor[part];
+    } else {
+      return void 0;
+    }
+  }
+  return cursor && typeof cursor === "object" && !Array.isArray(cursor) ? cursor : void 0;
+};
+const extractValueToken = (serialized, key) => {
+  for (const candidate of serialized.split(LINE_SPLIT_REGEX)) {
+    if (!candidate || candidate.startsWith("[")) {
+      continue;
+    }
+    const match = ENTRY_REGEX.exec(candidate);
+    if (!match) {
+      continue;
+    }
+    const candidateKey = candidate.slice(0, match[0].length - 1).trim();
+    if (candidateKey === key || candidateKey === `${key}[]`) {
+      return candidate.slice(match[0].length).trimStart();
+    }
+  }
+  return "";
+};
+const classifyLine = (raw, currentSection) => {
+  if (raw.trim() === "") {
+    return { line: { kind: "blank", raw, section: currentSection }, nextSection: currentSection };
+  }
+  const trimmed = raw.trimStart();
+  if (trimmed.startsWith(";") || trimmed.startsWith("#")) {
+    return { line: { kind: "comment", raw, section: currentSection }, nextSection: currentSection };
+  }
+  const headerMatch = SECTION_HEADER_REGEX.exec(raw);
+  if (headerMatch) {
+    const nextSection = headerMatch[1];
+    return { line: { kind: "header", raw, section: nextSection }, nextSection };
+  }
+  const parts = parseKeyValue(raw);
+  if (parts) {
+    return { line: { key: parts.key, kind: "key", raw, section: currentSection }, nextSection: currentSection };
+  }
+  return { line: { kind: "unknown", raw, section: currentSection }, nextSection: currentSection };
+};
+const parseLines = (original) => {
+  const stripped = original.replace(TRAILING_EOL_REGEX, "");
+  const rawLines = stripped.split(LINE_SPLIT_REGEX);
+  const parsed = [];
+  let currentSection;
+  for (const raw of rawLines) {
+    const { line, nextSection } = classifyLine(raw, currentSection);
+    parsed.push(line);
+    currentSection = nextSection;
+  }
+  return parsed;
+};
+const renderChangedKey = (line, newValue, freshStringify) => {
+  const parts = parseKeyValue(line.raw);
+  if (!parts || !line.key) {
+    return line.raw;
+  }
+  const serialized = freshStringify({ [line.key]: newValue });
+  const valueToken = extractValueToken(serialized, line.key);
+  return `${parts.indent}${parts.key}${parts.before}=${parts.after}${valueToken}${parts.trailing}`;
+};
+const collectSections = (data, prefix = []) => {
+  const sections = [];
+  for (const [key, value] of Object.entries(data)) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      const path = [...prefix, key];
+      sections.push(path.join("."), ...collectSections(value, path));
+    }
+  }
+  return sections;
+};
+const pickScalars = (data, skip) => {
+  const scalars = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (skip.has(key) || value && typeof value === "object" && !Array.isArray(value)) {
+      continue;
+    }
+    scalars[key] = value;
+  }
+  return scalars;
+};
+const appendSerialized = (outputLines, serialized) => {
+  const added = [];
+  for (const line of serialized.split(LINE_SPLIT_REGEX)) {
+    if (line !== "") {
+      added.push(line);
+    }
+  }
+  if (added.length > 0) {
+    outputLines.push(...added);
+  }
+};
+const processKeyLine = (context) => {
+  const { line, markWritten, nextData, oldData, renderValue } = context;
+  if (!line.key) {
+    return line.raw;
+  }
+  const newSection = getSection(nextData, line.section);
+  if (!newSection || !(line.key in newSection)) {
+    return void 0;
+  }
+  markWritten(line.section, line.key);
+  const oldSection = getSection(oldData, line.section);
+  const oldValue = oldSection?.[line.key];
+  const newValue = newSection[line.key];
+  if (JSON.stringify(oldValue) === JSON.stringify(newValue)) {
+    return line.raw;
+  }
+  return renderValue(line, newValue);
+};
+const flushAdditions = (outputLines, section, writtenPerSection, nextData, freshStringify) => {
+  const sectionData = getSection(nextData, section);
+  if (!sectionData) {
+    return;
+  }
+  const written = writtenPerSection.get(section) ?? /* @__PURE__ */ new Set();
+  const additions = pickScalars(sectionData, written);
+  if (Object.keys(additions).length === 0) {
+    return;
+  }
+  appendSerialized(outputLines, freshStringify(additions));
+};
+const flushNewSections = (outputLines, parsedLines, nextData, freshStringify) => {
+  const existingSections = new Set(parsedLines.filter((line) => line.kind === "header" && line.section).map((line) => line.section));
+  for (const section of collectSections(nextData)) {
+    if (existingSections.has(section)) {
+      continue;
+    }
+    const sectionData = getSection(nextData, section);
+    if (!sectionData || Object.keys(sectionData).length === 0) {
+      continue;
+    }
+    const scalars = pickScalars(sectionData, /* @__PURE__ */ new Set());
+    if (Object.keys(scalars).length === 0) {
+      continue;
+    }
+    appendSerialized(outputLines, freshStringify(scalars, section));
+  }
+};
+const detectIniStyle = (text) => {
+  const eol = text.includes("\r\n") ? "\r\n" : "\n";
+  const { spaced, unspaced } = countStyleMatches(text);
+  return { eol, whitespace: spaced > 0 && spaced >= unspaced };
+};
+const mergeIniPreservingLines = (original, oldData, nextData, freshStringify, style) => {
+  const { eol } = style;
+  const endsWithEol = TRAILING_EOL_REGEX.test(original);
+  const parsedLines = parseLines(original);
+  const writtenPerSection = /* @__PURE__ */ new Map();
+  const sectionLastIndex = /* @__PURE__ */ new Map();
+  for (const [index, line] of parsedLines.entries()) {
+    if (line.kind !== "blank") {
+      sectionLastIndex.set(line.section, index);
+    }
+  }
+  const markWritten = (section, key) => {
+    let set = writtenPerSection.get(section);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      writtenPerSection.set(section, set);
+    }
+    set.add(key);
+  };
+  const renderValue = (line, value) => renderChangedKey(line, value, freshStringify);
+  const outputLines = [];
+  for (const [index, line] of parsedLines.entries()) {
+    if (line.kind === "key") {
+      const rendered = processKeyLine({ line, markWritten, nextData, oldData, renderValue });
+      if (rendered !== void 0) {
+        outputLines.push(rendered);
+      }
+      continue;
+    }
+    outputLines.push(line.raw);
+    if (sectionLastIndex.get(line.section) === index) {
+      flushAdditions(outputLines, line.section, writtenPerSection, nextData, freshStringify);
+    }
+  }
+  flushNewSections(outputLines, parsedLines, nextData, freshStringify);
+  const joined = outputLines.join(eol);
+  return endsWithEol && !joined.endsWith(eol) ? `${joined}${eol}` : joined;
+};
+
+export { detectIniStyle as d, mergeIniPreservingLines as m };

package/dist/packem_shared/{isAccessible-iOp0Bou6.js → isAccessible-DuVrTNFV.js}

@@ -21,7 +21,7 @@ const {
   access
 } = __cjs_getBuiltinModule("node:fs/promises");
 import { toPath } from '@visulima/path/utils';
-import { F_OK } from './F_OK-BalxCn9n.js';
+import { F_OK } from './F_OK-MldBaGxb.js';
 import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-8HANmVjk.js';
 
 async function isAccessible(path, mode = F_OK) {

package/dist/packem_shared/{isAccessibleSync-38BmiIcx.js → isAccessibleSync-DI8mM0fA.js}

@@ -21,7 +21,7 @@ const {
   accessSync
 } = __cjs_getBuiltinModule("node:fs");
 import { toPath } from '@visulima/path/utils';
-import { F_OK } from './F_OK-BalxCn9n.js';
+import { F_OK } from './F_OK-MldBaGxb.js';
 import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-8HANmVjk.js';
 
 function isAccessibleSync(path, mode = F_OK) {

package/dist/packem_shared/{isFsCaseSensitive-D-ayleCy.js → isFsCaseSensitive-DunL7Iry.js}

@@ -17,9 +17,9 @@ const __cjs_getBuiltinModule = (module) => {
     return __cjs_require(module);
 };
 
-const y = __cjs_getBuiltinModule("fs");
-const h = __cjs_getBuiltinModule("os");
-const u = __cjs_getBuiltinModule("path");
+const nativeFs__default = __cjs_getBuiltinModule("fs");
+const require$$2 = __cjs_getBuiltinModule("os");
+const require$$1 = __cjs_getBuiltinModule("path");
 
 var l = Object.defineProperty;
 var s = (i, t) => l(i, "name", { value: t, configurable: true });
@@ -33,7 +33,7 @@ const a = s((i) => {
 }, "invertCase");
 const c = /* @__PURE__ */ new Map();
 const p = s((i, t) => {
-  const e = u.join(i, `.is-fs-case-sensitive-test-${process.pid}`);
+  const e = require$$1.join(i, `.is-fs-case-sensitive-test-${process.pid}`);
   try {
     return t.writeFileSync(e, ""), !t.existsSync(a(e));
   } finally {
@@ -47,11 +47,11 @@ const m = s((i, t, e) => {
   try {
     return p(i, e);
   } catch (r) {
-    if (t === void 0) return p(h.tmpdir(), e);
+    if (t === void 0) return p(require$$2.tmpdir(), e);
     throw r;
   }
 }, "checkDirectoryCaseWithFallback");
-const S = s((i, t = y, e = true) => {
+const S = s((i, t = nativeFs__default, e = true) => {
   const r = i ?? process.cwd();
   if (e && c.has(r)) return c.get(r);
   let o;

package/dist/packem_shared/json-error.d-DgKaeuIf.d.ts

@@ -0,0 +1,10 @@
+declare class JSONError extends Error {
+  #private;
+  fileName: string | undefined;
+  codeFrame: string | undefined;
+  readonly name = "JSONError";
+  constructor(message: string);
+  get message(): string;
+  set message(message: string);
+}
+export { JSONError as J };

package/dist/packem_shared/jsonc-merge-C6jWcfWh.js

@@ -0,0 +1,72 @@
+import { parse, modify, applyEdits } from 'jsonc-parser';
+
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const applyModification = (context, path, value) => {
+  const edits = modify(context.text, path, value, { formattingOptions: context.formattingOptions });
+  context.text = applyEdits(context.text, edits);
+};
+const walkObject = (context, oldValue, newValue, path, walk) => {
+  const keys = /* @__PURE__ */ new Set([...Object.keys(oldValue), ...Object.keys(newValue)]);
+  for (const key of keys) {
+    const keyPath = [...path, key];
+    if (key in newValue) {
+      if (key in oldValue) {
+        walk(context, oldValue[key], newValue[key], keyPath);
+      } else {
+        applyModification(context, keyPath, newValue[key]);
+      }
+    } else {
+      applyModification(context, keyPath, void 0);
+    }
+  }
+};
+const walkValue = (context, oldValue, newValue, path) => {
+  if (oldValue === newValue) {
+    return;
+  }
+  if (isPlainObject(oldValue) && isPlainObject(newValue)) {
+    walkObject(context, oldValue, newValue, path, walkValue);
+    return;
+  }
+  if (Array.isArray(oldValue) && Array.isArray(newValue) && oldValue.length === newValue.length) {
+    for (const [index, oldItem] of oldValue.entries()) {
+      walkValue(context, oldItem, newValue[index], [...path, index]);
+    }
+    return;
+  }
+  if (JSON.stringify(oldValue) === JSON.stringify(newValue)) {
+    return;
+  }
+  applyModification(context, path, newValue);
+};
+const mergeJsoncPreservingComments = (original, next, formattingOptions) => {
+  const existing = parse(original, [], { allowTrailingComma: true });
+  const context = { formattingOptions, text: original };
+  walkValue(context, existing, next, []);
+  return context.text;
+};
+const formattingFromIndent = (indent) => {
+  if (typeof indent === "number") {
+    return { insertSpaces: true, tabSize: indent };
+  }
+  if (typeof indent === "string") {
+    if (indent === "	" || indent.includes("	")) {
+      return { insertSpaces: false, tabSize: indent.length || 1 };
+    }
+    return { insertSpaces: true, tabSize: indent.length || 2 };
+  }
+  return { insertSpaces: true, tabSize: 2 };
+};
+const buildJsoncOutput = (existingText, data, preserveComments, indent, trailingNewline, formattingOptions, replacer) => {
+  if (preserveComments && existingText !== void 0) {
+    const resolvedFormatting = { ...formattingFromIndent(indent), ...formattingOptions };
+    let merged = mergeJsoncPreservingComments(existingText, data, resolvedFormatting);
+    if (trailingNewline && !merged.endsWith("\n")) {
+      merged += trailingNewline;
+    }
+    return merged;
+  }
+  return `${JSON.stringify(data, replacer, indent)}${trailingNewline}`;
+};
+
+export { buildJsoncOutput as b };

package/dist/packem_shared/{move-BD6JbYSu.js → move-DbpW5_vA.js}

@@ -28,14 +28,14 @@ const {
   unlink
 } = __cjs_getBuiltinModule("node:fs/promises");
 import { dirname, resolve } from '@visulima/path';
-import isAccessible from './isAccessible-iOp0Bou6.js';
+import isAccessible from './isAccessible-DuVrTNFV.js';
 const {
   mkdirSync,
   renameSync: renameSync$1,
   copyFileSync,
   unlinkSync
 } = __cjs_getBuiltinModule("node:fs");
-import isAccessibleSync from './isAccessibleSync-38BmiIcx.js';
+import isAccessibleSync from './isAccessibleSync-DI8mM0fA.js';
 
 class SameDirectoryError extends Error {
   constructor(source, destination) {

package/dist/packem_shared/parseJson-BIp89Xjo.js

@@ -0,0 +1,63 @@
+import JSONError from './JSONError-BkHRnInH.js';
+import { i as indexToLineColumn, c as codeFrame } from './indexToLineColumn-BUb0GPKl-BF770uX7.js';
+
+const getCodePoint = (character) => String.raw`\u{${character.codePointAt(0).toString(16)}}`;
+const generateCodeFrame = (source, location, options) => codeFrame(
+  source,
+  { start: location },
+  {
+    tabWidth: false,
+    ...options
+  }
+);
+const JSON_POSITION_REGEX = /in JSON at position (\d+)(?: \(line (\d+) column (\d+)\))?$/;
+const getErrorLocation = (source, message) => {
+  const match = JSON_POSITION_REGEX.exec(message);
+  if (!match) {
+    return void 0;
+  }
+  const [, indexString, lineString, columnString] = match;
+  if (lineString && columnString) {
+    return { column: Number(columnString), line: Number(lineString) };
+  }
+  let index = Number(indexString);
+  if (index === source.length) {
+    index = source.length - 1;
+  }
+  return indexToLineColumn(source, index);
+};
+const UNEXPECTED_TOKEN_REGEX = /(?<=^Unexpected token )(?<quote>')?(.)\k<quote>/;
+const addCodePointToUnexpectedToken = (message) => message.replace(
+  UNEXPECTED_TOKEN_REGEX,
+  (_, _quote, token) => `"${token}"(${getCodePoint(token)})`
+);
+function parseJson(string, reviver, fileName, options) {
+  if (typeof reviver === "string") {
+    if (typeof fileName === "object") {
+      options = fileName;
+    }
+    fileName = reviver;
+    reviver = void 0;
+  }
+  let message;
+  try {
+    return JSON.parse(string, reviver);
+  } catch (error) {
+    message = error.message;
+  }
+  let location;
+  if (string) {
+    location = getErrorLocation(string, message);
+    message = addCodePointToUnexpectedToken(message);
+  } else {
+    message += " while parsing empty string";
+  }
+  const jsonError = new JSONError(message);
+  jsonError.fileName = fileName;
+  if (location) {
+    jsonError.codeFrame = generateCodeFrame(string, location, options);
+  }
+  throw jsonError;
+}
+
+export { parseJson as default };

package/dist/packem_shared/{readFile-BcK0rkht.js → readFile-Iz7kvCCk.js}

@@ -25,9 +25,9 @@ const {
   brotliDecompress
 } = __cjs_getBuiltinModule("node:zlib");
 import { toPath } from '@visulima/path/utils';
-import { R_OK } from './F_OK-BalxCn9n.js';
+import { R_OK } from './F_OK-MldBaGxb.js';
 import PermissionError from './PermissionError-CjoiJgip.js';
-import isAccessible from './isAccessible-iOp0Bou6.js';
+import isAccessible from './isAccessible-DuVrTNFV.js';
 import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-8HANmVjk.js';
 
 const decompressionMethods = {

package/dist/packem_shared/{readFileSync-BDgEnnqT.js → readFileSync-gm9yfIhh.js}

@@ -25,9 +25,9 @@ const {
   brotliDecompressSync
 } = __cjs_getBuiltinModule("node:zlib");
 import { toPath } from '@visulima/path/utils';
-import { R_OK } from './F_OK-BalxCn9n.js';
+import { R_OK } from './F_OK-MldBaGxb.js';
 import PermissionError from './PermissionError-CjoiJgip.js';
-import isAccessibleSync from './isAccessibleSync-38BmiIcx.js';
+import isAccessibleSync from './isAccessibleSync-DI8mM0fA.js';
 import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-8HANmVjk.js';
 
 const decompressionMethods = {
@@ -46,7 +46,8 @@ const readFileSync = (path, options) => {
   }
   const { buffer, compression, encoding, flag } = options ?? {};
   const content = readFileSync$1(path, flag ? { encoding, flag } : { encoding });
-  const decompressed = decompressionMethods[compression ?? "none"](content);
+  const decompress = decompressionMethods[compression ?? "none"];
+  const decompressed = decompress(content);
   return buffer ? decompressed : decompressed.toString();
 };
 

package/dist/packem_shared/readIni-CJ2xfpjB.js

@@ -0,0 +1,10 @@
+import { parse } from 'ini';
+import readFile from './readFile-Iz7kvCCk.js';
+
+const readIni = async (path, options) => {
+  const { bracketedArray = true, ...readOptions } = options ?? {};
+  const content = await readFile(path, { encoding: "utf8", ...readOptions });
+  return parse(content, { bracketedArray });
+};
+
+export { readIni as default };

package/dist/packem_shared/readIniSync-9LUjaSSp.js

@@ -0,0 +1,10 @@
+import { parse } from 'ini';
+import readFileSync from './readFileSync-gm9yfIhh.js';
+
+const readIniSync = (path, options) => {
+  const { bracketedArray = true, ...readOptions } = options ?? {};
+  const content = readFileSync(path, { encoding: "utf8", ...readOptions });
+  return parse(content, { bracketedArray });
+};
+
+export { readIniSync as default };

package/dist/packem_shared/{readJson-ac6N9-5G.js → readJson-C_rwm-wq.js}

@@ -1,6 +1,6 @@
 import { toPath } from '@visulima/path/utils';
-import parseJson from './parseJson-C8xb-3LR.js';
-import readFile from './readFile-BcK0rkht.js';
+import parseJson from './parseJson-BIp89Xjo.js';
+import readFile from './readFile-Iz7kvCCk.js';
 
 async function readJson(path, reviver, options) {
   if (typeof reviver === "object") {

package/dist/packem_shared/readJson5-mBoTZppy.js

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