@visulima/fs 2.3.4 → 2.3.6

package/dist/packem_shared/to-uint-8-array-B4CjMOD3.mjs

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const encoder = new TextEncoder();
+const toUint8Array = /* @__PURE__ */ __name((contents) => {
+  if (contents instanceof Uint8Array) {
+    return contents;
+  }
+  if (typeof contents === "string") {
+    return encoder.encode(contents);
+  }
+  if (contents instanceof ArrayBuffer) {
+    return new Uint8Array(contents);
+  }
+  if (ArrayBuffer.isView(contents)) {
+    const bytes = contents.buffer.slice(contents.byteOffset, contents.byteOffset + contents.byteLength);
+    return new Uint8Array(bytes);
+  }
+  throw new TypeError("Invalid contents type. Expected string or ArrayBuffer.");
+}, "toUint8Array");
+
+export { toUint8Array as t };

package/dist/packem_shared/to-uint-8-array-BaTEyX3D.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const encoder = new TextEncoder();
+const toUint8Array = /* @__PURE__ */ __name((contents) => {
+  if (contents instanceof Uint8Array) {
+    return contents;
+  }
+  if (typeof contents === "string") {
+    return encoder.encode(contents);
+  }
+  if (contents instanceof ArrayBuffer) {
+    return new Uint8Array(contents);
+  }
+  if (ArrayBuffer.isView(contents)) {
+    const bytes = contents.buffer.slice(contents.byteOffset, contents.byteOffset + contents.byteLength);
+    return new Uint8Array(bytes);
+  }
+  throw new TypeError("Invalid contents type. Expected string or ArrayBuffer.");
+}, "toUint8Array");
+
+exports.toUint8Array = toUint8Array;

package/dist/packem_shared/walk-BW7b4GXI.cjs

@@ -0,0 +1,106 @@
+'use strict';
+
+const promises = require('node:fs/promises');
+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(async (path$1) => {
+  const normalizePath = path.normalize(path$1);
+  const name = path.basename(normalizePath);
+  const info = await promises.stat(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: normalizePath
+  };
+}, "_createWalkEntry");
+async function* walk(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 await _createWalkEntry(directory);
+  }
+  if (maxDepth < 1 || !walkInclude.walkInclude(directory, undefined, undefined, mappedSkip)) {
+    return;
+  }
+  try {
+    for await (const entry of await promises.readdir(directory, {
+      withFileTypes: true
+    })) {
+      let path$1 = path.join(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        if (followSymlinks) {
+          path$1 = await promises.realpath(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$1
+          };
+        } else {
+          continue;
+        }
+      }
+      if (entry.isSymbolicLink() || entry.isDirectory()) {
+        yield* walk(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$1
+        };
+      }
+    }
+  } catch (error) {
+    if (error instanceof WalkError) {
+      throw error;
+    }
+    throw new WalkError(error, directory);
+  }
+}
+__name(walk, "walk");
+
+module.exports = walk;

package/dist/packem_shared/walk-CNcSYQVq.mjs

@@ -0,0 +1,104 @@
+import { readdir, realpath, stat } from 'node:fs/promises';
+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(async (path) => {
+  const normalizePath = normalize(path);
+  const name = basename(normalizePath);
+  const info = await stat(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: normalizePath
+  };
+}, "_createWalkEntry");
+async function* walk(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 await _createWalkEntry(directory);
+  }
+  if (maxDepth < 1 || !walkInclude(directory, undefined, undefined, mappedSkip)) {
+    return;
+  }
+  try {
+    for await (const entry of await readdir(directory, {
+      withFileTypes: true
+    })) {
+      let path = join(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        if (followSymlinks) {
+          path = await realpath(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
+          };
+        } else {
+          continue;
+        }
+      }
+      if (entry.isSymbolicLink() || entry.isDirectory()) {
+        yield* walk(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
+        };
+      }
+    }
+  } catch (error) {
+    if (error instanceof WalkError) {
+      throw error;
+    }
+    throw new WalkError(error, directory);
+  }
+}
+__name(walk, "walk");
+
+export { walk as default };

package/dist/packem_shared/walk-include-CMUSRa86.mjs

@@ -0,0 +1,20 @@
+var __defProp$1 = Object.defineProperty;
+var __name$1 = (target, value) => __defProp$1(target, "name", { value, configurable: true });
+const globToRegExp = /* @__PURE__ */ __name$1((glob) => {
+  const reString = glob.replace(/\.\*/g, ".([^/]*)").replace(/\*\*/g, "(.*)").replace(/(?<!\.)\*(?!\*)/g, "([^/]*)").replace(/\?/g, "[^/]").replace(/\.(?!\*)/g, "\\.").replace(/\{/g, "(").replace(/\}/g, ")").replace(/,/g, "|").replace(/\[!(.*?)\]/g, "[^$1]");
+  return new RegExp(`^${reString}$`);
+}, "globToRegExp");
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const walkInclude = /* @__PURE__ */ __name((path, extensions, match, skip) => {
+  if (Array.isArray(extensions) && extensions.length > 0 && !extensions.some((extension) => path.endsWith(extension))) {
+    return false;
+  }
+  if (match && !match.some((pattern) => pattern.test(path))) {
+    return false;
+  }
+  return !skip?.some((pattern) => pattern.test(path));
+}, "walkInclude");
+
+export { globToRegExp as g, walkInclude as w };

package/dist/packem_shared/walk-include-yUdRrF16.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var __defProp$1 = Object.defineProperty;
+var __name$1 = (target, value) => __defProp$1(target, "name", { value, configurable: true });
+const globToRegExp = /* @__PURE__ */ __name$1((glob) => {
+  const reString = glob.replace(/\.\*/g, ".([^/]*)").replace(/\*\*/g, "(.*)").replace(/(?<!\.)\*(?!\*)/g, "([^/]*)").replace(/\?/g, "[^/]").replace(/\.(?!\*)/g, "\\.").replace(/\{/g, "(").replace(/\}/g, ")").replace(/,/g, "|").replace(/\[!(.*?)\]/g, "[^$1]");
+  return new RegExp(`^${reString}$`);
+}, "globToRegExp");
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const walkInclude = /* @__PURE__ */ __name((path, extensions, match, skip) => {
+  if (Array.isArray(extensions) && extensions.length > 0 && !extensions.some((extension) => path.endsWith(extension))) {
+    return false;
+  }
+  if (match && !match.some((pattern) => pattern.test(path))) {
+    return false;
+  }
+  return !skip?.some((pattern) => pattern.test(path));
+}, "walkInclude");
+
+exports.globToRegExp = globToRegExp;
+exports.walkInclude = walkInclude;

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;