@stryke/fs 0.33.32 → 0.33.34

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 # Changelog for Stryke - Fs
 
+## [0.33.33](https://github.com/storm-software/stryke/releases/tag/fs%400.33.33) (01/16/2026)
+
+### Updated Dependencies
+
+- Updated **string-format** to **v0.13.3**
+- Updated **type-checks** to **v0.5.19**
+- Updated **convert** to **v0.6.34**
+- Updated **helpers** to **v0.9.36**
+- Updated **types** to **v0.10.33**
+- Updated **json** to **v0.9.37**
+- Updated **path** to **v0.25.1**
+
+## [0.33.32](https://github.com/storm-software/stryke/releases/tag/fs%400.33.32) (01/16/2026)
+
+### Updated Dependencies
+
+- Updated **path** to **v0.25.0**
+
 ## [0.33.31](https://github.com/storm-software/stryke/releases/tag/fs%400.33.31) (01/16/2026)
 
 ### Updated Dependencies

package/dist/_virtual/rolldown_runtime.cjs

@@ -1 +1,29 @@
-var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},s=(n,r,a)=>(a=n==null?{}:e(i(n)),o(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n));exports.__toESM=s;
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/dist/buffer.cjs

@@ -1 +1,60 @@
-const e=require(`./_virtual/rolldown_runtime.cjs`),t=require(`./path/src/file-path-fns.cjs`),n=require(`./helpers.cjs`);let r=require(`node:buffer`),i=require(`node:fs`),a=require(`node:fs/promises`);async function o(e){if(!e)throw Error(`No file path provided to read data`);if(!(0,i.existsSync)(e))throw Error(`File does not exist at path: ${e}`);let t=await(0,a.readFile)(e);return t.buffer.slice(t.byteOffset,t.byteOffset+t.byteLength)}function s(e){if(!e)throw Error(`No file path provided to read data`);if(!(0,i.existsSync)(e))throw Error(`File does not exist at path: ${e}`);let t=(0,i.readFileSync)(e);return t.buffer.slice(t.byteOffset,t.byteOffset+t.byteLength)}async function c(e,o){if(!e)throw Error(`No file path provided to write data`);(0,i.existsSync)(t.findFilePath(e))||await n.createDirectory(t.findFilePath(e)),await(0,a.writeFile)(e,r.Buffer.from(o))}function l(e,a){if(!e)throw Error(`No file path provided to write data`);(0,i.existsSync)(t.findFilePath(e))||n.createDirectorySync(t.findFilePath(e)),(0,i.writeFileSync)(e,r.Buffer.from(a))}exports.readFileBuffer=o,exports.readFileBufferSync=s,exports.writeFileBuffer=c,exports.writeFileBufferSync=l;
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_file_path_fns = require('./path/src/file-path-fns.cjs');
+const require_helpers = require('./helpers.cjs');
+let node_buffer = require("node:buffer");
+let node_fs = require("node:fs");
+let node_fs_promises = require("node:fs/promises");
+
+//#region src/buffer.ts
+/**
+* Reads a file from the given path and returns its content as an ArrayBuffer. The file is expected to be located relative to the current directory of this module.
+*
+* @param filePath - The path to the file to read.
+* @returns The content of the file as an ArrayBuffer.
+*/
+async function readFileBuffer(filePath) {
+	if (!filePath) throw new Error("No file path provided to read data");
+	if (!(0, node_fs.existsSync)(filePath)) throw new Error(`File does not exist at path: ${filePath}`);
+	const b = await (0, node_fs_promises.readFile)(filePath);
+	return b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength);
+}
+/**
+* Reads a file from the given path and returns its content as an ArrayBuffer. The file is expected to be located relative to the current directory of this module.
+*
+* @param filePath - The path to the file to read.
+* @returns The content of the file as an ArrayBuffer.
+*/
+function readFileBufferSync(filePath) {
+	if (!filePath) throw new Error("No file path provided to read data");
+	if (!(0, node_fs.existsSync)(filePath)) throw new Error(`File does not exist at path: ${filePath}`);
+	const b = (0, node_fs.readFileSync)(filePath);
+	return b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength);
+}
+/**
+* Writes an ArrayBuffer to a file at the specified path.
+*
+* @param filePath - The path to the file where the data should be written.
+* @param data - The ArrayBuffer containing the data to write.
+*/
+async function writeFileBuffer(filePath, data) {
+	if (!filePath) throw new Error("No file path provided to write data");
+	if (!(0, node_fs.existsSync)(require_file_path_fns.findFilePath(filePath))) await require_helpers.createDirectory(require_file_path_fns.findFilePath(filePath));
+	await (0, node_fs_promises.writeFile)(filePath, node_buffer.Buffer.from(data));
+}
+/**
+* Writes an ArrayBuffer to a file at the specified path.
+*
+* @param filePath - The path to the file where the data should be written.
+* @param data - The ArrayBuffer containing the data to write.
+*/
+function writeFileBufferSync(filePath, data) {
+	if (!filePath) throw new Error("No file path provided to write data");
+	if (!(0, node_fs.existsSync)(require_file_path_fns.findFilePath(filePath))) require_helpers.createDirectorySync(require_file_path_fns.findFilePath(filePath));
+	(0, node_fs.writeFileSync)(filePath, node_buffer.Buffer.from(data));
+}
+
+//#endregion
+exports.readFileBuffer = readFileBuffer;
+exports.readFileBufferSync = readFileBufferSync;
+exports.writeFileBuffer = writeFileBuffer;
+exports.writeFileBufferSync = writeFileBufferSync;

package/dist/buffer.mjs

@@ -1,2 +1,57 @@
-import{findFilePath as e}from"./path/src/file-path-fns.mjs";import{createDirectory as t,createDirectorySync as n}from"./helpers.mjs";import{Buffer as r}from"node:buffer";import{existsSync as i,readFileSync as a,writeFileSync as o}from"node:fs";import{readFile as s,writeFile as c}from"node:fs/promises";async function l(e){if(!e)throw Error(`No file path provided to read data`);if(!i(e))throw Error(`File does not exist at path: ${e}`);let t=await s(e);return t.buffer.slice(t.byteOffset,t.byteOffset+t.byteLength)}function u(e){if(!e)throw Error(`No file path provided to read data`);if(!i(e))throw Error(`File does not exist at path: ${e}`);let t=a(e);return t.buffer.slice(t.byteOffset,t.byteOffset+t.byteLength)}async function d(n,a){if(!n)throw Error(`No file path provided to write data`);i(e(n))||await t(e(n)),await c(n,r.from(a))}function f(t,a){if(!t)throw Error(`No file path provided to write data`);i(e(t))||n(e(t)),o(t,r.from(a))}export{l as readFileBuffer,u as readFileBufferSync,d as writeFileBuffer,f as writeFileBufferSync};
+import { findFilePath } from "./path/src/file-path-fns.mjs";
+import { createDirectory, createDirectorySync } from "./helpers.mjs";
+import { Buffer } from "node:buffer";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+
+//#region src/buffer.ts
+/**
+* Reads a file from the given path and returns its content as an ArrayBuffer. The file is expected to be located relative to the current directory of this module.
+*
+* @param filePath - The path to the file to read.
+* @returns The content of the file as an ArrayBuffer.
+*/
+async function readFileBuffer(filePath) {
+	if (!filePath) throw new Error("No file path provided to read data");
+	if (!existsSync(filePath)) throw new Error(`File does not exist at path: ${filePath}`);
+	const b = await readFile(filePath);
+	return b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength);
+}
+/**
+* Reads a file from the given path and returns its content as an ArrayBuffer. The file is expected to be located relative to the current directory of this module.
+*
+* @param filePath - The path to the file to read.
+* @returns The content of the file as an ArrayBuffer.
+*/
+function readFileBufferSync(filePath) {
+	if (!filePath) throw new Error("No file path provided to read data");
+	if (!existsSync(filePath)) throw new Error(`File does not exist at path: ${filePath}`);
+	const b = readFileSync(filePath);
+	return b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength);
+}
+/**
+* Writes an ArrayBuffer to a file at the specified path.
+*
+* @param filePath - The path to the file where the data should be written.
+* @param data - The ArrayBuffer containing the data to write.
+*/
+async function writeFileBuffer(filePath, data) {
+	if (!filePath) throw new Error("No file path provided to write data");
+	if (!existsSync(findFilePath(filePath))) await createDirectory(findFilePath(filePath));
+	await writeFile(filePath, Buffer.from(data));
+}
+/**
+* Writes an ArrayBuffer to a file at the specified path.
+*
+* @param filePath - The path to the file where the data should be written.
+* @param data - The ArrayBuffer containing the data to write.
+*/
+function writeFileBufferSync(filePath, data) {
+	if (!filePath) throw new Error("No file path provided to write data");
+	if (!existsSync(findFilePath(filePath))) createDirectorySync(findFilePath(filePath));
+	writeFileSync(filePath, Buffer.from(data));
+}
+
+//#endregion
+export { readFileBuffer, readFileBufferSync, writeFileBuffer, writeFileBufferSync };
 //# sourceMappingURL=buffer.mjs.map

package/dist/buffer.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"buffer.mjs","names":[],"sources":["../src/buffer.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { findFilePath } from \"@stryke/path\";\nimport { Buffer } from \"node:buffer\";\nimport { existsSync, readFileSync, writeFileSync } from \"node:fs\";\nimport { readFile, writeFile } from \"node:fs/promises\";\nimport { createDirectory, createDirectorySync } from \"./helpers\";\n\n/**\n * Reads a file from the given path and returns its content as an ArrayBuffer. The file is expected to be located relative to the current directory of this module.\n *\n * @param filePath - The path to the file to read.\n * @returns The content of the file as an ArrayBuffer.\n */\nexport async function readFileBuffer(filePath: string): Promise<ArrayBuffer> {\n  if (!filePath) {\n    throw new Error(\"No file path provided to read data\");\n  }\n  if (!existsSync(filePath)) {\n    throw new Error(`File does not exist at path: ${filePath}`);\n  }\n\n  const b = await readFile(filePath);\n\n  return b.buffer.slice(\n    b.byteOffset,\n    b.byteOffset + b.byteLength\n  ) as ArrayBuffer;\n}\n\n/**\n * Reads a file from the given path and returns its content as an ArrayBuffer. The file is expected to be located relative to the current directory of this module.\n *\n * @param filePath - The path to the file to read.\n * @returns The content of the file as an ArrayBuffer.\n */\nexport function readFileBufferSync(filePath: string): ArrayBuffer {\n  if (!filePath) {\n    throw new Error(\"No file path provided to read data\");\n  }\n  if (!existsSync(filePath)) {\n    throw new Error(`File does not exist at path: ${filePath}`);\n  }\n\n  const b = readFileSync(filePath);\n\n  return b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength);\n}\n\n/**\n * Writes an ArrayBuffer to a file at the specified path.\n *\n * @param filePath - The path to the file where the data should be written.\n * @param data - The ArrayBuffer containing the data to write.\n */\nexport async function writeFileBuffer(filePath: string, data: ArrayBuffer) {\n  if (!filePath) {\n    throw new Error(\"No file path provided to write data\");\n  }\n  if (!existsSync(findFilePath(filePath))) {\n    await createDirectory(findFilePath(filePath));\n  }\n\n  await writeFile(filePath, Buffer.from(data));\n}\n\n/**\n * Writes an ArrayBuffer to a file at the specified path.\n *\n * @param filePath - The path to the file where the data should be written.\n * @param data - The ArrayBuffer containing the data to write.\n */\nexport function writeFileBufferSync(filePath: string, data: ArrayBuffer) {\n  if (!filePath) {\n    throw new Error(\"No file path provided to write data\");\n  }\n  if (!existsSync(findFilePath(filePath))) {\n    createDirectorySync(findFilePath(filePath));\n  }\n\n  writeFileSync(filePath, Buffer.from(data));\n}\n"],"mappings":"+SA8BA,eAAsB,EAAe,EAAwC,CAC3E,GAAI,CAAC,EACH,MAAU,MAAM,qCAAqC,CAEvD,GAAI,CAAC,EAAW,EAAS,CACvB,MAAU,MAAM,gCAAgC,IAAW,CAG7D,IAAM,EAAI,MAAM,EAAS,EAAS,CAElC,OAAO,EAAE,OAAO,MACd,EAAE,WACF,EAAE,WAAa,EAAE,WAClB,CASH,SAAgB,EAAmB,EAA+B,CAChE,GAAI,CAAC,EACH,MAAU,MAAM,qCAAqC,CAEvD,GAAI,CAAC,EAAW,EAAS,CACvB,MAAU,MAAM,gCAAgC,IAAW,CAG7D,IAAM,EAAI,EAAa,EAAS,CAEhC,OAAO,EAAE,OAAO,MAAM,EAAE,WAAY,EAAE,WAAa,EAAE,WAAW,CASlE,eAAsB,EAAgB,EAAkB,EAAmB,CACzE,GAAI,CAAC,EACH,MAAU,MAAM,sCAAsC,CAEnD,EAAW,EAAa,EAAS,CAAC,EACrC,MAAM,EAAgB,EAAa,EAAS,CAAC,CAG/C,MAAM,EAAU,EAAU,EAAO,KAAK,EAAK,CAAC,CAS9C,SAAgB,EAAoB,EAAkB,EAAmB,CACvE,GAAI,CAAC,EACH,MAAU,MAAM,sCAAsC,CAEnD,EAAW,EAAa,EAAS,CAAC,EACrC,EAAoB,EAAa,EAAS,CAAC,CAG7C,EAAc,EAAU,EAAO,KAAK,EAAK,CAAC"}
+{"version":3,"file":"buffer.mjs","names":[],"sources":["../src/buffer.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { findFilePath } from \"@stryke/path\";\nimport { Buffer } from \"node:buffer\";\nimport { existsSync, readFileSync, writeFileSync } from \"node:fs\";\nimport { readFile, writeFile } from \"node:fs/promises\";\nimport { createDirectory, createDirectorySync } from \"./helpers\";\n\n/**\n * Reads a file from the given path and returns its content as an ArrayBuffer. The file is expected to be located relative to the current directory of this module.\n *\n * @param filePath - The path to the file to read.\n * @returns The content of the file as an ArrayBuffer.\n */\nexport async function readFileBuffer(filePath: string): Promise<ArrayBuffer> {\n  if (!filePath) {\n    throw new Error(\"No file path provided to read data\");\n  }\n  if (!existsSync(filePath)) {\n    throw new Error(`File does not exist at path: ${filePath}`);\n  }\n\n  const b = await readFile(filePath);\n\n  return b.buffer.slice(\n    b.byteOffset,\n    b.byteOffset + b.byteLength\n  ) as ArrayBuffer;\n}\n\n/**\n * Reads a file from the given path and returns its content as an ArrayBuffer. The file is expected to be located relative to the current directory of this module.\n *\n * @param filePath - The path to the file to read.\n * @returns The content of the file as an ArrayBuffer.\n */\nexport function readFileBufferSync(filePath: string): ArrayBuffer {\n  if (!filePath) {\n    throw new Error(\"No file path provided to read data\");\n  }\n  if (!existsSync(filePath)) {\n    throw new Error(`File does not exist at path: ${filePath}`);\n  }\n\n  const b = readFileSync(filePath);\n\n  return b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength);\n}\n\n/**\n * Writes an ArrayBuffer to a file at the specified path.\n *\n * @param filePath - The path to the file where the data should be written.\n * @param data - The ArrayBuffer containing the data to write.\n */\nexport async function writeFileBuffer(filePath: string, data: ArrayBuffer) {\n  if (!filePath) {\n    throw new Error(\"No file path provided to write data\");\n  }\n  if (!existsSync(findFilePath(filePath))) {\n    await createDirectory(findFilePath(filePath));\n  }\n\n  await writeFile(filePath, Buffer.from(data));\n}\n\n/**\n * Writes an ArrayBuffer to a file at the specified path.\n *\n * @param filePath - The path to the file where the data should be written.\n * @param data - The ArrayBuffer containing the data to write.\n */\nexport function writeFileBufferSync(filePath: string, data: ArrayBuffer) {\n  if (!filePath) {\n    throw new Error(\"No file path provided to write data\");\n  }\n  if (!existsSync(findFilePath(filePath))) {\n    createDirectorySync(findFilePath(filePath));\n  }\n\n  writeFileSync(filePath, Buffer.from(data));\n}\n"],"mappings":";;;;;;;;;;;;;AA8BA,eAAsB,eAAe,UAAwC;AAC3E,KAAI,CAAC,SACH,OAAM,IAAI,MAAM,qCAAqC;AAEvD,KAAI,CAAC,WAAW,SAAS,CACvB,OAAM,IAAI,MAAM,gCAAgC,WAAW;CAG7D,MAAM,IAAI,MAAM,SAAS,SAAS;AAElC,QAAO,EAAE,OAAO,MACd,EAAE,YACF,EAAE,aAAa,EAAE,WAClB;;;;;;;;AASH,SAAgB,mBAAmB,UAA+B;AAChE,KAAI,CAAC,SACH,OAAM,IAAI,MAAM,qCAAqC;AAEvD,KAAI,CAAC,WAAW,SAAS,CACvB,OAAM,IAAI,MAAM,gCAAgC,WAAW;CAG7D,MAAM,IAAI,aAAa,SAAS;AAEhC,QAAO,EAAE,OAAO,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW;;;;;;;;AASlE,eAAsB,gBAAgB,UAAkB,MAAmB;AACzE,KAAI,CAAC,SACH,OAAM,IAAI,MAAM,sCAAsC;AAExD,KAAI,CAAC,WAAW,aAAa,SAAS,CAAC,CACrC,OAAM,gBAAgB,aAAa,SAAS,CAAC;AAG/C,OAAM,UAAU,UAAU,OAAO,KAAK,KAAK,CAAC;;;;;;;;AAS9C,SAAgB,oBAAoB,UAAkB,MAAmB;AACvE,KAAI,CAAC,SACH,OAAM,IAAI,MAAM,sCAAsC;AAExD,KAAI,CAAC,WAAW,aAAa,SAAS,CAAC,CACrC,qBAAoB,aAAa,SAAS,CAAC;AAG7C,eAAc,UAAU,OAAO,KAAK,KAAK,CAAC"}

package/dist/chmod-x.cjs

@@ -1 +1,93 @@
-const e=require(`./_virtual/rolldown_runtime.cjs`);let t=require(`node:fs`),n=require(`node:fs/promises`);function r(e){if(process.platform===`win32`)return;let n=(0,t.statSync)(e),r=n.mode|73;n.mode!==r&&(0,t.chmodSync)(e,r.toString(8).slice(-3))}async function i(e){if(process.platform===`win32`)return;let r=(0,t.statSync)(e),i=r.mode|73;if(r.mode!==i)return(0,n.chmod)(e,i.toString(8).slice(-3))}async function a(e){try{return await(0,n.access)(e,t.constants.W_OK),!0}catch{return!1}}function o(e){try{return(0,t.accessSync)(e,t.constants.W_OK),!0}catch{return!1}}async function s(e){try{return await(0,n.access)(e,t.constants.X_OK),!0}catch{return!1}}function c(e){try{return(0,t.accessSync)(e,t.constants.X_OK),!0}catch{return!1}}exports.chmodX=i,exports.chmodXSync=r,exports.isExecutable=s,exports.isExecutableSync=c,exports.isWritable=a,exports.isWritableSync=o;
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let node_fs = require("node:fs");
+let node_fs_promises = require("node:fs/promises");
+
+//#region src/chmod-x.ts
+/**
+* Adds execute permissions to a file
+*
+* @param file - The file to add execute permissions to
+*/
+function chmodXSync(file) {
+	if (process.platform === "win32") return;
+	const s = (0, node_fs.statSync)(file);
+	const newMode = s.mode | 73;
+	if (s.mode === newMode) return;
+	(0, node_fs.chmodSync)(file, newMode.toString(8).slice(-3));
+}
+/**
+* Adds execute permissions to a file
+*
+* @param file - The file to add execute permissions to
+*/
+async function chmodX(file) {
+	if (process.platform === "win32") return;
+	const s = (0, node_fs.statSync)(file);
+	const newMode = s.mode | 73;
+	if (s.mode === newMode) return;
+	return (0, node_fs_promises.chmod)(file, newMode.toString(8).slice(-3));
+}
+/**
+* Checks the write permission of a file
+*
+* @param filename - The file to check the permission of
+* @returns A promise that resolves to true if the file is writable, false otherwise
+*/
+async function isWritable(filename) {
+	try {
+		await (0, node_fs_promises.access)(filename, node_fs.constants.W_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Checks the write permission of a file
+*
+* @param filename - The file to check the permission of
+* @returns True if the file is writable, false otherwise
+*/
+function isWritableSync(filename) {
+	try {
+		(0, node_fs.accessSync)(filename, node_fs.constants.W_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Checks the execute permission of a file
+*
+* @param filename - The file to check the permission of
+* @returns A promise that resolves to true if the file is executable, false otherwise
+*/
+async function isExecutable(filename) {
+	try {
+		await (0, node_fs_promises.access)(filename, node_fs.constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Checks the execute permission of a file
+*
+* @param filename - The file to check the permission of
+* @returns True if the file is executable, false otherwise
+*/
+function isExecutableSync(filename) {
+	try {
+		(0, node_fs.accessSync)(filename, node_fs.constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+exports.chmodX = chmodX;
+exports.chmodXSync = chmodXSync;
+exports.isExecutable = isExecutable;
+exports.isExecutableSync = isExecutableSync;
+exports.isWritable = isWritable;
+exports.isWritableSync = isWritableSync;

package/dist/chmod-x.mjs

@@ -1,2 +1,88 @@
-import{accessSync as e,chmodSync as t,constants as n,statSync as r}from"node:fs";import{access as i,chmod as a}from"node:fs/promises";function o(e){if(process.platform===`win32`)return;let n=r(e),i=n.mode|73;n.mode!==i&&t(e,i.toString(8).slice(-3))}async function s(e){if(process.platform===`win32`)return;let t=r(e),n=t.mode|73;if(t.mode!==n)return a(e,n.toString(8).slice(-3))}async function c(e){try{return await i(e,n.W_OK),!0}catch{return!1}}function l(t){try{return e(t,n.W_OK),!0}catch{return!1}}async function u(e){try{return await i(e,n.X_OK),!0}catch{return!1}}function d(t){try{return e(t,n.X_OK),!0}catch{return!1}}export{s as chmodX,o as chmodXSync,u as isExecutable,d as isExecutableSync,c as isWritable,l as isWritableSync};
+import { accessSync, chmodSync, constants, statSync } from "node:fs";
+import { access, chmod } from "node:fs/promises";
+
+//#region src/chmod-x.ts
+/**
+* Adds execute permissions to a file
+*
+* @param file - The file to add execute permissions to
+*/
+function chmodXSync(file) {
+	if (process.platform === "win32") return;
+	const s = statSync(file);
+	const newMode = s.mode | 73;
+	if (s.mode === newMode) return;
+	chmodSync(file, newMode.toString(8).slice(-3));
+}
+/**
+* Adds execute permissions to a file
+*
+* @param file - The file to add execute permissions to
+*/
+async function chmodX(file) {
+	if (process.platform === "win32") return;
+	const s = statSync(file);
+	const newMode = s.mode | 73;
+	if (s.mode === newMode) return;
+	return chmod(file, newMode.toString(8).slice(-3));
+}
+/**
+* Checks the write permission of a file
+*
+* @param filename - The file to check the permission of
+* @returns A promise that resolves to true if the file is writable, false otherwise
+*/
+async function isWritable(filename) {
+	try {
+		await access(filename, constants.W_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Checks the write permission of a file
+*
+* @param filename - The file to check the permission of
+* @returns True if the file is writable, false otherwise
+*/
+function isWritableSync(filename) {
+	try {
+		accessSync(filename, constants.W_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Checks the execute permission of a file
+*
+* @param filename - The file to check the permission of
+* @returns A promise that resolves to true if the file is executable, false otherwise
+*/
+async function isExecutable(filename) {
+	try {
+		await access(filename, constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Checks the execute permission of a file
+*
+* @param filename - The file to check the permission of
+* @returns True if the file is executable, false otherwise
+*/
+function isExecutableSync(filename) {
+	try {
+		accessSync(filename, constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+export { chmodX, chmodXSync, isExecutable, isExecutableSync, isWritable, isWritableSync };
 //# sourceMappingURL=chmod-x.mjs.map

package/dist/chmod-x.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"chmod-x.mjs","names":[],"sources":["../src/chmod-x.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { accessSync, chmodSync, constants, statSync } from \"node:fs\";\nimport { access, chmod } from \"node:fs/promises\";\n\n/**\n * Adds execute permissions to a file\n *\n * @param file - The file to add execute permissions to\n */\nexport function chmodXSync(file: string) {\n  // Note: skip for windows as chmod does on exist there\n  // and will error with `EACCES: permission denied`\n  if (process.platform === \"win32\") {\n    return;\n  }\n\n  const s = statSync(file);\n  const newMode = s.mode | 64 | 8 | 1;\n\n  if (s.mode === newMode) {\n    return;\n  }\n  const base8 = newMode.toString(8).slice(-3);\n\n  chmodSync(file, base8);\n}\n\n/**\n * Adds execute permissions to a file\n *\n * @param file - The file to add execute permissions to\n */\nexport async function chmodX(file: string) {\n  // Note: skip for windows as chmod does on exist there\n  // and will error with `EACCES: permission denied`\n  if (process.platform === \"win32\") {\n    return;\n  }\n\n  const s = statSync(file);\n  const newMode = s.mode | 64 | 8 | 1;\n\n  if (s.mode === newMode) {\n    return;\n  }\n  const base8 = newMode.toString(8).slice(-3);\n\n  return chmod(file, base8);\n}\n\n/**\n * Checks the write permission of a file\n *\n * @param filename - The file to check the permission of\n * @returns A promise that resolves to true if the file is writable, false otherwise\n */\nexport async function isWritable(filename: string): Promise<boolean> {\n  try {\n    await access(filename, constants.W_OK);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Checks the write permission of a file\n *\n * @param filename - The file to check the permission of\n * @returns True if the file is writable, false otherwise\n */\nexport function isWritableSync(filename: string): boolean {\n  try {\n    accessSync(filename, constants.W_OK);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Checks the execute permission of a file\n *\n * @param filename - The file to check the permission of\n * @returns A promise that resolves to true if the file is executable, false otherwise\n */\nexport async function isExecutable(filename: string): Promise<boolean> {\n  try {\n    await access(filename, constants.X_OK);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Checks the execute permission of a file\n *\n * @param filename - The file to check the permission of\n * @returns True if the file is executable, false otherwise\n */\nexport function isExecutableSync(filename: string): boolean {\n  try {\n    accessSync(filename, constants.X_OK);\n    return true;\n  } catch {\n    return false;\n  }\n}\n"],"mappings":"sIA0BA,SAAgB,EAAW,EAAc,CAGvC,GAAI,QAAQ,WAAa,QACvB,OAGF,IAAM,EAAI,EAAS,EAAK,CAClB,EAAU,EAAE,KAAO,GAErB,EAAE,OAAS,GAKf,EAAU,EAFI,EAAQ,SAAS,EAAE,CAAC,MAAM,GAAG,CAErB,CAQxB,eAAsB,EAAO,EAAc,CAGzC,GAAI,QAAQ,WAAa,QACvB,OAGF,IAAM,EAAI,EAAS,EAAK,CAClB,EAAU,EAAE,KAAO,GAErB,KAAE,OAAS,EAKf,OAAO,EAAM,EAFC,EAAQ,SAAS,EAAE,CAAC,MAAM,GAAG,CAElB,CAS3B,eAAsB,EAAW,EAAoC,CACnE,GAAI,CAEF,OADA,MAAM,EAAO,EAAU,EAAU,KAAK,CAC/B,QACD,CACN,MAAO,IAUX,SAAgB,EAAe,EAA2B,CACxD,GAAI,CAEF,OADA,EAAW,EAAU,EAAU,KAAK,CAC7B,QACD,CACN,MAAO,IAUX,eAAsB,EAAa,EAAoC,CACrE,GAAI,CAEF,OADA,MAAM,EAAO,EAAU,EAAU,KAAK,CAC/B,QACD,CACN,MAAO,IAUX,SAAgB,EAAiB,EAA2B,CAC1D,GAAI,CAEF,OADA,EAAW,EAAU,EAAU,KAAK,CAC7B,QACD,CACN,MAAO"}
+{"version":3,"file":"chmod-x.mjs","names":[],"sources":["../src/chmod-x.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { accessSync, chmodSync, constants, statSync } from \"node:fs\";\nimport { access, chmod } from \"node:fs/promises\";\n\n/**\n * Adds execute permissions to a file\n *\n * @param file - The file to add execute permissions to\n */\nexport function chmodXSync(file: string) {\n  // Note: skip for windows as chmod does on exist there\n  // and will error with `EACCES: permission denied`\n  if (process.platform === \"win32\") {\n    return;\n  }\n\n  const s = statSync(file);\n  const newMode = s.mode | 64 | 8 | 1;\n\n  if (s.mode === newMode) {\n    return;\n  }\n  const base8 = newMode.toString(8).slice(-3);\n\n  chmodSync(file, base8);\n}\n\n/**\n * Adds execute permissions to a file\n *\n * @param file - The file to add execute permissions to\n */\nexport async function chmodX(file: string) {\n  // Note: skip for windows as chmod does on exist there\n  // and will error with `EACCES: permission denied`\n  if (process.platform === \"win32\") {\n    return;\n  }\n\n  const s = statSync(file);\n  const newMode = s.mode | 64 | 8 | 1;\n\n  if (s.mode === newMode) {\n    return;\n  }\n  const base8 = newMode.toString(8).slice(-3);\n\n  return chmod(file, base8);\n}\n\n/**\n * Checks the write permission of a file\n *\n * @param filename - The file to check the permission of\n * @returns A promise that resolves to true if the file is writable, false otherwise\n */\nexport async function isWritable(filename: string): Promise<boolean> {\n  try {\n    await access(filename, constants.W_OK);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Checks the write permission of a file\n *\n * @param filename - The file to check the permission of\n * @returns True if the file is writable, false otherwise\n */\nexport function isWritableSync(filename: string): boolean {\n  try {\n    accessSync(filename, constants.W_OK);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Checks the execute permission of a file\n *\n * @param filename - The file to check the permission of\n * @returns A promise that resolves to true if the file is executable, false otherwise\n */\nexport async function isExecutable(filename: string): Promise<boolean> {\n  try {\n    await access(filename, constants.X_OK);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Checks the execute permission of a file\n *\n * @param filename - The file to check the permission of\n * @returns True if the file is executable, false otherwise\n */\nexport function isExecutableSync(filename: string): boolean {\n  try {\n    accessSync(filename, constants.X_OK);\n    return true;\n  } catch {\n    return false;\n  }\n}\n"],"mappings":";;;;;;;;;AA0BA,SAAgB,WAAW,MAAc;AAGvC,KAAI,QAAQ,aAAa,QACvB;CAGF,MAAM,IAAI,SAAS,KAAK;CACxB,MAAM,UAAU,EAAE,OAAO;AAEzB,KAAI,EAAE,SAAS,QACb;AAIF,WAAU,MAFI,QAAQ,SAAS,EAAE,CAAC,MAAM,GAAG,CAErB;;;;;;;AAQxB,eAAsB,OAAO,MAAc;AAGzC,KAAI,QAAQ,aAAa,QACvB;CAGF,MAAM,IAAI,SAAS,KAAK;CACxB,MAAM,UAAU,EAAE,OAAO;AAEzB,KAAI,EAAE,SAAS,QACb;AAIF,QAAO,MAAM,MAFC,QAAQ,SAAS,EAAE,CAAC,MAAM,GAAG,CAElB;;;;;;;;AAS3B,eAAsB,WAAW,UAAoC;AACnE,KAAI;AACF,QAAM,OAAO,UAAU,UAAU,KAAK;AACtC,SAAO;SACD;AACN,SAAO;;;;;;;;;AAUX,SAAgB,eAAe,UAA2B;AACxD,KAAI;AACF,aAAW,UAAU,UAAU,KAAK;AACpC,SAAO;SACD;AACN,SAAO;;;;;;;;;AAUX,eAAsB,aAAa,UAAoC;AACrE,KAAI;AACF,QAAM,OAAO,UAAU,UAAU,KAAK;AACtC,SAAO;SACD;AACN,SAAO;;;;;;;;;AAUX,SAAgB,iBAAiB,UAA2B;AAC1D,KAAI;AACF,aAAW,UAAU,UAAU,KAAK;AACpC,SAAO;SACD;AACN,SAAO"}

package/dist/command-exists.cjs

@@ -1 +1,102 @@
-const e=require(`./_virtual/rolldown_runtime.cjs`);let t=require(`node:fs`),n=require(`node:fs/promises`),r=require(`node:child_process`),i=require(`node:path`);const a=process.platform==`win32`;async function o(e){try{return await(0,n.access)(e,n.constants.F_OK),!1}catch{return!0}}function s(e){try{return(0,t.accessSync)(e,n.constants.F_OK),!1}catch{return!0}}async function c(e){return(0,n.access)(e,n.constants.F_OK|n.constants.X_OK)}function l(e){try{return(0,t.accessSync)(e,n.constants.F_OK|n.constants.X_OK),!0}catch{return!1}}async function u(e,t){await o(e)||((0,r.exec)(`command -v ${t} 2>/dev/null && { echo >&1 ${t}; exit 0; }`),await c(e))}async function d(e,t){/^(?!(?:.*\s|.*\.|\W+)$)(?:[a-z]:)?[^<>:"|?*\n]+$/im.test(e)&&(0,r.exec)(`where ${t}`)}function f(e,t){if(s(e))try{return!!(0,r.execSync)(`command -v ${t} 2>/dev/null && { echo >&1 ${t}; exit 0; }`)}catch{return!1}return l(e)}function p(e,t){if(!/^(?!(?:.*\s|.*\.|\W+)$)(?:[a-z]:)?[^<>:"|?*\n]+$/im.test(e))return!1;try{return!!(0,r.execSync)(`where ${t}`,{stdio:[]})}catch{return!1}}function m(e){return/[^\w/:=-]/.test(e)&&(e=`'${e.replace(/'/g,`'\\''`)}'`,e=e.replace(/^(?:'')+/g,``).replace(/\\'''/g,`\\'`)),e}const h=e=>/\\/.test(e)?`"${(0,i.dirname)(e)}:${(0,i.basename)(e)}"`:`"${e}"`;async function g(e){let t=m(e);return typeof Promise<`u`?g(e):a?d(e,t):u(e,t)}function _(e){return a?p(e,h(e)):f(e,m(e))}exports.commandExists=g,exports.commandExistsSync=_;
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let node_fs = require("node:fs");
+let node_fs_promises = require("node:fs/promises");
+let node_child_process = require("node:child_process");
+let node_path = require("node:path");
+
+//#region src/command-exists.ts
+const isUsingWindows = process.platform == "win32";
+async function fileNotExists(commandName) {
+	try {
+		await (0, node_fs_promises.access)(commandName, node_fs_promises.constants.F_OK);
+		return false;
+	} catch (_) {
+		return true;
+	}
+}
+function fileNotExistsSync(commandName) {
+	try {
+		(0, node_fs.accessSync)(commandName, node_fs_promises.constants.F_OK);
+		return false;
+	} catch (_) {
+		return true;
+	}
+}
+async function localExecutable(commandName) {
+	return (0, node_fs_promises.access)(commandName, node_fs_promises.constants.F_OK | node_fs_promises.constants.X_OK);
+}
+function localExecutableSync(commandName) {
+	try {
+		(0, node_fs.accessSync)(commandName, node_fs_promises.constants.F_OK | node_fs_promises.constants.X_OK);
+		return true;
+	} catch (_) {
+		return false;
+	}
+}
+async function commandExistsUnix(commandName, cleanedCommandName) {
+	if (!await fileNotExists(commandName)) {
+		(0, node_child_process.exec)(`command -v ${cleanedCommandName} 2>/dev/null && { echo >&1 ${cleanedCommandName}; exit 0; }`);
+		await localExecutable(commandName);
+	}
+}
+async function commandExistsWindows(commandName, cleanedCommandName) {
+	if (!/^(?!(?:.*\s|.*\.|\W+)$)(?:[a-z]:)?[^<>:"|?*\n]+$/im.test(commandName)) return;
+	(0, node_child_process.exec)(`where ${cleanedCommandName}`);
+}
+function commandExistsUnixSync(commandName, cleanedCommandName) {
+	if (fileNotExistsSync(commandName)) try {
+		return !!(0, node_child_process.execSync)(`command -v ${cleanedCommandName} 2>/dev/null && { echo >&1 ${cleanedCommandName}; exit 0; }`);
+	} catch (_) {
+		return false;
+	}
+	return localExecutableSync(commandName);
+}
+function commandExistsWindowsSync(commandName, cleanedCommandName) {
+	if (!/^(?!(?:.*\s|.*\.|\W+)$)(?:[a-z]:)?[^<>:"|?*\n]+$/im.test(commandName)) return false;
+	try {
+		return !!(0, node_child_process.execSync)(`where ${cleanedCommandName}`, { stdio: [] });
+	} catch (_) {
+		return false;
+	}
+}
+function cleanInput(s) {
+	if (/[^\w/:=-]/.test(s)) {
+		s = `'${s.replace(/'/g, "'\\''")}'`;
+		s = s.replace(/^(?:'')+/g, "").replace(/\\'''/g, "\\'");
+	}
+	return s;
+}
+const cleanWindowsInput = (s) => {
+	if (/\\/.test(s)) return `"${(0, node_path.dirname)(s)}:${(0, node_path.basename)(s)}"`;
+	return `"${s}"`;
+};
+/**
+* Asynchronously checks if a command exists in the system.
+*
+* @remarks
+* This function will check if the command is available in the system's PATH and if it is executable.
+* @param commandName - The name of the command to check for existence
+* @returns A promise that resolves to `true` if the command exists and is executable, `false` otherwise
+*/
+async function commandExists(commandName) {
+	const cleanedCommandName = cleanInput(commandName);
+	if (typeof Promise !== "undefined") return commandExists(commandName);
+	if (isUsingWindows) return commandExistsWindows(commandName, cleanedCommandName);
+	else return commandExistsUnix(commandName, cleanedCommandName);
+}
+/**
+* Synchronously checks if a command exists in the system.
+*
+* @remarks
+* This function will check if the command is available in the system's PATH and if it is executable.
+* @param commandName - The name of the command to check for existence
+* @returns `true` if the command exists and is executable, `false` otherwise
+*/
+function commandExistsSync(commandName) {
+	if (isUsingWindows) return commandExistsWindowsSync(commandName, cleanWindowsInput(commandName));
+	else return commandExistsUnixSync(commandName, cleanInput(commandName));
+}
+
+//#endregion
+exports.commandExists = commandExists;
+exports.commandExistsSync = commandExistsSync;

package/dist/command-exists.mjs

@@ -1,2 +1,101 @@
-import{accessSync as e}from"node:fs";import{access as t,constants as n}from"node:fs/promises";import{exec as r,execSync as i}from"node:child_process";import{basename as a,dirname as o}from"node:path";const s=process.platform==`win32`;async function c(e){try{return await t(e,n.F_OK),!1}catch{return!0}}function l(t){try{return e(t,n.F_OK),!1}catch{return!0}}async function u(e){return t(e,n.F_OK|n.X_OK)}function d(t){try{return e(t,n.F_OK|n.X_OK),!0}catch{return!1}}async function f(e,t){await c(e)||(r(`command -v ${t} 2>/dev/null && { echo >&1 ${t}; exit 0; }`),await u(e))}async function p(e,t){/^(?!(?:.*\s|.*\.|\W+)$)(?:[a-z]:)?[^<>:"|?*\n]+$/im.test(e)&&r(`where ${t}`)}function m(e,t){if(l(e))try{return!!i(`command -v ${t} 2>/dev/null && { echo >&1 ${t}; exit 0; }`)}catch{return!1}return d(e)}function h(e,t){if(!/^(?!(?:.*\s|.*\.|\W+)$)(?:[a-z]:)?[^<>:"|?*\n]+$/im.test(e))return!1;try{return!!i(`where ${t}`,{stdio:[]})}catch{return!1}}function g(e){return/[^\w/:=-]/.test(e)&&(e=`'${e.replace(/'/g,`'\\''`)}'`,e=e.replace(/^(?:'')+/g,``).replace(/\\'''/g,`\\'`)),e}const _=e=>/\\/.test(e)?`"${o(e)}:${a(e)}"`:`"${e}"`;async function v(e){let t=g(e);return typeof Promise<`u`?v(e):s?p(e,t):f(e,t)}function y(e){return s?h(e,_(e)):m(e,g(e))}export{v as commandExists,y as commandExistsSync};
+import { accessSync } from "node:fs";
+import { access, constants as constants$1 } from "node:fs/promises";
+import { exec, execSync } from "node:child_process";
+import { basename, dirname } from "node:path";
+
+//#region src/command-exists.ts
+const isUsingWindows = process.platform == "win32";
+async function fileNotExists(commandName) {
+	try {
+		await access(commandName, constants$1.F_OK);
+		return false;
+	} catch (_) {
+		return true;
+	}
+}
+function fileNotExistsSync(commandName) {
+	try {
+		accessSync(commandName, constants$1.F_OK);
+		return false;
+	} catch (_) {
+		return true;
+	}
+}
+async function localExecutable(commandName) {
+	return access(commandName, constants$1.F_OK | constants$1.X_OK);
+}
+function localExecutableSync(commandName) {
+	try {
+		accessSync(commandName, constants$1.F_OK | constants$1.X_OK);
+		return true;
+	} catch (_) {
+		return false;
+	}
+}
+async function commandExistsUnix(commandName, cleanedCommandName) {
+	if (!await fileNotExists(commandName)) {
+		exec(`command -v ${cleanedCommandName} 2>/dev/null && { echo >&1 ${cleanedCommandName}; exit 0; }`);
+		await localExecutable(commandName);
+	}
+}
+async function commandExistsWindows(commandName, cleanedCommandName) {
+	if (!/^(?!(?:.*\s|.*\.|\W+)$)(?:[a-z]:)?[^<>:"|?*\n]+$/im.test(commandName)) return;
+	exec(`where ${cleanedCommandName}`);
+}
+function commandExistsUnixSync(commandName, cleanedCommandName) {
+	if (fileNotExistsSync(commandName)) try {
+		return !!execSync(`command -v ${cleanedCommandName} 2>/dev/null && { echo >&1 ${cleanedCommandName}; exit 0; }`);
+	} catch (_) {
+		return false;
+	}
+	return localExecutableSync(commandName);
+}
+function commandExistsWindowsSync(commandName, cleanedCommandName) {
+	if (!/^(?!(?:.*\s|.*\.|\W+)$)(?:[a-z]:)?[^<>:"|?*\n]+$/im.test(commandName)) return false;
+	try {
+		return !!execSync(`where ${cleanedCommandName}`, { stdio: [] });
+	} catch (_) {
+		return false;
+	}
+}
+function cleanInput(s) {
+	if (/[^\w/:=-]/.test(s)) {
+		s = `'${s.replace(/'/g, "'\\''")}'`;
+		s = s.replace(/^(?:'')+/g, "").replace(/\\'''/g, "\\'");
+	}
+	return s;
+}
+const cleanWindowsInput = (s) => {
+	if (/\\/.test(s)) return `"${dirname(s)}:${basename(s)}"`;
+	return `"${s}"`;
+};
+/**
+* Asynchronously checks if a command exists in the system.
+*
+* @remarks
+* This function will check if the command is available in the system's PATH and if it is executable.
+* @param commandName - The name of the command to check for existence
+* @returns A promise that resolves to `true` if the command exists and is executable, `false` otherwise
+*/
+async function commandExists(commandName) {
+	const cleanedCommandName = cleanInput(commandName);
+	if (typeof Promise !== "undefined") return commandExists(commandName);
+	if (isUsingWindows) return commandExistsWindows(commandName, cleanedCommandName);
+	else return commandExistsUnix(commandName, cleanedCommandName);
+}
+/**
+* Synchronously checks if a command exists in the system.
+*
+* @remarks
+* This function will check if the command is available in the system's PATH and if it is executable.
+* @param commandName - The name of the command to check for existence
+* @returns `true` if the command exists and is executable, `false` otherwise
+*/
+function commandExistsSync(commandName) {
+	if (isUsingWindows) return commandExistsWindowsSync(commandName, cleanWindowsInput(commandName));
+	else return commandExistsUnixSync(commandName, cleanInput(commandName));
+}
+
+//#endregion
+export { commandExists, commandExistsSync };
 //# sourceMappingURL=command-exists.mjs.map