@visulima/fs 2.3.5 → 2.3.7

package/dist/packem_shared/walkSync-BzxdFWLU.mjs

@@ -0,0 +1,103 @@
+import { readdirSync, realpathSync, statSync } from 'node:fs';
+import { resolve, join, normalize, basename } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import WalkError from './WalkError-H9EuRv7O.mjs';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-BWWgA1wj.mjs';
+import { g as globToRegExp, w as walkInclude } from './walk-include-CMUSRa86.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const _createWalkEntry = /* @__PURE__ */ __name((path) => {
+  const normalizePath = normalize(path);
+  const info = statSync(normalizePath);
+  return {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    isDirectory: info.isDirectory,
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    isFile: info.isFile,
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    isSymbolicLink: info.isSymbolicLink,
+    name: basename(normalizePath),
+    path: normalizePath
+  };
+}, "_createWalkEntry");
+function* walkSync(directory, {
+  extensions,
+  followSymlinks = false,
+  includeDirs: includeDirectories = true,
+  includeFiles = true,
+  includeSymlinks = true,
+  match,
+  maxDepth = Number.POSITIVE_INFINITY,
+  skip
+} = {}) {
+  assertValidFileOrDirectoryPath(directory);
+  if (maxDepth < 0) {
+    return;
+  }
+  const mappedMatch = match ? match.map((pattern) => typeof pattern === "string" ? globToRegExp(pattern) : pattern) : undefined;
+  const mappedSkip = skip ? skip.map((pattern) => typeof pattern === "string" ? globToRegExp(pattern) : pattern) : undefined;
+  directory = resolve(toPath(directory));
+  if (includeDirectories && walkInclude(directory, extensions, mappedMatch, mappedSkip)) {
+    yield _createWalkEntry(directory);
+  }
+  if (maxDepth < 1 || !walkInclude(directory, undefined, undefined, mappedSkip)) {
+    return;
+  }
+  try {
+    for (const entry of readdirSync(directory, {
+      withFileTypes: true
+    })) {
+      let path = join(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        if (followSymlinks) {
+          path = realpathSync(path);
+        } else if (includeSymlinks && walkInclude(path, extensions, mappedMatch, mappedSkip)) {
+          yield {
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            isDirectory: entry.isDirectory,
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            isFile: entry.isFile,
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            isSymbolicLink: entry.isSymbolicLink,
+            name: entry.name,
+            path: normalize(path)
+          };
+        } else {
+          continue;
+        }
+      }
+      if (entry.isSymbolicLink() || entry.isDirectory()) {
+        yield* walkSync(path, {
+          extensions,
+          followSymlinks,
+          includeDirs: includeDirectories,
+          includeFiles,
+          includeSymlinks,
+          match: mappedMatch,
+          maxDepth: maxDepth - 1,
+          skip: mappedSkip
+        });
+      } else if (entry.isFile() && includeFiles && walkInclude(path, extensions, mappedMatch, mappedSkip)) {
+        yield {
+          // eslint-disable-next-line @typescript-eslint/unbound-method
+          isDirectory: entry.isDirectory,
+          // eslint-disable-next-line @typescript-eslint/unbound-method
+          isFile: entry.isFile,
+          // eslint-disable-next-line @typescript-eslint/unbound-method
+          isSymbolicLink: entry.isSymbolicLink,
+          name: entry.name,
+          path: normalize(path)
+        };
+      }
+    }
+  } catch (error) {
+    if (error instanceof WalkError) {
+      throw error;
+    }
+    throw new WalkError(error, directory);
+  }
+}
+__name(walkSync, "walkSync");
+
+export { walkSync as default };

package/dist/packem_shared/walkSync-DgPj93NL.cjs

@@ -0,0 +1,105 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const path = require('@visulima/path');
+const utils = require('@visulima/path/utils');
+const WalkError = require('./WalkError-B7_AVs7d.cjs');
+const assertValidFileOrDirectoryPath = require('./assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
+const walkInclude = require('./walk-include-yUdRrF16.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const _createWalkEntry = /* @__PURE__ */ __name((path$1) => {
+  const normalizePath = path.normalize(path$1);
+  const info = node_fs.statSync(normalizePath);
+  return {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    isDirectory: info.isDirectory,
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    isFile: info.isFile,
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    isSymbolicLink: info.isSymbolicLink,
+    name: path.basename(normalizePath),
+    path: normalizePath
+  };
+}, "_createWalkEntry");
+function* walkSync(directory, {
+  extensions,
+  followSymlinks = false,
+  includeDirs: includeDirectories = true,
+  includeFiles = true,
+  includeSymlinks = true,
+  match,
+  maxDepth = Number.POSITIVE_INFINITY,
+  skip
+} = {}) {
+  assertValidFileOrDirectoryPath(directory);
+  if (maxDepth < 0) {
+    return;
+  }
+  const mappedMatch = match ? match.map((pattern) => typeof pattern === "string" ? walkInclude.globToRegExp(pattern) : pattern) : undefined;
+  const mappedSkip = skip ? skip.map((pattern) => typeof pattern === "string" ? walkInclude.globToRegExp(pattern) : pattern) : undefined;
+  directory = path.resolve(utils.toPath(directory));
+  if (includeDirectories && walkInclude.walkInclude(directory, extensions, mappedMatch, mappedSkip)) {
+    yield _createWalkEntry(directory);
+  }
+  if (maxDepth < 1 || !walkInclude.walkInclude(directory, undefined, undefined, mappedSkip)) {
+    return;
+  }
+  try {
+    for (const entry of node_fs.readdirSync(directory, {
+      withFileTypes: true
+    })) {
+      let path$1 = path.join(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        if (followSymlinks) {
+          path$1 = node_fs.realpathSync(path$1);
+        } else if (includeSymlinks && walkInclude.walkInclude(path$1, extensions, mappedMatch, mappedSkip)) {
+          yield {
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            isDirectory: entry.isDirectory,
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            isFile: entry.isFile,
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            isSymbolicLink: entry.isSymbolicLink,
+            name: entry.name,
+            path: path.normalize(path$1)
+          };
+        } else {
+          continue;
+        }
+      }
+      if (entry.isSymbolicLink() || entry.isDirectory()) {
+        yield* walkSync(path$1, {
+          extensions,
+          followSymlinks,
+          includeDirs: includeDirectories,
+          includeFiles,
+          includeSymlinks,
+          match: mappedMatch,
+          maxDepth: maxDepth - 1,
+          skip: mappedSkip
+        });
+      } else if (entry.isFile() && includeFiles && walkInclude.walkInclude(path$1, extensions, mappedMatch, mappedSkip)) {
+        yield {
+          // eslint-disable-next-line @typescript-eslint/unbound-method
+          isDirectory: entry.isDirectory,
+          // eslint-disable-next-line @typescript-eslint/unbound-method
+          isFile: entry.isFile,
+          // eslint-disable-next-line @typescript-eslint/unbound-method
+          isSymbolicLink: entry.isSymbolicLink,
+          name: entry.name,
+          path: path.normalize(path$1)
+        };
+      }
+    }
+  } catch (error) {
+    if (error instanceof WalkError) {
+      throw error;
+    }
+    throw new WalkError(error, directory);
+  }
+}
+__name(walkSync, "walkSync");
+
+module.exports = walkSync;

package/dist/packem_shared/writeFile-B7dhfseN.mjs

@@ -0,0 +1,58 @@
+import { mkdir, writeFile as writeFile$1, stat, rename, chown, chmod, unlink } from 'node:fs/promises';
+import { dirname } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import { F_OK } from './F_OK-JER1LjUr.mjs';
+import isAccessible from './isAccessible-Bonsm1Ez.mjs';
+import assertValidFileContents from './assertValidFileContents-Ox-ScfeK.mjs';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-BWWgA1wj.mjs';
+import { t as toUint8Array } from './to-uint-8-array-B4CjMOD3.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const writeFile = /* @__PURE__ */ __name(async (path, content, options) => {
+  options = {
+    encoding: "utf8",
+    flag: "w",
+    overwrite: true,
+    recursive: true,
+    ...options
+  };
+  assertValidFileOrDirectoryPath(path);
+  assertValidFileContents(content);
+  path = toPath(path);
+  try {
+    const pathExists = await isAccessible(path, F_OK);
+    if (!pathExists && options.recursive) {
+      const directory = dirname(path);
+      if (!await isAccessible(directory, F_OK)) {
+        await mkdir(directory, { recursive: true });
+      }
+    }
+    let stat$1;
+    await writeFile$1(`${path}.tmp`, toUint8Array(content), { encoding: options.encoding, flag: options.flag });
+    if (pathExists && !options.overwrite) {
+      stat$1 = await stat(path);
+      if (options.chown === undefined) {
+        options.chown = { gid: stat$1.gid, uid: stat$1.uid };
+      }
+      await rename(path, `${path}.bak`);
+    }
+    const temporaryPath = `${path}.tmp`;
+    if (options.chown) {
+      try {
+        await chown(temporaryPath, options.chown.uid, options.chown.gid);
+      } catch {
+      }
+    }
+    await chmod(temporaryPath, stat$1 && !options.mode ? stat$1.mode : options.mode ?? 438);
+    await rename(temporaryPath, path);
+  } catch (error) {
+    throw new Error(`Failed to write file at: ${path} - ${error.message}`, { cause: error });
+  } finally {
+    if (await isAccessible(`${path}.tmp`)) {
+      await unlink(`${path}.tmp`);
+    }
+  }
+}, "writeFile");
+
+export { writeFile as default };

package/dist/packem_shared/writeFile-DKu5-M8x.cjs

@@ -0,0 +1,60 @@
+'use strict';
+
+const promises = require('node:fs/promises');
+const path = require('@visulima/path');
+const utils = require('@visulima/path/utils');
+const F_OK = require('./F_OK-CWSqQIdF.cjs');
+const isAccessible = require('./isAccessible-ZNVGsSb7.cjs');
+const assertValidFileContents = require('./assertValidFileContents-CRVvyM6b.cjs');
+const assertValidFileOrDirectoryPath = require('./assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
+const toUint8Array = require('./to-uint-8-array-BaTEyX3D.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const writeFile = /* @__PURE__ */ __name(async (path$1, content, options) => {
+  options = {
+    encoding: "utf8",
+    flag: "w",
+    overwrite: true,
+    recursive: true,
+    ...options
+  };
+  assertValidFileOrDirectoryPath(path$1);
+  assertValidFileContents(content);
+  path$1 = utils.toPath(path$1);
+  try {
+    const pathExists = await isAccessible(path$1, F_OK.F_OK);
+    if (!pathExists && options.recursive) {
+      const directory = path.dirname(path$1);
+      if (!await isAccessible(directory, F_OK.F_OK)) {
+        await promises.mkdir(directory, { recursive: true });
+      }
+    }
+    let stat;
+    await promises.writeFile(`${path$1}.tmp`, toUint8Array.toUint8Array(content), { encoding: options.encoding, flag: options.flag });
+    if (pathExists && !options.overwrite) {
+      stat = await promises.stat(path$1);
+      if (options.chown === undefined) {
+        options.chown = { gid: stat.gid, uid: stat.uid };
+      }
+      await promises.rename(path$1, `${path$1}.bak`);
+    }
+    const temporaryPath = `${path$1}.tmp`;
+    if (options.chown) {
+      try {
+        await promises.chown(temporaryPath, options.chown.uid, options.chown.gid);
+      } catch {
+      }
+    }
+    await promises.chmod(temporaryPath, stat && !options.mode ? stat.mode : options.mode ?? 438);
+    await promises.rename(temporaryPath, path$1);
+  } catch (error) {
+    throw new Error(`Failed to write file at: ${path$1} - ${error.message}`, { cause: error });
+  } finally {
+    if (await isAccessible(`${path$1}.tmp`)) {
+      await promises.unlink(`${path$1}.tmp`);
+    }
+  }
+}, "writeFile");
+
+module.exports = writeFile;

package/dist/packem_shared/writeFileSync-Db6pmY0q.cjs

@@ -0,0 +1,60 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const path = require('@visulima/path');
+const utils = require('@visulima/path/utils');
+const F_OK = require('./F_OK-CWSqQIdF.cjs');
+const isAccessibleSync = require('./isAccessibleSync-VWjQa-US.cjs');
+const assertValidFileContents = require('./assertValidFileContents-CRVvyM6b.cjs');
+const assertValidFileOrDirectoryPath = require('./assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
+const toUint8Array = require('./to-uint-8-array-BaTEyX3D.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const writeFileSync = /* @__PURE__ */ __name((path$1, content, options) => {
+  options = {
+    encoding: "utf8",
+    flag: "w",
+    overwrite: true,
+    recursive: true,
+    ...options
+  };
+  assertValidFileOrDirectoryPath(path$1);
+  assertValidFileContents(content);
+  path$1 = utils.toPath(path$1);
+  try {
+    const pathExists = isAccessibleSync(path$1, F_OK.F_OK);
+    if (!pathExists && options.recursive) {
+      const directory = path.dirname(path$1);
+      if (!isAccessibleSync(directory, F_OK.F_OK)) {
+        node_fs.mkdirSync(directory, { recursive: true });
+      }
+    }
+    let stat;
+    node_fs.writeFileSync(`${path$1}.tmp`, toUint8Array.toUint8Array(content), { encoding: options.encoding, flag: options.flag });
+    if (pathExists && !options.overwrite) {
+      stat = node_fs.statSync(path$1);
+      if (options.chown === undefined) {
+        options.chown = { gid: stat.gid, uid: stat.uid };
+      }
+      node_fs.renameSync(path$1, `${path$1}.bak`);
+    }
+    const temporaryPath = `${path$1}.tmp`;
+    if (options.chown) {
+      try {
+        node_fs.chownSync(temporaryPath, options.chown.uid, options.chown.gid);
+      } catch {
+      }
+    }
+    node_fs.chmodSync(temporaryPath, stat && !options.mode ? stat.mode : options.mode ?? 438);
+    node_fs.renameSync(temporaryPath, path$1);
+  } catch (error) {
+    throw new Error(`Failed to write file at: ${path$1} - ${error.message}`, { cause: error });
+  } finally {
+    if (isAccessibleSync(`${path$1}.tmp`)) {
+      node_fs.unlinkSync(`${path$1}.tmp`);
+    }
+  }
+}, "writeFileSync");
+
+module.exports = writeFileSync;

package/dist/packem_shared/writeFileSync-mMGYqOc8.mjs

@@ -0,0 +1,58 @@
+import { mkdirSync, writeFileSync as writeFileSync$1, statSync, renameSync, chownSync, chmodSync, unlinkSync } from 'node:fs';
+import { dirname } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import { F_OK } from './F_OK-JER1LjUr.mjs';
+import isAccessibleSync from './isAccessibleSync-3gnUWUwX.mjs';
+import assertValidFileContents from './assertValidFileContents-Ox-ScfeK.mjs';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-BWWgA1wj.mjs';
+import { t as toUint8Array } from './to-uint-8-array-B4CjMOD3.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const writeFileSync = /* @__PURE__ */ __name((path, content, options) => {
+  options = {
+    encoding: "utf8",
+    flag: "w",
+    overwrite: true,
+    recursive: true,
+    ...options
+  };
+  assertValidFileOrDirectoryPath(path);
+  assertValidFileContents(content);
+  path = toPath(path);
+  try {
+    const pathExists = isAccessibleSync(path, F_OK);
+    if (!pathExists && options.recursive) {
+      const directory = dirname(path);
+      if (!isAccessibleSync(directory, F_OK)) {
+        mkdirSync(directory, { recursive: true });
+      }
+    }
+    let stat;
+    writeFileSync$1(`${path}.tmp`, toUint8Array(content), { encoding: options.encoding, flag: options.flag });
+    if (pathExists && !options.overwrite) {
+      stat = statSync(path);
+      if (options.chown === undefined) {
+        options.chown = { gid: stat.gid, uid: stat.uid };
+      }
+      renameSync(path, `${path}.bak`);
+    }
+    const temporaryPath = `${path}.tmp`;
+    if (options.chown) {
+      try {
+        chownSync(temporaryPath, options.chown.uid, options.chown.gid);
+      } catch {
+      }
+    }
+    chmodSync(temporaryPath, stat && !options.mode ? stat.mode : options.mode ?? 438);
+    renameSync(temporaryPath, path);
+  } catch (error) {
+    throw new Error(`Failed to write file at: ${path} - ${error.message}`, { cause: error });
+  } finally {
+    if (isAccessibleSync(`${path}.tmp`)) {
+      unlinkSync(`${path}.tmp`);
+    }
+  }
+}, "writeFileSync");
+
+export { writeFileSync as default };

package/dist/packem_shared/writeJson-BSQE2uFN.mjs

@@ -0,0 +1,31 @@
+import { readFile } from 'node:fs/promises';
+import { d as detectIndent } from './index-ajT9ecry.mjs';
+import { R_OK } from './F_OK-JER1LjUr.mjs';
+import isAccessible from './isAccessible-Bonsm1Ez.mjs';
+import writeFile from './writeFile-B7dhfseN.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const writeJson = /* @__PURE__ */ __name(async (path, data, options = {}) => {
+  const { detectIndent: detectIndent$1, indent: indentOption, replacer, stringify = JSON.stringify, ...writeOptions } = { indent: "	", ...options };
+  let indent = indentOption;
+  let trailingNewline = "\n";
+  if (await isAccessible(path, R_OK)) {
+    try {
+      const file = await readFile(path, "utf8");
+      if (detectIndent$1) {
+        const { indent: dIndent } = detectIndent(file);
+        indent = dIndent;
+      }
+      trailingNewline = file.endsWith("\n") ? "\n" : "";
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  const json = stringify(data, replacer, indent);
+  await writeFile(path, `${json}${trailingNewline}`, writeOptions);
+}, "writeJson");
+
+export { writeJson as default };

package/dist/packem_shared/writeJson-DtnnjTix.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+const promises = require('node:fs/promises');
+const index = require('./index-ngvEMjBI.cjs');
+const F_OK = require('./F_OK-CWSqQIdF.cjs');
+const isAccessible = require('./isAccessible-ZNVGsSb7.cjs');
+const writeFile = require('./writeFile-DKu5-M8x.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const writeJson = /* @__PURE__ */ __name(async (path, data, options = {}) => {
+  const { detectIndent, indent: indentOption, replacer, stringify = JSON.stringify, ...writeOptions } = { indent: "	", ...options };
+  let indent = indentOption;
+  let trailingNewline = "\n";
+  if (await isAccessible(path, F_OK.R_OK)) {
+    try {
+      const file = await promises.readFile(path, "utf8");
+      if (detectIndent) {
+        const { indent: dIndent } = index.detectIndent(file);
+        indent = dIndent;
+      }
+      trailingNewline = file.endsWith("\n") ? "\n" : "";
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  const json = stringify(data, replacer, indent);
+  await writeFile(path, `${json}${trailingNewline}`, writeOptions);
+}, "writeJson");
+
+module.exports = writeJson;

package/dist/packem_shared/writeJsonSync-C_i6LsGT.mjs

@@ -0,0 +1,31 @@
+import { readFileSync } from 'node:fs';
+import { d as detectIndent } from './index-ajT9ecry.mjs';
+import { R_OK } from './F_OK-JER1LjUr.mjs';
+import isAccessibleSync from './isAccessibleSync-3gnUWUwX.mjs';
+import writeFileSync from './writeFileSync-mMGYqOc8.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const writeJsonSync = /* @__PURE__ */ __name((path, data, options = {}) => {
+  const { detectIndent: detectIndent$1, indent: indentOption, replacer, stringify = JSON.stringify, ...writeOptions } = { indent: "	", ...options };
+  let indent = indentOption;
+  let trailingNewline = "\n";
+  if (isAccessibleSync(path, R_OK)) {
+    try {
+      const file = readFileSync(path, "utf8");
+      if (detectIndent$1) {
+        const { indent: dIndent } = detectIndent(file);
+        indent = dIndent;
+      }
+      trailingNewline = file.endsWith("\n") ? "\n" : "";
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  const json = stringify(data, replacer, indent);
+  writeFileSync(path, `${json}${trailingNewline}`, writeOptions);
+}, "writeJsonSync");
+
+export { writeJsonSync as default };

package/dist/packem_shared/writeJsonSync-Dz5-B2PD.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const index = require('./index-ngvEMjBI.cjs');
+const F_OK = require('./F_OK-CWSqQIdF.cjs');
+const isAccessibleSync = require('./isAccessibleSync-VWjQa-US.cjs');
+const writeFileSync = require('./writeFileSync-Db6pmY0q.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const writeJsonSync = /* @__PURE__ */ __name((path, data, options = {}) => {
+  const { detectIndent, indent: indentOption, replacer, stringify = JSON.stringify, ...writeOptions } = { indent: "	", ...options };
+  let indent = indentOption;
+  let trailingNewline = "\n";
+  if (isAccessibleSync(path, F_OK.R_OK)) {
+    try {
+      const file = node_fs.readFileSync(path, "utf8");
+      if (detectIndent) {
+        const { indent: dIndent } = index.detectIndent(file);
+        indent = dIndent;
+      }
+      trailingNewline = file.endsWith("\n") ? "\n" : "";
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  const json = stringify(data, replacer, indent);
+  writeFileSync(path, `${json}${trailingNewline}`, writeOptions);
+}, "writeJsonSync");
+
+module.exports = writeJsonSync;

package/dist/packem_shared/writeYaml-B-KoZN0E.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+const yaml = require('yaml');
+const writeFile = require('./writeFile-DKu5-M8x.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+async function writeYaml(path, data, replacer, options) {
+  const content = typeof replacer === "function" || Array.isArray(replacer) ? yaml.stringify(data, replacer, options) : yaml.stringify(data, replacer);
+  await writeFile(path, content);
+}
+__name(writeYaml, "writeYaml");
+
+module.exports = writeYaml;

package/dist/packem_shared/writeYaml-DSTzKc0_.mjs

@@ -0,0 +1,12 @@
+import { stringify } from 'yaml';
+import writeFile from './writeFile-B7dhfseN.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+async function writeYaml(path, data, replacer, options) {
+  const content = typeof replacer === "function" || Array.isArray(replacer) ? stringify(data, replacer, options) : stringify(data, replacer);
+  await writeFile(path, content);
+}
+__name(writeYaml, "writeYaml");
+
+export { writeYaml as default };

package/dist/packem_shared/writeYamlSync-D6borSP1.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+const yaml = require('yaml');
+const writeFileSync = require('./writeFileSync-Db6pmY0q.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function writeYamlSync(path, data, replacer, options) {
+  const content = typeof replacer === "function" || Array.isArray(replacer) ? yaml.stringify(data, replacer, options) : yaml.stringify(data, replacer);
+  writeFileSync(path, content);
+}
+__name(writeYamlSync, "writeYamlSync");
+
+module.exports = writeYamlSync;

package/dist/packem_shared/writeYamlSync-agxYIea0.mjs

@@ -0,0 +1,12 @@
+import { stringify } from 'yaml';
+import writeFileSync from './writeFileSync-mMGYqOc8.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function writeYamlSync(path, data, replacer, options) {
+  const content = typeof replacer === "function" || Array.isArray(replacer) ? stringify(data, replacer, options) : stringify(data, replacer);
+  writeFileSync(path, content);
+}
+__name(writeYamlSync, "writeYamlSync");
+
+export { writeYamlSync as default };

package/dist/utils.cjs

@@ -1 +1,19 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./packem_shared/JSONError-CWuiGmNc.cjs"),e=require("./packem_shared/assertValidFileContents-CrbDz09d.cjs"),t=require("./packem_shared/assertValidFileOrDirectoryPath-HOUs73Jk.cjs"),s=require("./packem_shared/parseJson-CXe73j5t.cjs"),o=require("./packem_shared/stripJsonComments-Cw7UCxI3.cjs"),i=require("@visulima/path/utils");exports.JSONError=r;exports.assertValidFileContents=e;exports.assertValidFileOrDirectoryPath=t;exports.parseJson=s;exports.stripJsonComments=o;exports.toPath=i.toPath;
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const JSONError = require('./packem_shared/JSONError-gkXvBSar.cjs');
+const assertValidFileContents = require('./packem_shared/assertValidFileContents-CRVvyM6b.cjs');
+const assertValidFileOrDirectoryPath = require('./packem_shared/assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
+const parseJson = require('./packem_shared/parseJson-DcUo4Rpt.cjs');
+const stripJsonComments = require('./packem_shared/stripJsonComments-eDrcJvBT.cjs');
+const utils = require('@visulima/path/utils');
+
+
+
+exports.JSONError = JSONError;
+exports.assertValidFileContents = assertValidFileContents;
+exports.assertValidFileOrDirectoryPath = assertValidFileOrDirectoryPath;
+exports.parseJson = parseJson;
+exports.stripJsonComments = stripJsonComments;
+exports.toPath = utils.toPath;

package/dist/utils.mjs

@@ -1 +1,6 @@
-import{default as e}from"./packem_shared/JSONError-CVkb3xZ3.mjs";import{default as a}from"./packem_shared/assertValidFileContents-BLhwm7u2.mjs";import{default as f}from"./packem_shared/assertValidFileOrDirectoryPath-DgPIPmZT.mjs";import{default as m}from"./packem_shared/parseJson-BIYrZWHm.mjs";import{default as d}from"./packem_shared/stripJsonComments-CKgR4nW4.mjs";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};
+export { default as JSONError } from './packem_shared/JSONError-BCIIHvzq.mjs';
+export { default as assertValidFileContents } from './packem_shared/assertValidFileContents-Ox-ScfeK.mjs';
+export { default as assertValidFileOrDirectoryPath } from './packem_shared/assertValidFileOrDirectoryPath-BWWgA1wj.mjs';
+export { default as parseJson } from './packem_shared/parseJson-n9THWOFI.mjs';
+export { default as stripJsonComments } from './packem_shared/stripJsonComments-B66nRaTZ.mjs';
+export { toPath } from '@visulima/path/utils';