@stryke/path 0.25.3 → 0.26.1

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 # Changelog for Stryke - Path
 
+## [0.26.0](https://github.com/storm-software/stryke/releases/tag/path%400.26.0) (01/20/2026)
+
+### Features
+
+- **path:** Added the `fullExtension` option to the `findFileExtension` function
+  ([d0bc510d](https://github.com/storm-software/stryke/commit/d0bc510d))
+
+### Updated Dependencies
+
+- Updated **type-checks** to **v0.5.20**
+- Updated **convert** to **v0.6.35**
+- Updated **types** to **v0.10.34**
+
+## [0.25.3](https://github.com/storm-software/stryke/releases/tag/path%400.25.3) (01/16/2026)
+
+### Bug Fixes
+
+- **path:** Resolve issue checking previous character in `globToRegex` function
+  ([59d9e9ae](https://github.com/storm-software/stryke/commit/59d9e9ae))
+
 ## [0.25.2](https://github.com/storm-software/stryke/releases/tag/path%400.25.2) (01/16/2026)
 
 ### Bug Fixes

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,29 @@
+//#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/file-path-fns.cjs

@@ -1,3 +1,4 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
 const require_cwd = require('./cwd.cjs');
 const require_regex = require('./regex.cjs');
 const require_is_type = require('./is-type.cjs');
@@ -24,14 +25,14 @@ function findFileName(filePath, options = {}) {
 	const { requireExtension = false, withExtension = true } = options;
 	const result = require_correct_path.normalizeWindowsPath(filePath)?.split(filePath?.includes("\\") ? "\\" : "/")?.pop() ?? "";
 	if (requireExtension === true && !result.includes(".")) return require_base.EMPTY_STRING;
-	if (withExtension === false && result.includes(".")) return result.replace(`.${findFileExtension(result) ?? ""}`, "") || require_base.EMPTY_STRING;
+	if (withExtension === false && result.includes(".")) return result.replace(`.${findFileExtension(result, options) ?? ""}`, "") || require_base.EMPTY_STRING;
 	return result;
 }
 /**
 * Find the full file path's directories from a file path.
 *
 * @remarks
-* The functionality of this method is similar to the {@link path.dirname} function in Node's path module.
+* The functionality of this method is similar to the {@link _path.dirname} function in Node's path module.
 *
 * @example
 * ```ts
@@ -56,7 +57,7 @@ const dirname = findFilePath;
 * Find the top most folder containing the file from a file path.
 *
 * @remarks
-* The functionality of this method is similar to the {@link path.basename} function in Node's path module.
+* The functionality of this method is similar to the {@link _path.basename} function in Node's path module.
 * If you're looking for the full path of the folder (for example: `C:\\Users\\user\\Documents` instead of just `Documents`) containing the file, use {@link findFilePath} instead.
 *
 * @example
@@ -91,16 +92,21 @@ const basename = findFolderName;
 *
 * @example
 * ```ts
-* findFileExtension("C:\\Users\\user\\Documents\\file.config.ts");
-* // Returns "ts"
+* findFileExtension("C:\\Users\\user\\Documents\\file.config.ts"); // Returns "ts"
+* findFileExtension("C:\\Users\\user\\Documents\\file.d.ts"); // Returns "ts"
+* findFileExtension("C:\\Users\\user\\Documents\\file.d.ts", { fullExtension: true }); // Returns "d.ts"
+* findFileExtension("C:\\Users\\user\\Documents\\file.ts.map"); // Returns "ts"
+* findFileExtension("C:\\Users\\user\\Documents\\file.ts.map", { fullExtension: true }); // Returns "ts.map"
+* findFileExtension("C:\\Users\\user\\Documents\\file"); // Returns undefined
 * ```
 *
 * @param filePath - The file path to process
+* @param options - Options to control the file name extraction
 * @returns The file extension or undefined if no extension is found
 */
-function findFileExtension(filePath) {
+function findFileExtension(filePath, options) {
 	if (filePath.endsWith(".") || filePath.endsWith("/")) return;
-	const match = require_regex.FILE_EXTENSION_REGEX.exec(require_correct_path.normalizeWindowsPath(filePath));
+	const match = (options?.fullExtension ? require_regex.FULL_FILE_EXTENSION_REGEX : require_regex.FILE_EXTENSION_REGEX).exec(require_correct_path.normalizeWindowsPath(filePath));
 	return match && match.length > 0 && require_is_set_string.isSetString(match[0]) ? match[0].replace(".", "") : void 0;
 }
 const extname = findFileExtension;
@@ -113,10 +119,11 @@ const extname = findFileExtension;
 * The returned extension **will** include the dot, for example `.txt` or `.js` instead of `txt` or `js`.
 *
 * @param filePath - The file path to process
+* @param options - Options to control the file name extraction
 * @returns The file extension (including the `"."` prefix) or undefined if no extension is found
 */
-function findFileDotExtension(filePath) {
-	const ext = findFileExtension(filePath);
+function findFileDotExtension(filePath, options) {
+	const ext = findFileExtension(filePath, options);
 	return ext ? `.${ext}` : void 0;
 }
 /**
@@ -128,10 +135,11 @@ function findFileDotExtension(filePath) {
 * The returned extension **will not** include the dot, for example `txt` or `js` instead of `.txt` or `.js`.
 *
 * @param filePath - The file path to process
+* @param options - Options to control the file name extraction
 * @returns The file extension or an empty string if no extension is found
 */
-function findFileExtensionSafe(filePath) {
-	return findFileExtension(filePath) ?? require_base.EMPTY_STRING;
+function findFileExtensionSafe(filePath, options) {
+	return findFileExtension(filePath, options) ?? require_base.EMPTY_STRING;
 }
 /**
 * Find the file extension including the `"."` character prefix from a file path or an empty string.
@@ -142,10 +150,11 @@ function findFileExtensionSafe(filePath) {
 * The returned extension **will** include the dot, for example `.txt` or `.js` instead of `txt` or `js`.
 *
 * @param filePath - The file path to process
+* @param options - Options to control the file name extraction
 * @returns The file extension (including the `"."` prefix) or an empty string if no extension is found
 */
-function findFileDotExtensionSafe(filePath) {
-	const ext = findFileExtension(filePath);
+function findFileDotExtensionSafe(filePath, options) {
+	const ext = findFileExtension(filePath, options);
 	return ext ? `.${ext}` : "";
 }
 /**
@@ -179,10 +188,11 @@ function hasFolderName(filePath) {
 * Check if a file path has a file extension.
 *
 * @param filePath - The file path to process
+* @param options - Options to control the file name extraction
 * @returns An indicator specifying if the file path has a file extension
 */
-function hasFileExtension(filePath) {
-	return Boolean(findFileExtension(filePath));
+function hasFileExtension(filePath, options) {
+	return Boolean(findFileExtension(filePath, options));
 }
 /**
 * Resolve the file path to an absolute path.
@@ -279,14 +289,14 @@ function relativeToCurrentDir(filePath) {
 * @param path - The path to check
 * @returns An indicator specifying if the path is a relative path
 */
-function parsePath(path) {
+function parsePath(path, options) {
 	const root = /^[/\\]|^[a-z]:[/\\]/i.exec(path)?.[0]?.replace(/\\/g, "/") || "";
 	const normalizedPath = require_correct_path.normalizeWindowsPath(path);
 	const segments = normalizedPath.replace(/\/$/, "").split("/").slice(0, -1);
 	if (segments.length === 1 && /^[A-Z]:$/i.test(segments[0])) segments[0] += "/";
-	const base = findFolderName(normalizedPath);
+	const base = findFolderName(normalizedPath, options);
 	const dir = segments.join("/") || (require_is_type.isAbsolutePath(path) ? "/" : ".");
-	const ext = findFileExtensionSafe(path);
+	const ext = findFileExtensionSafe(path, options);
 	return {
 		root,
 		dir,
@@ -300,10 +310,11 @@ function parsePath(path) {
 *
 * @param filePath - The current file path being processed
 * @param newFileName - The updated file name being processed
+* @param options - Options to control the file name extraction
 * @returns The modified or unmodified file path.
 */
-function renameFile(filePath, newFileName) {
-	const file = parsePath(filePath);
+function renameFile(filePath, newFileName, options) {
+	const file = parsePath(filePath, options);
 	return require_join_paths.joinPaths(file.dir, newFileName.includes(".") ? newFileName : newFileName + file.ext);
 }
 

package/dist/file-path-fns.d.cts

@@ -1,5 +1,5 @@
 //#region src/file-path-fns.d.ts
-interface FindFileNameOptions {
+interface FindFileNameOptions extends FindFileExtensionOptions {
   /**
    * Require the file extension to be present in the file name.
    *
@@ -31,7 +31,7 @@ declare function findFileName(filePath: string, options?: FindFileNameOptions):
  * Find the full file path's directories from a file path.
  *
  * @remarks
- * The functionality of this method is similar to the {@link path.dirname} function in Node's path module.
+ * The functionality of this method is similar to the {@link _path.dirname} function in Node's path module.
  *
  * @example
  * ```ts
@@ -49,7 +49,7 @@ declare const dirname: typeof findFilePath;
  * Find the top most folder containing the file from a file path.
  *
  * @remarks
- * The functionality of this method is similar to the {@link path.basename} function in Node's path module.
+ * The functionality of this method is similar to the {@link _path.basename} function in Node's path module.
  * If you're looking for the full path of the folder (for example: `C:\\Users\\user\\Documents` instead of just `Documents`) containing the file, use {@link findFilePath} instead.
  *
  * @example
@@ -62,6 +62,14 @@ declare const dirname: typeof findFilePath;
  */
 declare function findFolderName(filePath: string, options?: FindFileNameOptions): string;
 declare const basename: typeof findFolderName;
+interface FindFileExtensionOptions {
+  /**
+   * Return the full file extension including `.d` and `.map` if present.
+   *
+   * @defaultValue false
+   */
+  fullExtension?: boolean;
+}
 /**
  * Find the file extension from a file path.
  *
@@ -73,14 +81,19 @@ declare const basename: typeof findFolderName;
  *
  * @example
  * ```ts
- * findFileExtension("C:\\Users\\user\\Documents\\file.config.ts");
- * // Returns "ts"
+ * findFileExtension("C:\\Users\\user\\Documents\\file.config.ts"); // Returns "ts"
+ * findFileExtension("C:\\Users\\user\\Documents\\file.d.ts"); // Returns "ts"
+ * findFileExtension("C:\\Users\\user\\Documents\\file.d.ts", { fullExtension: true }); // Returns "d.ts"
+ * findFileExtension("C:\\Users\\user\\Documents\\file.ts.map"); // Returns "ts"
+ * findFileExtension("C:\\Users\\user\\Documents\\file.ts.map", { fullExtension: true }); // Returns "ts.map"
+ * findFileExtension("C:\\Users\\user\\Documents\\file"); // Returns undefined
  * ```
  *
  * @param filePath - The file path to process
+ * @param options - Options to control the file name extraction
  * @returns The file extension or undefined if no extension is found
  */
-declare function findFileExtension(filePath: string): string | undefined;
+declare function findFileExtension(filePath: string, options?: FindFileExtensionOptions): string | undefined;
 declare const extname: typeof findFileExtension;
 /**
  * Find the file extension including the `"."` character prefix from a file path.
@@ -91,9 +104,10 @@ declare const extname: typeof findFileExtension;
  * The returned extension **will** include the dot, for example `.txt` or `.js` instead of `txt` or `js`.
  *
  * @param filePath - The file path to process
+ * @param options - Options to control the file name extraction
  * @returns The file extension (including the `"."` prefix) or undefined if no extension is found
  */
-declare function findFileDotExtension(filePath: string): string | undefined;
+declare function findFileDotExtension(filePath: string, options?: FindFileExtensionOptions): string | undefined;
 /**
  * Find the file extension from a file path or an empty string.
  *
@@ -103,9 +117,10 @@ declare function findFileDotExtension(filePath: string): string | undefined;
  * The returned extension **will not** include the dot, for example `txt` or `js` instead of `.txt` or `.js`.
  *
  * @param filePath - The file path to process
+ * @param options - Options to control the file name extraction
  * @returns The file extension or an empty string if no extension is found
  */
-declare function findFileExtensionSafe(filePath: string): string;
+declare function findFileExtensionSafe(filePath: string, options?: FindFileExtensionOptions): string;
 /**
  * Find the file extension including the `"."` character prefix from a file path or an empty string.
  *
@@ -115,9 +130,10 @@ declare function findFileExtensionSafe(filePath: string): string;
  * The returned extension **will** include the dot, for example `.txt` or `.js` instead of `txt` or `js`.
  *
  * @param filePath - The file path to process
+ * @param options - Options to control the file name extraction
  * @returns The file extension (including the `"."` prefix) or an empty string if no extension is found
  */
-declare function findFileDotExtensionSafe(filePath: string): string;
+declare function findFileDotExtensionSafe(filePath: string, options?: FindFileExtensionOptions): string;
 /**
  * Check if a file path has a file name.
  *
@@ -143,9 +159,10 @@ declare function hasFolderName(filePath: string): boolean;
  * Check if a file path has a file extension.
  *
  * @param filePath - The file path to process
+ * @param options - Options to control the file name extraction
  * @returns An indicator specifying if the file path has a file extension
  */
-declare function hasFileExtension(filePath: string): boolean;
+declare function hasFileExtension(filePath: string, options?: FindFileExtensionOptions): boolean;
 /**
  * Resolve the file path to an absolute path.
  *
@@ -198,7 +215,7 @@ declare function relativeToCurrentDir(filePath: string): string;
  * @param path - The path to check
  * @returns An indicator specifying if the path is a relative path
  */
-declare function parsePath(path: string): {
+declare function parsePath(path: string, options?: FindFileNameOptions): {
   root: string;
   dir: string;
   base: string;
@@ -210,9 +227,10 @@ declare function parsePath(path: string): {
  *
  * @param filePath - The current file path being processed
  * @param newFileName - The updated file name being processed
+ * @param options - Options to control the file name extraction
  * @returns The modified or unmodified file path.
  */
-declare function renameFile(filePath: string, newFileName: string): string;
+declare function renameFile(filePath: string, newFileName: string, options?: FindFileNameOptions): string;
 //#endregion
-export { FindFileNameOptions, basename, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, hasFileExtension, hasFileName, hasFilePath, hasFolderName, parsePath, relative, relativePath, relativeToCurrentDir, renameFile, resolve, resolvePath, resolvePaths };
+export { FindFileExtensionOptions, FindFileNameOptions, basename, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, hasFileExtension, hasFileName, hasFilePath, hasFolderName, parsePath, relative, relativePath, relativeToCurrentDir, renameFile, resolve, resolvePath, resolvePaths };
 //# sourceMappingURL=file-path-fns.d.cts.map

package/dist/file-path-fns.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"file-path-fns.d.cts","names":[],"sources":["../src/file-path-fns.ts"],"sourcesContent":[],"mappings":";UA0BiB,mBAAA;EAAA;AA6BjB;AAuCA;AAcA;AAiBA;EAyBa,gBAAyB,CAAA,EAAA,OAAjB;EAoBL;AAYhB;AAaA;AAiBA;AAeA;EAYgB,aAAA,CAAW,EAAA,OAAA;AAU3B;AAUA;AAUA;AAWA;AAoCA;AA0CA;AAgBA;AAsCA;AAaA;AAUA;AAgCA;;;;iBA5ZgB,YAAA,6BAEL;;;;;;;;;;;;;;;;;iBAqCK,YAAA,6BAEL;cAYE,gBAAO;;;;;;;;;;;;;;;;iBAiBJ,cAAA,6BAEJ;cAuBC,iBAAQ;;;;;;;;;;;;;;;;;;;iBAoBL,iBAAA;cAYH,gBAAO;;;;;;;;;;;;iBAaJ,oBAAA;;;;;;;;;;;;iBAiBA,qBAAA;;;;;;;;;;;;iBAeA,wBAAA;;;;;;;iBAYA,WAAA;;;;;;;iBAUA,WAAA;;;;;;;iBAUA,aAAA;;;;;;;iBAUA,gBAAA;;;;;;;;iBAWA,WAAA;iBAoCA,OAAA;;;;;;;iBA0CA,YAAA;;;;;;;;;;;iBAgBA,QAAA;;;;;;;;;;;;iBAsCA,YAAA;;;;;;;iBAaA,oBAAA;;;;;;;iBAUA,SAAA;;;;;;;;;;;;;;iBAgCA,UAAA"}
+{"version":3,"file":"file-path-fns.d.cts","names":[],"sources":["../src/file-path-fns.ts"],"sourcesContent":[],"mappings":";UA+BiB,mBAAA,SAA4B;EAA5B;AA6BjB;AAwCA;AAcA;AAiBA;EAyBa,gBAAyB,CAAA,EAAA,OAAjB;EAEJ;AAgCjB;AAiBA;AAcA;AAqBA;EAmBgB,aAAA,CAAA,EAAA,OAAA;AAehB;AAUA;AAUA;AAWA;AAcA;AAoCA;AA0CA;AAgBA;AAsCA;AAaA;AAUA;AAiCA;;;iBAjcgB,YAAA,6BAEL;;;;;;;;;;;;;;;;;iBAsCK,YAAA,6BAEL;cAYE,gBAAO;;;;;;;;;;;;;;;;iBAiBJ,cAAA,6BAEJ;cAuBC,iBAAQ;UAEJ,wBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgCD,iBAAA,6BAEJ;cAeC,gBAAO;;;;;;;;;;;;;iBAcJ,oBAAA,6BAEJ;;;;;;;;;;;;;iBAmBI,qBAAA,6BAEJ;;;;;;;;;;;;;iBAiBI,wBAAA,6BAEJ;;;;;;;iBAaI,WAAA;;;;;;;iBAUA,WAAA;;;;;;;iBAUA,aAAA;;;;;;;;iBAWA,gBAAA,6BAEJ;;;;;;;;iBAYI,WAAA;iBAoCA,OAAA;;;;;;;iBA0CA,YAAA;;;;;;;;;;;iBAgBA,QAAA;;;;;;;;;;;;iBAsCA,YAAA;;;;;;;iBAaA,oBAAA;;;;;;;iBAUA,SAAA,yBAAkC;;;;;;;;;;;;;;;iBAiClC,UAAA,kDAGJ"}

package/dist/file-path-fns.d.mts

@@ -1,5 +1,5 @@
 //#region src/file-path-fns.d.ts
-interface FindFileNameOptions {
+interface FindFileNameOptions extends FindFileExtensionOptions {
   /**
    * Require the file extension to be present in the file name.
    *
@@ -31,7 +31,7 @@ declare function findFileName(filePath: string, options?: FindFileNameOptions):
  * Find the full file path's directories from a file path.
  *
  * @remarks
- * The functionality of this method is similar to the {@link path.dirname} function in Node's path module.
+ * The functionality of this method is similar to the {@link _path.dirname} function in Node's path module.
  *
  * @example
  * ```ts
@@ -49,7 +49,7 @@ declare const dirname: typeof findFilePath;
  * Find the top most folder containing the file from a file path.
  *
  * @remarks
- * The functionality of this method is similar to the {@link path.basename} function in Node's path module.
+ * The functionality of this method is similar to the {@link _path.basename} function in Node's path module.
  * If you're looking for the full path of the folder (for example: `C:\\Users\\user\\Documents` instead of just `Documents`) containing the file, use {@link findFilePath} instead.
  *
  * @example
@@ -62,6 +62,14 @@ declare const dirname: typeof findFilePath;
  */
 declare function findFolderName(filePath: string, options?: FindFileNameOptions): string;
 declare const basename: typeof findFolderName;
+interface FindFileExtensionOptions {
+  /**
+   * Return the full file extension including `.d` and `.map` if present.
+   *
+   * @defaultValue false
+   */
+  fullExtension?: boolean;
+}
 /**
  * Find the file extension from a file path.
  *
@@ -73,14 +81,19 @@ declare const basename: typeof findFolderName;
  *
  * @example
  * ```ts
- * findFileExtension("C:\\Users\\user\\Documents\\file.config.ts");
- * // Returns "ts"
+ * findFileExtension("C:\\Users\\user\\Documents\\file.config.ts"); // Returns "ts"
+ * findFileExtension("C:\\Users\\user\\Documents\\file.d.ts"); // Returns "ts"
+ * findFileExtension("C:\\Users\\user\\Documents\\file.d.ts", { fullExtension: true }); // Returns "d.ts"
+ * findFileExtension("C:\\Users\\user\\Documents\\file.ts.map"); // Returns "ts"
+ * findFileExtension("C:\\Users\\user\\Documents\\file.ts.map", { fullExtension: true }); // Returns "ts.map"
+ * findFileExtension("C:\\Users\\user\\Documents\\file"); // Returns undefined
  * ```
  *
  * @param filePath - The file path to process
+ * @param options - Options to control the file name extraction
  * @returns The file extension or undefined if no extension is found
  */
-declare function findFileExtension(filePath: string): string | undefined;
+declare function findFileExtension(filePath: string, options?: FindFileExtensionOptions): string | undefined;
 declare const extname: typeof findFileExtension;
 /**
  * Find the file extension including the `"."` character prefix from a file path.
@@ -91,9 +104,10 @@ declare const extname: typeof findFileExtension;
  * The returned extension **will** include the dot, for example `.txt` or `.js` instead of `txt` or `js`.
  *
  * @param filePath - The file path to process
+ * @param options - Options to control the file name extraction
  * @returns The file extension (including the `"."` prefix) or undefined if no extension is found
  */
-declare function findFileDotExtension(filePath: string): string | undefined;
+declare function findFileDotExtension(filePath: string, options?: FindFileExtensionOptions): string | undefined;
 /**
  * Find the file extension from a file path or an empty string.
  *
@@ -103,9 +117,10 @@ declare function findFileDotExtension(filePath: string): string | undefined;
  * The returned extension **will not** include the dot, for example `txt` or `js` instead of `.txt` or `.js`.
  *
  * @param filePath - The file path to process
+ * @param options - Options to control the file name extraction
  * @returns The file extension or an empty string if no extension is found
  */
-declare function findFileExtensionSafe(filePath: string): string;
+declare function findFileExtensionSafe(filePath: string, options?: FindFileExtensionOptions): string;
 /**
  * Find the file extension including the `"."` character prefix from a file path or an empty string.
  *
@@ -115,9 +130,10 @@ declare function findFileExtensionSafe(filePath: string): string;
  * The returned extension **will** include the dot, for example `.txt` or `.js` instead of `txt` or `js`.
  *
  * @param filePath - The file path to process
+ * @param options - Options to control the file name extraction
  * @returns The file extension (including the `"."` prefix) or an empty string if no extension is found
  */
-declare function findFileDotExtensionSafe(filePath: string): string;
+declare function findFileDotExtensionSafe(filePath: string, options?: FindFileExtensionOptions): string;
 /**
  * Check if a file path has a file name.
  *
@@ -143,9 +159,10 @@ declare function hasFolderName(filePath: string): boolean;
  * Check if a file path has a file extension.
  *
  * @param filePath - The file path to process
+ * @param options - Options to control the file name extraction
  * @returns An indicator specifying if the file path has a file extension
  */
-declare function hasFileExtension(filePath: string): boolean;
+declare function hasFileExtension(filePath: string, options?: FindFileExtensionOptions): boolean;
 /**
  * Resolve the file path to an absolute path.
  *
@@ -198,7 +215,7 @@ declare function relativeToCurrentDir(filePath: string): string;
  * @param path - The path to check
  * @returns An indicator specifying if the path is a relative path
  */
-declare function parsePath(path: string): {
+declare function parsePath(path: string, options?: FindFileNameOptions): {
   root: string;
   dir: string;
   base: string;
@@ -210,9 +227,10 @@ declare function parsePath(path: string): {
  *
  * @param filePath - The current file path being processed
  * @param newFileName - The updated file name being processed
+ * @param options - Options to control the file name extraction
  * @returns The modified or unmodified file path.
  */
-declare function renameFile(filePath: string, newFileName: string): string;
+declare function renameFile(filePath: string, newFileName: string, options?: FindFileNameOptions): string;
 //#endregion
-export { FindFileNameOptions, basename, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, hasFileExtension, hasFileName, hasFilePath, hasFolderName, parsePath, relative, relativePath, relativeToCurrentDir, renameFile, resolve, resolvePath, resolvePaths };
+export { FindFileExtensionOptions, FindFileNameOptions, basename, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, hasFileExtension, hasFileName, hasFilePath, hasFolderName, parsePath, relative, relativePath, relativeToCurrentDir, renameFile, resolve, resolvePath, resolvePaths };
 //# sourceMappingURL=file-path-fns.d.mts.map

package/dist/file-path-fns.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"file-path-fns.d.mts","names":[],"sources":["../src/file-path-fns.ts"],"sourcesContent":[],"mappings":";UA0BiB,mBAAA;EAAA;AA6BjB;AAuCA;AAcA;AAiBA;EAyBa,gBAAyB,CAAA,EAAA,OAAjB;EAoBL;AAYhB;AAaA;AAiBA;AAeA;EAYgB,aAAA,CAAW,EAAA,OAAA;AAU3B;AAUA;AAUA;AAWA;AAoCA;AA0CA;AAgBA;AAsCA;AAaA;AAUA;AAgCA;;;;iBA5ZgB,YAAA,6BAEL;;;;;;;;;;;;;;;;;iBAqCK,YAAA,6BAEL;cAYE,gBAAO;;;;;;;;;;;;;;;;iBAiBJ,cAAA,6BAEJ;cAuBC,iBAAQ;;;;;;;;;;;;;;;;;;;iBAoBL,iBAAA;cAYH,gBAAO;;;;;;;;;;;;iBAaJ,oBAAA;;;;;;;;;;;;iBAiBA,qBAAA;;;;;;;;;;;;iBAeA,wBAAA;;;;;;;iBAYA,WAAA;;;;;;;iBAUA,WAAA;;;;;;;iBAUA,aAAA;;;;;;;iBAUA,gBAAA;;;;;;;;iBAWA,WAAA;iBAoCA,OAAA;;;;;;;iBA0CA,YAAA;;;;;;;;;;;iBAgBA,QAAA;;;;;;;;;;;;iBAsCA,YAAA;;;;;;;iBAaA,oBAAA;;;;;;;iBAUA,SAAA;;;;;;;;;;;;;;iBAgCA,UAAA"}
+{"version":3,"file":"file-path-fns.d.mts","names":[],"sources":["../src/file-path-fns.ts"],"sourcesContent":[],"mappings":";UA+BiB,mBAAA,SAA4B;EAA5B;AA6BjB;AAwCA;AAcA;AAiBA;EAyBa,gBAAyB,CAAA,EAAA,OAAjB;EAEJ;AAgCjB;AAiBA;AAcA;AAqBA;EAmBgB,aAAA,CAAA,EAAA,OAAA;AAehB;AAUA;AAUA;AAWA;AAcA;AAoCA;AA0CA;AAgBA;AAsCA;AAaA;AAUA;AAiCA;;;iBAjcgB,YAAA,6BAEL;;;;;;;;;;;;;;;;;iBAsCK,YAAA,6BAEL;cAYE,gBAAO;;;;;;;;;;;;;;;;iBAiBJ,cAAA,6BAEJ;cAuBC,iBAAQ;UAEJ,wBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgCD,iBAAA,6BAEJ;cAeC,gBAAO;;;;;;;;;;;;;iBAcJ,oBAAA,6BAEJ;;;;;;;;;;;;;iBAmBI,qBAAA,6BAEJ;;;;;;;;;;;;;iBAiBI,wBAAA,6BAEJ;;;;;;;iBAaI,WAAA;;;;;;;iBAUA,WAAA;;;;;;;iBAUA,aAAA;;;;;;;;iBAWA,gBAAA,6BAEJ;;;;;;;;iBAYI,WAAA;iBAoCA,OAAA;;;;;;;iBA0CA,YAAA;;;;;;;;;;;iBAgBA,QAAA;;;;;;;;;;;;iBAsCA,YAAA;;;;;;;iBAaA,oBAAA;;;;;;;iBAUA,SAAA,yBAAkC;;;;;;;;;;;;;;;iBAiClC,UAAA,kDAGJ"}

package/dist/file-path-fns.mjs

@@ -1,5 +1,5 @@
 import { cwd } from "./cwd.mjs";
-import { FILE_EXTENSION_REGEX, ROOT_FOLDER_REGEX } from "./regex.mjs";
+import { FILE_EXTENSION_REGEX, FULL_FILE_EXTENSION_REGEX, ROOT_FOLDER_REGEX } from "./regex.mjs";
 import { isAbsolute, isAbsolutePath } from "./is-type.mjs";
 import { joinPaths } from "./join-paths.mjs";
 import { normalizeString, normalizeWindowsPath } from "./correct-path.mjs";
@@ -24,14 +24,14 @@ function findFileName(filePath, options = {}) {
 	const { requireExtension = false, withExtension = true } = options;
 	const result = normalizeWindowsPath(filePath)?.split(filePath?.includes("\\") ? "\\" : "/")?.pop() ?? "";
 	if (requireExtension === true && !result.includes(".")) return EMPTY_STRING;
-	if (withExtension === false && result.includes(".")) return result.replace(`.${findFileExtension(result) ?? ""}`, "") || EMPTY_STRING;
+	if (withExtension === false && result.includes(".")) return result.replace(`.${findFileExtension(result, options) ?? ""}`, "") || EMPTY_STRING;
 	return result;
 }
 /**
 * Find the full file path's directories from a file path.
 *
 * @remarks
-* The functionality of this method is similar to the {@link path.dirname} function in Node's path module.
+* The functionality of this method is similar to the {@link _path.dirname} function in Node's path module.
 *
 * @example
 * ```ts
@@ -56,7 +56,7 @@ const dirname = findFilePath;
 * Find the top most folder containing the file from a file path.
 *
 * @remarks
-* The functionality of this method is similar to the {@link path.basename} function in Node's path module.
+* The functionality of this method is similar to the {@link _path.basename} function in Node's path module.
 * If you're looking for the full path of the folder (for example: `C:\\Users\\user\\Documents` instead of just `Documents`) containing the file, use {@link findFilePath} instead.
 *
 * @example
@@ -91,16 +91,21 @@ const basename = findFolderName;
 *
 * @example
 * ```ts
-* findFileExtension("C:\\Users\\user\\Documents\\file.config.ts");
-* // Returns "ts"
+* findFileExtension("C:\\Users\\user\\Documents\\file.config.ts"); // Returns "ts"
+* findFileExtension("C:\\Users\\user\\Documents\\file.d.ts"); // Returns "ts"
+* findFileExtension("C:\\Users\\user\\Documents\\file.d.ts", { fullExtension: true }); // Returns "d.ts"
+* findFileExtension("C:\\Users\\user\\Documents\\file.ts.map"); // Returns "ts"
+* findFileExtension("C:\\Users\\user\\Documents\\file.ts.map", { fullExtension: true }); // Returns "ts.map"
+* findFileExtension("C:\\Users\\user\\Documents\\file"); // Returns undefined
 * ```
 *
 * @param filePath - The file path to process
+* @param options - Options to control the file name extraction
 * @returns The file extension or undefined if no extension is found
 */
-function findFileExtension(filePath) {
+function findFileExtension(filePath, options) {
 	if (filePath.endsWith(".") || filePath.endsWith("/")) return;
-	const match = FILE_EXTENSION_REGEX.exec(normalizeWindowsPath(filePath));
+	const match = (options?.fullExtension ? FULL_FILE_EXTENSION_REGEX : FILE_EXTENSION_REGEX).exec(normalizeWindowsPath(filePath));
 	return match && match.length > 0 && isSetString(match[0]) ? match[0].replace(".", "") : void 0;
 }
 const extname = findFileExtension;
@@ -113,10 +118,11 @@ const extname = findFileExtension;
 * The returned extension **will** include the dot, for example `.txt` or `.js` instead of `txt` or `js`.
 *
 * @param filePath - The file path to process
+* @param options - Options to control the file name extraction
 * @returns The file extension (including the `"."` prefix) or undefined if no extension is found
 */
-function findFileDotExtension(filePath) {
-	const ext = findFileExtension(filePath);
+function findFileDotExtension(filePath, options) {
+	const ext = findFileExtension(filePath, options);
 	return ext ? `.${ext}` : void 0;
 }
 /**
@@ -128,10 +134,11 @@ function findFileDotExtension(filePath) {
 * The returned extension **will not** include the dot, for example `txt` or `js` instead of `.txt` or `.js`.
 *
 * @param filePath - The file path to process
+* @param options - Options to control the file name extraction
 * @returns The file extension or an empty string if no extension is found
 */
-function findFileExtensionSafe(filePath) {
-	return findFileExtension(filePath) ?? EMPTY_STRING;
+function findFileExtensionSafe(filePath, options) {
+	return findFileExtension(filePath, options) ?? EMPTY_STRING;
 }
 /**
 * Find the file extension including the `"."` character prefix from a file path or an empty string.
@@ -142,10 +149,11 @@ function findFileExtensionSafe(filePath) {
 * The returned extension **will** include the dot, for example `.txt` or `.js` instead of `txt` or `js`.
 *
 * @param filePath - The file path to process
+* @param options - Options to control the file name extraction
 * @returns The file extension (including the `"."` prefix) or an empty string if no extension is found
 */
-function findFileDotExtensionSafe(filePath) {
-	const ext = findFileExtension(filePath);
+function findFileDotExtensionSafe(filePath, options) {
+	const ext = findFileExtension(filePath, options);
 	return ext ? `.${ext}` : "";
 }
 /**
@@ -179,10 +187,11 @@ function hasFolderName(filePath) {
 * Check if a file path has a file extension.
 *
 * @param filePath - The file path to process
+* @param options - Options to control the file name extraction
 * @returns An indicator specifying if the file path has a file extension
 */
-function hasFileExtension(filePath) {
-	return Boolean(findFileExtension(filePath));
+function hasFileExtension(filePath, options) {
+	return Boolean(findFileExtension(filePath, options));
 }
 /**
 * Resolve the file path to an absolute path.
@@ -279,14 +288,14 @@ function relativeToCurrentDir(filePath) {
 * @param path - The path to check
 * @returns An indicator specifying if the path is a relative path
 */
-function parsePath(path) {
+function parsePath(path, options) {
 	const root = /^[/\\]|^[a-z]:[/\\]/i.exec(path)?.[0]?.replace(/\\/g, "/") || "";
 	const normalizedPath = normalizeWindowsPath(path);
 	const segments = normalizedPath.replace(/\/$/, "").split("/").slice(0, -1);
 	if (segments.length === 1 && /^[A-Z]:$/i.test(segments[0])) segments[0] += "/";
-	const base = findFolderName(normalizedPath);
+	const base = findFolderName(normalizedPath, options);
 	const dir = segments.join("/") || (isAbsolutePath(path) ? "/" : ".");
-	const ext = findFileExtensionSafe(path);
+	const ext = findFileExtensionSafe(path, options);
 	return {
 		root,
 		dir,
@@ -300,10 +309,11 @@ function parsePath(path) {
 *
 * @param filePath - The current file path being processed
 * @param newFileName - The updated file name being processed
+* @param options - Options to control the file name extraction
 * @returns The modified or unmodified file path.
 */
-function renameFile(filePath, newFileName) {
-	const file = parsePath(filePath);
+function renameFile(filePath, newFileName, options) {
+	const file = parsePath(filePath, options);
 	return joinPaths(file.dir, newFileName.includes(".") ? newFileName : newFileName + file.ext);
 }
 

package/dist/file-path-fns.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"file-path-fns.mjs","names":["currentDir","path","cwd"],"sources":["../src/file-path-fns.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 { isSetString } from \"@stryke/type-checks/is-set-string\";\nimport { EMPTY_STRING } from \"@stryke/types/base\";\nimport { normalizeString, normalizeWindowsPath } from \"./correct-path\";\nimport { cwd as currentDir } from \"./cwd\";\nimport { isAbsolute, isAbsolutePath } from \"./is-type\";\nimport { joinPaths } from \"./join-paths\";\nimport { FILE_EXTENSION_REGEX, ROOT_FOLDER_REGEX } from \"./regex\";\n\nexport interface FindFileNameOptions {\n  /**\n   * Require the file extension to be present in the file name.\n   *\n   * @defaultValue false\n   */\n  requireExtension?: boolean;\n\n  /**\n   * Return the file extension as part of the full file name result.\n   *\n   * @defaultValue true\n   */\n  withExtension?: boolean;\n}\n\n/**\n * Find the file name from a file path.\n *\n * @example\n * ```ts\n * const fileName = findFileName(\"C:\\\\Users\\\\user\\\\Documents\\\\file.txt\");\n * // fileName = \"file.txt\"\n * ```\n *\n * @param filePath - The file path to process\n * @param options - Options to control the file name extraction\n * @returns The file name\n */\nexport function findFileName(\n  filePath: string,\n  options: FindFileNameOptions = {}\n): string {\n  const { requireExtension = false, withExtension = true } = options;\n  const result =\n    normalizeWindowsPath(filePath)\n      ?.split(filePath?.includes(\"\\\\\") ? \"\\\\\" : \"/\")\n      ?.pop() ?? \"\";\n\n  if (requireExtension === true && !result.includes(\".\")) {\n    return EMPTY_STRING;\n  }\n\n  if (withExtension === false && result.includes(\".\")) {\n    return (\n      result.replace(`.${findFileExtension(result) ?? \"\"}`, \"\") || EMPTY_STRING\n    );\n  }\n\n  return result;\n}\n\n/**\n * Find the full file path's directories from a file path.\n *\n * @remarks\n * The functionality of this method is similar to the {@link path.dirname} function in Node's path module.\n *\n * @example\n * ```ts\n * const folderPath = findFilePath(\"C:\\\\Users\\\\user\\\\Documents\\\\file.txt\");\n * // folderPath = \"C:\\\\Users\\\\user\\\\Documents\"\n * ```\n *\n * @param filePath - The file path to process\n * @param options - Options to control the file name extraction\n * @returns The full file path's directories\n */\nexport function findFilePath(\n  filePath: string,\n  options: FindFileNameOptions = {}\n): string {\n  const normalizedPath = normalizeWindowsPath(filePath);\n\n  const result = normalizedPath.replace(\n    findFileName(normalizedPath, { requireExtension: false, ...options }),\n    \"\"\n  );\n\n  return result === \"/\" ? result : result.replace(/\\/$/, \"\");\n}\n\nexport const dirname = findFilePath;\n\n/**\n * Find the top most folder containing the file from a file path.\n *\n * @remarks\n * The functionality of this method is similar to the {@link path.basename} function in Node's path module.\n * If you're looking for the full path of the folder (for example: `C:\\\\Users\\\\user\\\\Documents` instead of just `Documents`) containing the file, use {@link findFilePath} instead.\n *\n * @example\n * const folderPath = findFolderName(\"C:\\\\Users\\\\user\\\\Documents\\\\file.txt\");\n * // folderPath = \"Documents\"\n *\n * @param filePath - The file path to process\n * @param options - Options to control the file name extraction\n * @returns The folder containing the file\n */\nexport function findFolderName(\n  filePath: string,\n  options?: FindFileNameOptions\n): string {\n  const segments = findFilePath(filePath, options).split(\"/\");\n\n  let lastSegment = \"\";\n  for (let i = segments.length - 1; i >= 0; i--) {\n    const val = segments[i];\n    if (val) {\n      lastSegment = val;\n      break;\n    }\n  }\n\n  // if (\n  //   folderPath.lastIndexOf(\"\\\\\") === folderPath.length - 1 ||\n  //   folderPath.lastIndexOf(\"/\") === folderPath.length - 1\n  // ) {\n  //   folderPath = folderPath.slice(0, Math.max(0, folderPath.length - 1));\n  // }\n\n  return lastSegment ?? EMPTY_STRING;\n}\n\nexport const basename = findFolderName;\n\n/**\n * Find the file extension from a file path.\n *\n * @remarks\n * The functionality of this method is similar to the {@link path.extname} function in Node's path module.\n * The file extension is the part of the file name that comes after the last dot (`.`) in the file name. If the file name does not contain a dot, or if it ends with a dot, this function will return `undefined`.\n *\n * The returned extension **will not** include the dot, for example `txt` or `js` instead of `.txt` or `.js`.\n *\n * @example\n * ```ts\n * findFileExtension(\"C:\\\\Users\\\\user\\\\Documents\\\\file.config.ts\");\n * // Returns \"ts\"\n * ```\n *\n * @param filePath - The file path to process\n * @returns The file extension or undefined if no extension is found\n */\nexport function findFileExtension(filePath: string): string | undefined {\n  if (filePath.endsWith(\".\") || filePath.endsWith(\"/\")) {\n    return undefined;\n  }\n\n  const match = FILE_EXTENSION_REGEX.exec(normalizeWindowsPath(filePath));\n\n  return match && match.length > 0 && isSetString(match[0])\n    ? match[0].replace(\".\", \"\")\n    : undefined;\n}\n\nexport const extname = findFileExtension;\n\n/**\n * Find the file extension including the `\".\"` character prefix from a file path.\n *\n * @remarks\n * The file extension is the part of the file name that comes after (and including) the last dot (`.`) in the file name. If the file name does not contain a dot, or if it ends with a dot, this function will return `undefined`.\n *\n * The returned extension **will** include the dot, for example `.txt` or `.js` instead of `txt` or `js`.\n *\n * @param filePath - The file path to process\n * @returns The file extension (including the `\".\"` prefix) or undefined if no extension is found\n */\nexport function findFileDotExtension(filePath: string): string | undefined {\n  const ext = findFileExtension(filePath);\n\n  return ext ? `.${ext}` : undefined;\n}\n\n/**\n * Find the file extension from a file path or an empty string.\n *\n *  @remarks\n * The file extension is the part of the file name that comes after the last dot (`.`) in the file name. If the file name does not contain a dot, or if it ends with a dot, this function will return `undefined`.\n *\n * The returned extension **will not** include the dot, for example `txt` or `js` instead of `.txt` or `.js`.\n *\n * @param filePath - The file path to process\n * @returns The file extension or an empty string if no extension is found\n */\nexport function findFileExtensionSafe(filePath: string): string {\n  return findFileExtension(filePath) ?? EMPTY_STRING;\n}\n\n/**\n * Find the file extension including the `\".\"` character prefix from a file path or an empty string.\n *\n *  @remarks\n * The file extension is the part of the file name that comes after (and including) the last dot (`.`) in the file name. If the file name does not contain a dot, or if it ends with a dot, this function will return `undefined`.\n *\n * The returned extension **will** include the dot, for example `.txt` or `.js` instead of `txt` or `js`.\n *\n * @param filePath - The file path to process\n * @returns The file extension (including the `\".\"` prefix) or an empty string if no extension is found\n */\nexport function findFileDotExtensionSafe(filePath: string): string {\n  const ext = findFileExtension(filePath);\n\n  return ext ? `.${ext}` : \"\";\n}\n\n/**\n * Check if a file path has a file name.\n *\n * @param filePath - The file path to process\n * @returns An indicator specifying if the file path has a file name\n */\nexport function hasFileName(filePath: string): boolean {\n  return Boolean(findFileName(filePath));\n}\n\n/**\n * Check if a file path has a file path.\n *\n * @param filePath - The file path to process\n * @returns An indicator specifying if the file path has a file path\n */\nexport function hasFilePath(filePath: string): boolean {\n  return Boolean(findFilePath(filePath));\n}\n\n/**\n * Check if a file path has a folder name.\n *\n * @param filePath - The file path to process\n * @returns An indicator specifying if the file path has a folder name\n */\nexport function hasFolderName(filePath: string): boolean {\n  return Boolean(findFolderName(filePath));\n}\n\n/**\n * Check if a file path has a file extension.\n *\n * @param filePath - The file path to process\n * @returns An indicator specifying if the file path has a file extension\n */\nexport function hasFileExtension(filePath: string): boolean {\n  return Boolean(findFileExtension(filePath));\n}\n\n/**\n * Resolve the file path to an absolute path.\n *\n * @param path - The path to resolve\n * @param cwd - The current working directory\n * @returns The resolved path\n */\nexport function resolvePath(path: string, cwd = currentDir()) {\n  // Normalize windows arguments\n  const paths = normalizeWindowsPath(path).split(\"/\");\n\n  let resolvedPath = \"\";\n  let resolvedAbsolute = false;\n\n  for (\n    let index = paths.length - 1;\n    index >= -1 && !resolvedAbsolute;\n    index--\n  ) {\n    const path = index >= 0 ? paths[index] : cwd;\n\n    // Skip empty entries\n    if (!path || path.length === 0) {\n      continue;\n    }\n\n    resolvedPath = joinPaths(path, resolvedPath);\n    resolvedAbsolute = isAbsolutePath(path);\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);\n\n  if (resolvedAbsolute && !isAbsolutePath(resolvedPath)) {\n    return `/${resolvedPath}`;\n  }\n\n  return resolvedPath.length > 0 ? resolvedPath : \".\";\n}\n\nexport function resolve(...paths: string[]) {\n  // Normalize windows arguments\n  paths = paths.map(argument => normalizeWindowsPath(argument));\n\n  let resolvedPath = \"\";\n  let resolvedAbsolute = false;\n\n  for (\n    let index = paths.length - 1;\n    index >= -1 && !resolvedAbsolute;\n    index--\n  ) {\n    const path = index >= 0 ? paths[index] : currentDir();\n\n    // Skip empty entries\n    if (!path || path.length === 0) {\n      continue;\n    }\n\n    resolvedPath = `${path}/${resolvedPath}`;\n    resolvedAbsolute = isAbsolute(path);\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);\n\n  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {\n    return `/${resolvedPath}`;\n  }\n\n  return resolvedPath.length > 0 ? resolvedPath : \".\";\n}\n\n/**\n * Resolve the file path to an absolute path.\n *\n * @param paths - The paths to resolve\n * @returns The resolved path\n */\nexport function resolvePaths(...paths: string[]) {\n  return resolvePath(\n    joinPaths(...paths.map(path => normalizeWindowsPath(path)))\n  );\n}\n\n/**\n * Get the relative path from one file to another.\n *\n * @remarks\n * This function is similar to the `path.relative` function in Node's path module.\n *\n * @param from - The base path to start from\n * @param to - The target path to resolve relative to the base path\n * @returns The relative path from the base path to the target path\n */\nexport function relative(from: string, to: string) {\n  // we cast these because `split` will always be at least one string\n  const _from = resolve(from).replace(ROOT_FOLDER_REGEX, \"$1\").split(\"/\") as [\n    string,\n    ...string[]\n  ];\n  const _to = resolve(to).replace(ROOT_FOLDER_REGEX, \"$1\").split(\"/\") as [\n    string,\n    ...string[]\n  ];\n\n  // Different windows drive letters\n  if (_to[0][1] === \":\" && _from[0][1] === \":\" && _from[0] !== _to[0]) {\n    return _to.join(\"/\");\n  }\n\n  const _fromCopy = [..._from];\n  for (const segment of _fromCopy) {\n    if (_to[0] !== segment) {\n      break;\n    }\n    _from.shift();\n    _to.shift();\n  }\n  return [..._from.map(() => \"..\"), ..._to].join(\"/\");\n}\n\n/**\n * Get the relative path from one file to another.\n *\n * @remarks\n * This function wraps the `path.relative` function in Node's path module.\n *\n * @param from - The base path to start from\n * @param to - The target path to resolve relative to the base path\n * @param withEndSlash - Whether to include a trailing slash at the end of the path\n * @returns The relative path from the base path to the target path\n */\nexport function relativePath(from: string, to: string, withEndSlash = false) {\n  return relative(\n    withEndSlash !== true ? from.replace(/\\/$/, \"\") : from,\n    withEndSlash !== true ? to.replace(/\\/$/, \"\") : to\n  );\n}\n\n/**\n * Find the file path relative to the workspace root path.\n *\n * @param filePath - The file path to process\n * @returns The resolved file path\n */\nexport function relativeToCurrentDir(filePath: string) {\n  return relativePath(filePath, currentDir());\n}\n\n/**\n * Check if the path is a relative path.\n *\n * @param path - The path to check\n * @returns An indicator specifying if the path is a relative path\n */\nexport function parsePath(path: string) {\n  // The root of the path such as '/' or 'c:\\'\n  const root =\n    /^[/\\\\]|^[a-z]:[/\\\\]/i.exec(path)?.[0]?.replace(/\\\\/g, \"/\") || \"\";\n\n  const normalizedPath = normalizeWindowsPath(path);\n\n  const segments = normalizedPath.replace(/\\/$/, \"\").split(\"/\").slice(0, -1);\n  if (segments.length === 1 && /^[A-Z]:$/i.test(segments[0] as string)) {\n    segments[0] += \"/\";\n  }\n\n  const base = findFolderName(normalizedPath);\n  const dir = segments.join(\"/\") || (isAbsolutePath(path) ? \"/\" : \".\");\n  const ext = findFileExtensionSafe(path);\n\n  return {\n    root,\n    dir,\n    base,\n    ext,\n    name: base.slice(0, base.length - ext.length)\n  };\n}\n\n/**\n * Rename the file name with a new name.\n *\n * @param filePath - The current file path being processed\n * @param newFileName - The updated file name being processed\n * @returns The modified or unmodified file path.\n */\nexport function renameFile(filePath: string, newFileName: string): string {\n  const file = parsePath(filePath);\n\n  return joinPaths(\n    file.dir,\n    newFileName.includes(\".\") ? newFileName : newFileName + file.ext\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuDA,SAAgB,aACd,UACA,UAA+B,EAAE,EACzB;CACR,MAAM,EAAE,mBAAmB,OAAO,gBAAgB,SAAS;CAC3D,MAAM,SACJ,qBAAqB,SAAS,EAC1B,MAAM,UAAU,SAAS,KAAK,GAAG,OAAO,IAAI,EAC5C,KAAK,IAAI;AAEf,KAAI,qBAAqB,QAAQ,CAAC,OAAO,SAAS,IAAI,CACpD,QAAO;AAGT,KAAI,kBAAkB,SAAS,OAAO,SAAS,IAAI,CACjD,QACE,OAAO,QAAQ,IAAI,kBAAkB,OAAO,IAAI,MAAM,GAAG,IAAI;AAIjE,QAAO;;;;;;;;;;;;;;;;;;AAmBT,SAAgB,aACd,UACA,UAA+B,EAAE,EACzB;CACR,MAAM,iBAAiB,qBAAqB,SAAS;CAErD,MAAM,SAAS,eAAe,QAC5B,aAAa,gBAAgB;EAAE,kBAAkB;EAAO,GAAG;EAAS,CAAC,EACrE,GACD;AAED,QAAO,WAAW,MAAM,SAAS,OAAO,QAAQ,OAAO,GAAG;;AAG5D,MAAa,UAAU;;;;;;;;;;;;;;;;AAiBvB,SAAgB,eACd,UACA,SACQ;CACR,MAAM,WAAW,aAAa,UAAU,QAAQ,CAAC,MAAM,IAAI;CAE3D,IAAI,cAAc;AAClB,MAAK,IAAI,IAAI,SAAS,SAAS,GAAG,KAAK,GAAG,KAAK;EAC7C,MAAM,MAAM,SAAS;AACrB,MAAI,KAAK;AACP,iBAAc;AACd;;;AAWJ,QAAO,eAAe;;AAGxB,MAAa,WAAW;;;;;;;;;;;;;;;;;;;AAoBxB,SAAgB,kBAAkB,UAAsC;AACtE,KAAI,SAAS,SAAS,IAAI,IAAI,SAAS,SAAS,IAAI,CAClD;CAGF,MAAM,QAAQ,qBAAqB,KAAK,qBAAqB,SAAS,CAAC;AAEvE,QAAO,SAAS,MAAM,SAAS,KAAK,YAAY,MAAM,GAAG,GACrD,MAAM,GAAG,QAAQ,KAAK,GAAG,GACzB;;AAGN,MAAa,UAAU;;;;;;;;;;;;AAavB,SAAgB,qBAAqB,UAAsC;CACzE,MAAM,MAAM,kBAAkB,SAAS;AAEvC,QAAO,MAAM,IAAI,QAAQ;;;;;;;;;;;;;AAc3B,SAAgB,sBAAsB,UAA0B;AAC9D,QAAO,kBAAkB,SAAS,IAAI;;;;;;;;;;;;;AAcxC,SAAgB,yBAAyB,UAA0B;CACjE,MAAM,MAAM,kBAAkB,SAAS;AAEvC,QAAO,MAAM,IAAI,QAAQ;;;;;;;;AAS3B,SAAgB,YAAY,UAA2B;AACrD,QAAO,QAAQ,aAAa,SAAS,CAAC;;;;;;;;AASxC,SAAgB,YAAY,UAA2B;AACrD,QAAO,QAAQ,aAAa,SAAS,CAAC;;;;;;;;AASxC,SAAgB,cAAc,UAA2B;AACvD,QAAO,QAAQ,eAAe,SAAS,CAAC;;;;;;;;AAS1C,SAAgB,iBAAiB,UAA2B;AAC1D,QAAO,QAAQ,kBAAkB,SAAS,CAAC;;;;;;;;;AAU7C,SAAgB,YAAY,MAAc,QAAMA,KAAY,EAAE;CAE5D,MAAM,QAAQ,qBAAqB,KAAK,CAAC,MAAM,IAAI;CAEnD,IAAI,eAAe;CACnB,IAAI,mBAAmB;AAEvB,MACE,IAAI,QAAQ,MAAM,SAAS,GAC3B,SAAS,MAAM,CAAC,kBAChB,SACA;EACA,MAAMC,SAAO,SAAS,IAAI,MAAM,SAASC;AAGzC,MAAI,CAACD,UAAQA,OAAK,WAAW,EAC3B;AAGF,iBAAe,UAAUA,QAAM,aAAa;AAC5C,qBAAmB,eAAeA,OAAK;;AAOzC,gBAAe,gBAAgB,cAAc,CAAC,iBAAiB;AAE/D,KAAI,oBAAoB,CAAC,eAAe,aAAa,CACnD,QAAO,IAAI;AAGb,QAAO,aAAa,SAAS,IAAI,eAAe;;AAGlD,SAAgB,QAAQ,GAAG,OAAiB;AAE1C,SAAQ,MAAM,KAAI,aAAY,qBAAqB,SAAS,CAAC;CAE7D,IAAI,eAAe;CACnB,IAAI,mBAAmB;AAEvB,MACE,IAAI,QAAQ,MAAM,SAAS,GAC3B,SAAS,MAAM,CAAC,kBAChB,SACA;EACA,MAAM,OAAO,SAAS,IAAI,MAAM,SAASD,KAAY;AAGrD,MAAI,CAAC,QAAQ,KAAK,WAAW,EAC3B;AAGF,iBAAe,GAAG,KAAK,GAAG;AAC1B,qBAAmB,WAAW,KAAK;;AAOrC,gBAAe,gBAAgB,cAAc,CAAC,iBAAiB;AAE/D,KAAI,oBAAoB,CAAC,WAAW,aAAa,CAC/C,QAAO,IAAI;AAGb,QAAO,aAAa,SAAS,IAAI,eAAe;;;;;;;;AASlD,SAAgB,aAAa,GAAG,OAAiB;AAC/C,QAAO,YACL,UAAU,GAAG,MAAM,KAAI,SAAQ,qBAAqB,KAAK,CAAC,CAAC,CAC5D;;;;;;;;;;;;AAaH,SAAgB,SAAS,MAAc,IAAY;CAEjD,MAAM,QAAQ,QAAQ,KAAK,CAAC,QAAQ,mBAAmB,KAAK,CAAC,MAAM,IAAI;CAIvE,MAAM,MAAM,QAAQ,GAAG,CAAC,QAAQ,mBAAmB,KAAK,CAAC,MAAM,IAAI;AAMnE,KAAI,IAAI,GAAG,OAAO,OAAO,MAAM,GAAG,OAAO,OAAO,MAAM,OAAO,IAAI,GAC/D,QAAO,IAAI,KAAK,IAAI;CAGtB,MAAM,YAAY,CAAC,GAAG,MAAM;AAC5B,MAAK,MAAM,WAAW,WAAW;AAC/B,MAAI,IAAI,OAAO,QACb;AAEF,QAAM,OAAO;AACb,MAAI,OAAO;;AAEb,QAAO,CAAC,GAAG,MAAM,UAAU,KAAK,EAAE,GAAG,IAAI,CAAC,KAAK,IAAI;;;;;;;;;;;;;AAcrD,SAAgB,aAAa,MAAc,IAAY,eAAe,OAAO;AAC3E,QAAO,SACL,iBAAiB,OAAO,KAAK,QAAQ,OAAO,GAAG,GAAG,MAClD,iBAAiB,OAAO,GAAG,QAAQ,OAAO,GAAG,GAAG,GACjD;;;;;;;;AASH,SAAgB,qBAAqB,UAAkB;AACrD,QAAO,aAAa,UAAUA,KAAY,CAAC;;;;;;;;AAS7C,SAAgB,UAAU,MAAc;CAEtC,MAAM,OACJ,uBAAuB,KAAK,KAAK,GAAG,IAAI,QAAQ,OAAO,IAAI,IAAI;CAEjE,MAAM,iBAAiB,qBAAqB,KAAK;CAEjD,MAAM,WAAW,eAAe,QAAQ,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,MAAM,GAAG,GAAG;AAC1E,KAAI,SAAS,WAAW,KAAK,YAAY,KAAK,SAAS,GAAa,CAClE,UAAS,MAAM;CAGjB,MAAM,OAAO,eAAe,eAAe;CAC3C,MAAM,MAAM,SAAS,KAAK,IAAI,KAAK,eAAe,KAAK,GAAG,MAAM;CAChE,MAAM,MAAM,sBAAsB,KAAK;AAEvC,QAAO;EACL;EACA;EACA;EACA;EACA,MAAM,KAAK,MAAM,GAAG,KAAK,SAAS,IAAI,OAAO;EAC9C;;;;;;;;;AAUH,SAAgB,WAAW,UAAkB,aAA6B;CACxE,MAAM,OAAO,UAAU,SAAS;AAEhC,QAAO,UACL,KAAK,KACL,YAAY,SAAS,IAAI,GAAG,cAAc,cAAc,KAAK,IAC9D"}
+{"version":3,"file":"file-path-fns.mjs","names":["currentDir","path","cwd"],"sources":["../src/file-path-fns.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 { isSetString } from \"@stryke/type-checks/is-set-string\";\nimport { EMPTY_STRING } from \"@stryke/types/base\";\nimport _path from \"node:path\";\nimport { normalizeString, normalizeWindowsPath } from \"./correct-path\";\nimport { cwd as currentDir } from \"./cwd\";\nimport { isAbsolute, isAbsolutePath } from \"./is-type\";\nimport { joinPaths } from \"./join-paths\";\nimport {\n  FILE_EXTENSION_REGEX,\n  FULL_FILE_EXTENSION_REGEX,\n  ROOT_FOLDER_REGEX\n} from \"./regex\";\n\nexport interface FindFileNameOptions extends FindFileExtensionOptions {\n  /**\n   * Require the file extension to be present in the file name.\n   *\n   * @defaultValue false\n   */\n  requireExtension?: boolean;\n\n  /**\n   * Return the file extension as part of the full file name result.\n   *\n   * @defaultValue true\n   */\n  withExtension?: boolean;\n}\n\n/**\n * Find the file name from a file path.\n *\n * @example\n * ```ts\n * const fileName = findFileName(\"C:\\\\Users\\\\user\\\\Documents\\\\file.txt\");\n * // fileName = \"file.txt\"\n * ```\n *\n * @param filePath - The file path to process\n * @param options - Options to control the file name extraction\n * @returns The file name\n */\nexport function findFileName(\n  filePath: string,\n  options: FindFileNameOptions = {}\n): string {\n  const { requireExtension = false, withExtension = true } = options;\n  const result =\n    normalizeWindowsPath(filePath)\n      ?.split(filePath?.includes(\"\\\\\") ? \"\\\\\" : \"/\")\n      ?.pop() ?? \"\";\n\n  if (requireExtension === true && !result.includes(\".\")) {\n    return EMPTY_STRING;\n  }\n\n  if (withExtension === false && result.includes(\".\")) {\n    return (\n      result.replace(`.${findFileExtension(result, options) ?? \"\"}`, \"\") ||\n      EMPTY_STRING\n    );\n  }\n\n  return result;\n}\n\n/**\n * Find the full file path's directories from a file path.\n *\n * @remarks\n * The functionality of this method is similar to the {@link _path.dirname} function in Node's path module.\n *\n * @example\n * ```ts\n * const folderPath = findFilePath(\"C:\\\\Users\\\\user\\\\Documents\\\\file.txt\");\n * // folderPath = \"C:\\\\Users\\\\user\\\\Documents\"\n * ```\n *\n * @param filePath - The file path to process\n * @param options - Options to control the file name extraction\n * @returns The full file path's directories\n */\nexport function findFilePath(\n  filePath: string,\n  options: FindFileNameOptions = {}\n): string {\n  const normalizedPath = normalizeWindowsPath(filePath);\n\n  const result = normalizedPath.replace(\n    findFileName(normalizedPath, { requireExtension: false, ...options }),\n    \"\"\n  );\n\n  return result === \"/\" ? result : result.replace(/\\/$/, \"\");\n}\n\nexport const dirname = findFilePath;\n\n/**\n * Find the top most folder containing the file from a file path.\n *\n * @remarks\n * The functionality of this method is similar to the {@link _path.basename} function in Node's path module.\n * If you're looking for the full path of the folder (for example: `C:\\\\Users\\\\user\\\\Documents` instead of just `Documents`) containing the file, use {@link findFilePath} instead.\n *\n * @example\n * const folderPath = findFolderName(\"C:\\\\Users\\\\user\\\\Documents\\\\file.txt\");\n * // folderPath = \"Documents\"\n *\n * @param filePath - The file path to process\n * @param options - Options to control the file name extraction\n * @returns The folder containing the file\n */\nexport function findFolderName(\n  filePath: string,\n  options?: FindFileNameOptions\n): string {\n  const segments = findFilePath(filePath, options).split(\"/\");\n\n  let lastSegment = \"\";\n  for (let i = segments.length - 1; i >= 0; i--) {\n    const val = segments[i];\n    if (val) {\n      lastSegment = val;\n      break;\n    }\n  }\n\n  // if (\n  //   folderPath.lastIndexOf(\"\\\\\") === folderPath.length - 1 ||\n  //   folderPath.lastIndexOf(\"/\") === folderPath.length - 1\n  // ) {\n  //   folderPath = folderPath.slice(0, Math.max(0, folderPath.length - 1));\n  // }\n\n  return lastSegment ?? EMPTY_STRING;\n}\n\nexport const basename = findFolderName;\n\nexport interface FindFileExtensionOptions {\n  /**\n   * Return the full file extension including `.d` and `.map` if present.\n   *\n   * @defaultValue false\n   */\n  fullExtension?: boolean;\n}\n\n/**\n * Find the file extension from a file path.\n *\n * @remarks\n * The functionality of this method is similar to the {@link path.extname} function in Node's path module.\n * The file extension is the part of the file name that comes after the last dot (`.`) in the file name. If the file name does not contain a dot, or if it ends with a dot, this function will return `undefined`.\n *\n * The returned extension **will not** include the dot, for example `txt` or `js` instead of `.txt` or `.js`.\n *\n * @example\n * ```ts\n * findFileExtension(\"C:\\\\Users\\\\user\\\\Documents\\\\file.config.ts\"); // Returns \"ts\"\n * findFileExtension(\"C:\\\\Users\\\\user\\\\Documents\\\\file.d.ts\"); // Returns \"ts\"\n * findFileExtension(\"C:\\\\Users\\\\user\\\\Documents\\\\file.d.ts\", { fullExtension: true }); // Returns \"d.ts\"\n * findFileExtension(\"C:\\\\Users\\\\user\\\\Documents\\\\file.ts.map\"); // Returns \"ts\"\n * findFileExtension(\"C:\\\\Users\\\\user\\\\Documents\\\\file.ts.map\", { fullExtension: true }); // Returns \"ts.map\"\n * findFileExtension(\"C:\\\\Users\\\\user\\\\Documents\\\\file\"); // Returns undefined\n * ```\n *\n * @param filePath - The file path to process\n * @param options - Options to control the file name extraction\n * @returns The file extension or undefined if no extension is found\n */\nexport function findFileExtension(\n  filePath: string,\n  options?: FindFileExtensionOptions\n): string | undefined {\n  if (filePath.endsWith(\".\") || filePath.endsWith(\"/\")) {\n    return undefined;\n  }\n\n  const match = (\n    options?.fullExtension ? FULL_FILE_EXTENSION_REGEX : FILE_EXTENSION_REGEX\n  ).exec(normalizeWindowsPath(filePath));\n\n  return match && match.length > 0 && isSetString(match[0])\n    ? match[0].replace(\".\", \"\")\n    : undefined;\n}\n\nexport const extname = findFileExtension;\n\n/**\n * Find the file extension including the `\".\"` character prefix from a file path.\n *\n * @remarks\n * The file extension is the part of the file name that comes after (and including) the last dot (`.`) in the file name. If the file name does not contain a dot, or if it ends with a dot, this function will return `undefined`.\n *\n * The returned extension **will** include the dot, for example `.txt` or `.js` instead of `txt` or `js`.\n *\n * @param filePath - The file path to process\n * @param options - Options to control the file name extraction\n * @returns The file extension (including the `\".\"` prefix) or undefined if no extension is found\n */\nexport function findFileDotExtension(\n  filePath: string,\n  options?: FindFileExtensionOptions\n): string | undefined {\n  const ext = findFileExtension(filePath, options);\n\n  return ext ? `.${ext}` : undefined;\n}\n\n/**\n * Find the file extension from a file path or an empty string.\n *\n *  @remarks\n * The file extension is the part of the file name that comes after the last dot (`.`) in the file name. If the file name does not contain a dot, or if it ends with a dot, this function will return `undefined`.\n *\n * The returned extension **will not** include the dot, for example `txt` or `js` instead of `.txt` or `.js`.\n *\n * @param filePath - The file path to process\n * @param options - Options to control the file name extraction\n * @returns The file extension or an empty string if no extension is found\n */\nexport function findFileExtensionSafe(\n  filePath: string,\n  options?: FindFileExtensionOptions\n): string {\n  return findFileExtension(filePath, options) ?? EMPTY_STRING;\n}\n\n/**\n * Find the file extension including the `\".\"` character prefix from a file path or an empty string.\n *\n *  @remarks\n * The file extension is the part of the file name that comes after (and including) the last dot (`.`) in the file name. If the file name does not contain a dot, or if it ends with a dot, this function will return `undefined`.\n *\n * The returned extension **will** include the dot, for example `.txt` or `.js` instead of `txt` or `js`.\n *\n * @param filePath - The file path to process\n * @param options - Options to control the file name extraction\n * @returns The file extension (including the `\".\"` prefix) or an empty string if no extension is found\n */\nexport function findFileDotExtensionSafe(\n  filePath: string,\n  options?: FindFileExtensionOptions\n): string {\n  const ext = findFileExtension(filePath, options);\n\n  return ext ? `.${ext}` : \"\";\n}\n\n/**\n * Check if a file path has a file name.\n *\n * @param filePath - The file path to process\n * @returns An indicator specifying if the file path has a file name\n */\nexport function hasFileName(filePath: string): boolean {\n  return Boolean(findFileName(filePath));\n}\n\n/**\n * Check if a file path has a file path.\n *\n * @param filePath - The file path to process\n * @returns An indicator specifying if the file path has a file path\n */\nexport function hasFilePath(filePath: string): boolean {\n  return Boolean(findFilePath(filePath));\n}\n\n/**\n * Check if a file path has a folder name.\n *\n * @param filePath - The file path to process\n * @returns An indicator specifying if the file path has a folder name\n */\nexport function hasFolderName(filePath: string): boolean {\n  return Boolean(findFolderName(filePath));\n}\n\n/**\n * Check if a file path has a file extension.\n *\n * @param filePath - The file path to process\n * @param options - Options to control the file name extraction\n * @returns An indicator specifying if the file path has a file extension\n */\nexport function hasFileExtension(\n  filePath: string,\n  options?: FindFileExtensionOptions\n): boolean {\n  return Boolean(findFileExtension(filePath, options));\n}\n\n/**\n * Resolve the file path to an absolute path.\n *\n * @param path - The path to resolve\n * @param cwd - The current working directory\n * @returns The resolved path\n */\nexport function resolvePath(path: string, cwd = currentDir()) {\n  // Normalize windows arguments\n  const paths = normalizeWindowsPath(path).split(\"/\");\n\n  let resolvedPath = \"\";\n  let resolvedAbsolute = false;\n\n  for (\n    let index = paths.length - 1;\n    index >= -1 && !resolvedAbsolute;\n    index--\n  ) {\n    const path = index >= 0 ? paths[index] : cwd;\n\n    // Skip empty entries\n    if (!path || path.length === 0) {\n      continue;\n    }\n\n    resolvedPath = joinPaths(path, resolvedPath);\n    resolvedAbsolute = isAbsolutePath(path);\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);\n\n  if (resolvedAbsolute && !isAbsolutePath(resolvedPath)) {\n    return `/${resolvedPath}`;\n  }\n\n  return resolvedPath.length > 0 ? resolvedPath : \".\";\n}\n\nexport function resolve(...paths: string[]) {\n  // Normalize windows arguments\n  paths = paths.map(argument => normalizeWindowsPath(argument));\n\n  let resolvedPath = \"\";\n  let resolvedAbsolute = false;\n\n  for (\n    let index = paths.length - 1;\n    index >= -1 && !resolvedAbsolute;\n    index--\n  ) {\n    const path = index >= 0 ? paths[index] : currentDir();\n\n    // Skip empty entries\n    if (!path || path.length === 0) {\n      continue;\n    }\n\n    resolvedPath = `${path}/${resolvedPath}`;\n    resolvedAbsolute = isAbsolute(path);\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);\n\n  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {\n    return `/${resolvedPath}`;\n  }\n\n  return resolvedPath.length > 0 ? resolvedPath : \".\";\n}\n\n/**\n * Resolve the file path to an absolute path.\n *\n * @param paths - The paths to resolve\n * @returns The resolved path\n */\nexport function resolvePaths(...paths: string[]) {\n  return resolvePath(\n    joinPaths(...paths.map(path => normalizeWindowsPath(path)))\n  );\n}\n\n/**\n * Get the relative path from one file to another.\n *\n * @remarks\n * This function is similar to the `path.relative` function in Node's path module.\n *\n * @param from - The base path to start from\n * @param to - The target path to resolve relative to the base path\n * @returns The relative path from the base path to the target path\n */\nexport function relative(from: string, to: string) {\n  // we cast these because `split` will always be at least one string\n  const _from = resolve(from).replace(ROOT_FOLDER_REGEX, \"$1\").split(\"/\") as [\n    string,\n    ...string[]\n  ];\n  const _to = resolve(to).replace(ROOT_FOLDER_REGEX, \"$1\").split(\"/\") as [\n    string,\n    ...string[]\n  ];\n\n  // Different windows drive letters\n  if (_to[0][1] === \":\" && _from[0][1] === \":\" && _from[0] !== _to[0]) {\n    return _to.join(\"/\");\n  }\n\n  const _fromCopy = [..._from];\n  for (const segment of _fromCopy) {\n    if (_to[0] !== segment) {\n      break;\n    }\n    _from.shift();\n    _to.shift();\n  }\n  return [..._from.map(() => \"..\"), ..._to].join(\"/\");\n}\n\n/**\n * Get the relative path from one file to another.\n *\n * @remarks\n * This function wraps the `path.relative` function in Node's path module.\n *\n * @param from - The base path to start from\n * @param to - The target path to resolve relative to the base path\n * @param withEndSlash - Whether to include a trailing slash at the end of the path\n * @returns The relative path from the base path to the target path\n */\nexport function relativePath(from: string, to: string, withEndSlash = false) {\n  return relative(\n    withEndSlash !== true ? from.replace(/\\/$/, \"\") : from,\n    withEndSlash !== true ? to.replace(/\\/$/, \"\") : to\n  );\n}\n\n/**\n * Find the file path relative to the workspace root path.\n *\n * @param filePath - The file path to process\n * @returns The resolved file path\n */\nexport function relativeToCurrentDir(filePath: string) {\n  return relativePath(filePath, currentDir());\n}\n\n/**\n * Check if the path is a relative path.\n *\n * @param path - The path to check\n * @returns An indicator specifying if the path is a relative path\n */\nexport function parsePath(path: string, options?: FindFileNameOptions) {\n  // The root of the path such as '/' or 'c:\\'\n  const root =\n    /^[/\\\\]|^[a-z]:[/\\\\]/i.exec(path)?.[0]?.replace(/\\\\/g, \"/\") || \"\";\n\n  const normalizedPath = normalizeWindowsPath(path);\n\n  const segments = normalizedPath.replace(/\\/$/, \"\").split(\"/\").slice(0, -1);\n  if (segments.length === 1 && /^[A-Z]:$/i.test(segments[0] as string)) {\n    segments[0] += \"/\";\n  }\n\n  const base = findFolderName(normalizedPath, options);\n  const dir = segments.join(\"/\") || (isAbsolutePath(path) ? \"/\" : \".\");\n  const ext = findFileExtensionSafe(path, options);\n\n  return {\n    root,\n    dir,\n    base,\n    ext,\n    name: base.slice(0, base.length - ext.length)\n  };\n}\n\n/**\n * Rename the file name with a new name.\n *\n * @param filePath - The current file path being processed\n * @param newFileName - The updated file name being processed\n * @param options - Options to control the file name extraction\n * @returns The modified or unmodified file path.\n */\nexport function renameFile(\n  filePath: string,\n  newFileName: string,\n  options?: FindFileNameOptions\n): string {\n  const file = parsePath(filePath, options);\n\n  return joinPaths(\n    file.dir,\n    newFileName.includes(\".\") ? newFileName : newFileName + file.ext\n  );\n}\n"],"mappings":"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"}

package/dist/find.d.cts

@@ -1,2 +1,2 @@
-import { FindFileNameOptions, basename, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, hasFileExtension, hasFileName, hasFilePath, hasFolderName, parsePath, relative, relativePath, relativeToCurrentDir, renameFile, resolve, resolvePath, resolvePaths } from "./file-path-fns.cjs";
-export { FindFileNameOptions, basename, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, hasFileExtension, hasFileName, hasFilePath, hasFolderName, parsePath, relative, relativePath, relativeToCurrentDir, renameFile, resolve, resolvePath, resolvePaths };
+import { FindFileExtensionOptions, FindFileNameOptions, basename, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, hasFileExtension, hasFileName, hasFilePath, hasFolderName, parsePath, relative, relativePath, relativeToCurrentDir, renameFile, resolve, resolvePath, resolvePaths } from "./file-path-fns.cjs";
+export { FindFileExtensionOptions, FindFileNameOptions, basename, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, hasFileExtension, hasFileName, hasFilePath, hasFolderName, parsePath, relative, relativePath, relativeToCurrentDir, renameFile, resolve, resolvePath, resolvePaths };

package/dist/find.d.mts

@@ -1,2 +1,2 @@
-import { FindFileNameOptions, basename, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, hasFileExtension, hasFileName, hasFilePath, hasFolderName, parsePath, relative, relativePath, relativeToCurrentDir, renameFile, resolve, resolvePath, resolvePaths } from "./file-path-fns.mjs";
-export { FindFileNameOptions, basename, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, hasFileExtension, hasFileName, hasFilePath, hasFolderName, parsePath, relative, relativePath, relativeToCurrentDir, renameFile, resolve, resolvePath, resolvePaths };
+import { FindFileExtensionOptions, FindFileNameOptions, basename, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, hasFileExtension, hasFileName, hasFilePath, hasFolderName, parsePath, relative, relativePath, relativeToCurrentDir, renameFile, resolve, resolvePath, resolvePaths } from "./file-path-fns.mjs";
+export { FindFileExtensionOptions, FindFileNameOptions, basename, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, hasFileExtension, hasFileName, hasFilePath, hasFolderName, parsePath, relative, relativePath, relativeToCurrentDir, renameFile, resolve, resolvePath, resolvePaths };

package/dist/glob-to-regex.cjs

@@ -45,23 +45,19 @@ function globToRegex(glob, options = {}) {
 				regex += `\\${glob[i]}`;
 				break;
 			case "?":
-				if (options.extended !== false) regex += ".";
+				regex += ".";
 				break;
 			case "[":
 			case "]":
-				if (options.extended !== false) regex += glob[i];
+				regex += glob[i];
 				break;
 			case "{":
-				if (options.extended !== false) {
-					inGroup = true;
-					regex += "(";
-				}
+				inGroup = true;
+				regex += "(";
 				break;
 			case "}":
-				if (options.extended !== false) {
-					inGroup = false;
-					regex += ")";
-				}
+				inGroup = false;
+				regex += ")";
 				break;
 			case ",":
 				if (inGroup) regex += "|";

package/dist/glob-to-regex.d.cts

@@ -3,12 +3,6 @@
  * Options for the `globToRegex` function.
  */
 interface GlobToRegexOptions {
-  /**
-   * Enables extended globbing features such as `?`, `+`, `@`, and `!`.
-   *
-   * @defaultValue true
-   */
-  extended?: boolean;
   /**
    * Enables globstar support (`**`).
    *

package/dist/glob-to-regex.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"glob-to-regex.d.cts","names":[],"sources":["../src/glob-to-regex.ts"],"sourcesContent":[],"mappings":";;AAuBA;AA6CA;UA7CiB,kBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6CD,WAAA,yBAEL,qBACR"}
+{"version":3,"file":"glob-to-regex.d.cts","names":[],"sources":["../src/glob-to-regex.ts"],"sourcesContent":[],"mappings":";;AAuBA;AAsCA;UAtCiB,kBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCD,WAAA,yBAEL,qBACR"}

package/dist/glob-to-regex.d.mts

@@ -3,12 +3,6 @@
  * Options for the `globToRegex` function.
  */
 interface GlobToRegexOptions {
-  /**
-   * Enables extended globbing features such as `?`, `+`, `@`, and `!`.
-   *
-   * @defaultValue true
-   */
-  extended?: boolean;
   /**
    * Enables globstar support (`**`).
    *

package/dist/glob-to-regex.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"glob-to-regex.d.mts","names":[],"sources":["../src/glob-to-regex.ts"],"sourcesContent":[],"mappings":";;AAuBA;AA6CA;UA7CiB,kBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6CD,WAAA,yBAEL,qBACR"}
+{"version":3,"file":"glob-to-regex.d.mts","names":[],"sources":["../src/glob-to-regex.ts"],"sourcesContent":[],"mappings":";;AAuBA;AAsCA;UAtCiB,kBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCD,WAAA,yBAEL,qBACR"}

package/dist/glob-to-regex.mjs

@@ -45,23 +45,19 @@ function globToRegex(glob, options = {}) {
 				regex += `\\${glob[i]}`;
 				break;
 			case "?":
-				if (options.extended !== false) regex += ".";
+				regex += ".";
 				break;
 			case "[":
 			case "]":
-				if (options.extended !== false) regex += glob[i];
+				regex += glob[i];
 				break;
 			case "{":
-				if (options.extended !== false) {
-					inGroup = true;
-					regex += "(";
-				}
+				inGroup = true;
+				regex += "(";
 				break;
 			case "}":
-				if (options.extended !== false) {
-					inGroup = false;
-					regex += ")";
-				}
+				inGroup = false;
+				regex += ")";
 				break;
 			case ",":
 				if (inGroup) regex += "|";

package/dist/glob-to-regex.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"glob-to-regex.mjs","names":[],"sources":["../src/glob-to-regex.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 { isSetString } from \"@stryke/type-checks/is-set-string\";\n\n/**\n * Options for the `globToRegex` function.\n */\nexport interface GlobToRegexOptions {\n  /**\n   * Enables extended globbing features such as `?`, `+`, `@`, and `!`.\n   *\n   * @defaultValue true\n   */\n  extended?: boolean;\n\n  /**\n   * Enables globstar support (`**`).\n   *\n   * @defaultValue true\n   */\n  globstar?: boolean;\n\n  /**\n   * Flags to use for the generated regular expression.\n   */\n  flags?: string;\n}\n\n/**\n * Converts a glob pattern to a regular expression.\n *\n * @see https://mergify.com/blog/origin-and-evolution-of-the-globstar\n * @see https://en.wikipedia.org/wiki/Glob_(programming)\n *\n * @remarks\n * This function converts a glob pattern (like `*.{js,ts}` or `**\\/src/**`) into a regular expression\n *\n * @example\n * ```ts\n * import { globToRegex } from \"@stryke/path/glob-to-regex\";\n *\n * const test1 = globToRegex(\"*.{js,ts}\");\n * console.log(test1); // Output: /^([^/]*)\\.(js|ts)$/\n *\n * const test2 = globToRegex(\"**\\/src/**\");\n * console.log(test2); // Output: /^((?:[^/]*(?:\\/|$))*)?\\/src\\/((?:[^/]*(?:\\/|$))*)?$/\n * ```\n *\n * @param glob - The glob pattern to convert.\n * @param options - The options for the conversion.\n * @returns The converted regular expression.\n */\nexport function globToRegex(\n  glob: string,\n  options: GlobToRegexOptions = {}\n): RegExp {\n  if (!isSetString(glob)) {\n    throw new TypeError(\"A string was not provided as a glob pattern.\");\n  }\n\n  let regex = \"\";\n  let inGroup = false;\n  for (let i = 0; i < glob.length; i++) {\n    let count = 1;\n    switch (glob[i]) {\n      case \"/\":\n      case \"$\":\n      case \"^\":\n      case \"+\":\n      case \".\":\n      case \"(\":\n      case \")\":\n      case \"=\":\n      case \"!\":\n      case \"|\":\n        regex += `\\\\${glob[i]}`;\n        break;\n\n      case \"?\":\n        if (options.extended !== false) {\n          regex += \".\";\n        }\n        break;\n\n      case \"[\":\n      case \"]\":\n        if (options.extended !== false) {\n          regex += glob[i];\n        }\n        break;\n\n      case \"{\":\n        if (options.extended !== false) {\n          inGroup = true;\n          regex += \"(\";\n        }\n        break;\n\n      case \"}\":\n        if (options.extended !== false) {\n          inGroup = false;\n          regex += \")\";\n        }\n        break;\n\n      case \",\":\n        if (inGroup) {\n          regex += \"|\";\n        }\n        regex += `\\\\${glob[i]}`;\n        break;\n\n      case \"*\":\n        while (glob[i + 1] === \"*\") {\n          count++;\n          i++;\n        }\n\n        if (options.globstar === false) {\n          regex += \".*\";\n        } else if (\n          count > 1 &&\n          i - count >= 0 &&\n          (glob[i - count] === \"/\" || glob[i - count] === undefined) &&\n          i + 1 < glob.length &&\n          (glob[i + 1] === \"/\" || glob[i + 1] === undefined)\n        ) {\n          regex += \"((?:[^\\/]*(?:\\/|$))*)\";\n          i++;\n        } else {\n          regex += \"([^\\/]*)\";\n        }\n\n        break;\n\n      case undefined:\n      default:\n        regex += glob[i];\n    }\n  }\n\n  const flags = isSetString(options.flags) ? options.flags : \"\";\n  if (!flags || !~flags.indexOf(\"g\")) {\n    regex = `^${regex}$`;\n  }\n\n  return new RegExp(regex, flags);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAoEA,SAAgB,YACd,MACA,UAA8B,EAAE,EACxB;AACR,KAAI,CAAC,YAAY,KAAK,CACpB,OAAM,IAAI,UAAU,+CAA+C;CAGrE,IAAI,QAAQ;CACZ,IAAI,UAAU;AACd,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACpC,IAAI,QAAQ;AACZ,UAAQ,KAAK,IAAb;GACE,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;AACH,aAAS,KAAK,KAAK;AACnB;GAEF,KAAK;AACH,QAAI,QAAQ,aAAa,MACvB,UAAS;AAEX;GAEF,KAAK;GACL,KAAK;AACH,QAAI,QAAQ,aAAa,MACvB,UAAS,KAAK;AAEhB;GAEF,KAAK;AACH,QAAI,QAAQ,aAAa,OAAO;AAC9B,eAAU;AACV,cAAS;;AAEX;GAEF,KAAK;AACH,QAAI,QAAQ,aAAa,OAAO;AAC9B,eAAU;AACV,cAAS;;AAEX;GAEF,KAAK;AACH,QAAI,QACF,UAAS;AAEX,aAAS,KAAK,KAAK;AACnB;GAEF,KAAK;AACH,WAAO,KAAK,IAAI,OAAO,KAAK;AAC1B;AACA;;AAGF,QAAI,QAAQ,aAAa,MACvB,UAAS;aAET,QAAQ,KACR,IAAI,SAAS,MACZ,KAAK,IAAI,WAAW,OAAO,KAAK,IAAI,WAAW,WAChD,IAAI,IAAI,KAAK,WACZ,KAAK,IAAI,OAAO,OAAO,KAAK,IAAI,OAAO,SACxC;AACA,cAAS;AACT;UAEA,UAAS;AAGX;GAEF,KAAK;GACL,QACE,UAAS,KAAK;;;CAIpB,MAAM,QAAQ,YAAY,QAAQ,MAAM,GAAG,QAAQ,QAAQ;AAC3D,KAAI,CAAC,SAAS,CAAC,CAAC,MAAM,QAAQ,IAAI,CAChC,SAAQ,IAAI,MAAM;AAGpB,QAAO,IAAI,OAAO,OAAO,MAAM"}
+{"version":3,"file":"glob-to-regex.mjs","names":[],"sources":["../src/glob-to-regex.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 { isSetString } from \"@stryke/type-checks/is-set-string\";\n\n/**\n * Options for the `globToRegex` function.\n */\nexport interface GlobToRegexOptions {\n  /**\n   * Enables globstar support (`**`).\n   *\n   * @defaultValue true\n   */\n  globstar?: boolean;\n\n  /**\n   * Flags to use for the generated regular expression.\n   */\n  flags?: string;\n}\n\n/**\n * Converts a glob pattern to a regular expression.\n *\n * @see https://mergify.com/blog/origin-and-evolution-of-the-globstar\n * @see https://en.wikipedia.org/wiki/Glob_(programming)\n *\n * @remarks\n * This function converts a glob pattern (like `*.{js,ts}` or `**\\/src/**`) into a regular expression\n *\n * @example\n * ```ts\n * import { globToRegex } from \"@stryke/path/glob-to-regex\";\n *\n * const test1 = globToRegex(\"*.{js,ts}\");\n * console.log(test1); // Output: /^([^/]*)\\.(js|ts)$/\n *\n * const test2 = globToRegex(\"**\\/src/**\");\n * console.log(test2); // Output: /^((?:[^/]*(?:\\/|$))*)?\\/src\\/((?:[^/]*(?:\\/|$))*)?$/\n * ```\n *\n * @param glob - The glob pattern to convert.\n * @param options - The options for the conversion.\n * @returns The converted regular expression.\n */\nexport function globToRegex(\n  glob: string,\n  options: GlobToRegexOptions = {}\n): RegExp {\n  if (!isSetString(glob)) {\n    throw new TypeError(\"A string was not provided as a glob pattern.\");\n  }\n\n  let regex = \"\";\n  let inGroup = false;\n  for (let i = 0; i < glob.length; i++) {\n    let count = 1;\n    switch (glob[i]) {\n      case \"/\":\n      case \"$\":\n      case \"^\":\n      case \"+\":\n      case \".\":\n      case \"(\":\n      case \")\":\n      case \"=\":\n      case \"!\":\n      case \"|\":\n        regex += `\\\\${glob[i]}`;\n        break;\n\n      case \"?\":\n        regex += \".\";\n        break;\n\n      case \"[\":\n      case \"]\":\n        regex += glob[i];\n        break;\n\n      case \"{\":\n        inGroup = true;\n        regex += \"(\";\n        break;\n\n      case \"}\":\n        inGroup = false;\n        regex += \")\";\n        break;\n\n      case \",\":\n        if (inGroup) {\n          regex += \"|\";\n        }\n        regex += `\\\\${glob[i]}`;\n        break;\n\n      case \"*\":\n        while (glob[i + 1] === \"*\") {\n          count++;\n          i++;\n        }\n\n        if (options.globstar === false) {\n          regex += \".*\";\n        } else if (\n          count > 1 &&\n          i - count >= 0 &&\n          (glob[i - count] === \"/\" || glob[i - count] === undefined) &&\n          i + 1 < glob.length &&\n          (glob[i + 1] === \"/\" || glob[i + 1] === undefined)\n        ) {\n          regex += \"((?:[^\\/]*(?:\\/|$))*)\";\n          i++;\n        } else {\n          regex += \"([^\\/]*)\";\n        }\n\n        break;\n\n      case undefined:\n      default:\n        regex += glob[i];\n    }\n  }\n\n  const flags = isSetString(options.flags) ? options.flags : \"\";\n  if (!flags || !~flags.indexOf(\"g\")) {\n    regex = `^${regex}$`;\n  }\n\n  return new RegExp(regex, flags);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA6DA,SAAgB,YACd,MACA,UAA8B,EAAE,EACxB;AACR,KAAI,CAAC,YAAY,KAAK,CACpB,OAAM,IAAI,UAAU,+CAA+C;CAGrE,IAAI,QAAQ;CACZ,IAAI,UAAU;AACd,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACpC,IAAI,QAAQ;AACZ,UAAQ,KAAK,IAAb;GACE,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;AACH,aAAS,KAAK,KAAK;AACnB;GAEF,KAAK;AACH,aAAS;AACT;GAEF,KAAK;GACL,KAAK;AACH,aAAS,KAAK;AACd;GAEF,KAAK;AACH,cAAU;AACV,aAAS;AACT;GAEF,KAAK;AACH,cAAU;AACV,aAAS;AACT;GAEF,KAAK;AACH,QAAI,QACF,UAAS;AAEX,aAAS,KAAK,KAAK;AACnB;GAEF,KAAK;AACH,WAAO,KAAK,IAAI,OAAO,KAAK;AAC1B;AACA;;AAGF,QAAI,QAAQ,aAAa,MACvB,UAAS;aAET,QAAQ,KACR,IAAI,SAAS,MACZ,KAAK,IAAI,WAAW,OAAO,KAAK,IAAI,WAAW,WAChD,IAAI,IAAI,KAAK,WACZ,KAAK,IAAI,OAAO,OAAO,KAAK,IAAI,OAAO,SACxC;AACA,cAAS;AACT;UAEA,UAAS;AAGX;GAEF,KAAK;GACL,QACE,UAAS,KAAK;;;CAIpB,MAAM,QAAQ,YAAY,QAAQ,MAAM,GAAG,QAAQ,QAAQ;AAC3D,KAAI,CAAC,SAAS,CAAC,CAAC,MAAM,QAAQ,IAAI,CAChC,SAAQ,IAAI,MAAM;AAGpB,QAAO,IAAI,OAAO,OAAO,MAAM"}

package/dist/index.cjs

@@ -19,6 +19,7 @@ exports.DEFAULT_ASSET_EXTS = require_asset_extensions.DEFAULT_ASSET_EXTS;
 exports.DRIVE_LETTER_REGEX = require_regex.DRIVE_LETTER_REGEX;
 exports.DRIVE_LETTER_START_REGEX = require_regex.DRIVE_LETTER_START_REGEX;
 exports.FILE_EXTENSION_REGEX = require_regex.FILE_EXTENSION_REGEX;
+exports.FULL_FILE_EXTENSION_REGEX = require_regex.FULL_FILE_EXTENSION_REGEX;
 exports.NPM_SCOPED_PACKAGE_REGEX = require_regex.NPM_SCOPED_PACKAGE_REGEX;
 exports.PACKAGE_PATH_REGEX = require_regex.PACKAGE_PATH_REGEX;
 exports.ROOT_FOLDER_REGEX = require_regex.ROOT_FOLDER_REGEX;

package/dist/index.d.cts

@@ -4,13 +4,13 @@ import { commonPath } from "./common.cjs";
 import { correctPath, normalizeString, normalizeWindowsPath, stripStars, toAbsolutePath, toRelativePath, withTrailingSlash, withoutTrailingSlash } from "./correct-path.cjs";
 import { cwd } from "./cwd.cjs";
 import { delimiter, posix, win32 } from "./delimiter.cjs";
-import { FindFileNameOptions, basename, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, hasFileExtension, hasFileName, hasFilePath, hasFolderName, parsePath, relative, relativePath, relativeToCurrentDir, renameFile, resolve, resolvePath, resolvePaths } from "./file-path-fns.cjs";
+import { FindFileExtensionOptions, FindFileNameOptions, basename, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, hasFileExtension, hasFileName, hasFilePath, hasFolderName, parsePath, relative, relativePath, relativeToCurrentDir, renameFile, resolve, resolvePath, resolvePaths } from "./file-path-fns.cjs";
 import { GlobToRegexOptions, globToRegex } from "./glob-to-regex.cjs";
 import { isParentPath } from "./is-parent-path.cjs";
 import { isSystemRoot } from "./is-root-dir.cjs";
 import { join, joinPaths } from "./join-paths.cjs";
-import { ABSOLUTE_PATH_REGEX, DRIVE_LETTER_REGEX, DRIVE_LETTER_START_REGEX, FILE_EXTENSION_REGEX, NPM_SCOPED_PACKAGE_REGEX, PACKAGE_PATH_REGEX, ROOT_FOLDER_REGEX, UNC_REGEX } from "./regex.cjs";
+import { ABSOLUTE_PATH_REGEX, DRIVE_LETTER_REGEX, DRIVE_LETTER_START_REGEX, FILE_EXTENSION_REGEX, FULL_FILE_EXTENSION_REGEX, NPM_SCOPED_PACKAGE_REGEX, PACKAGE_PATH_REGEX, ROOT_FOLDER_REGEX, UNC_REGEX } from "./regex.cjs";
 import { replaceExtension, replacePath } from "./replace.cjs";
 import { resolveParentPath } from "./resolve-parent-path.cjs";
 import { formatSlash, slash } from "./slash.cjs";
-export { ABSOLUTE_PATH_REGEX, AppendPathOptions, DEFAULT_ASSET_EXTS, DRIVE_LETTER_REGEX, DRIVE_LETTER_START_REGEX, FILE_EXTENSION_REGEX, FindFileNameOptions, GlobToRegexOptions, NPM_SCOPED_PACKAGE_REGEX, PACKAGE_PATH_REGEX, ROOT_FOLDER_REGEX, UNC_REGEX, append, appendExtension, appendPath, basename, commonPath, correctPath, cwd, delimiter, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, formatSlash, globToRegex, hasFileExtension, hasFileName, hasFilePath, hasFolderName, isParentPath, isSystemRoot, join, joinPaths, normalizeString, normalizeWindowsPath, parsePath, posix, relative, relativePath, relativeToCurrentDir, renameFile, replaceExtension, replacePath, resolve, resolveParentPath, resolvePath, resolvePaths, slash, stripStars, toAbsolutePath, toRelativePath, win32, withTrailingSlash, withoutTrailingSlash };
+export { ABSOLUTE_PATH_REGEX, AppendPathOptions, DEFAULT_ASSET_EXTS, DRIVE_LETTER_REGEX, DRIVE_LETTER_START_REGEX, FILE_EXTENSION_REGEX, FULL_FILE_EXTENSION_REGEX, FindFileExtensionOptions, FindFileNameOptions, GlobToRegexOptions, NPM_SCOPED_PACKAGE_REGEX, PACKAGE_PATH_REGEX, ROOT_FOLDER_REGEX, UNC_REGEX, append, appendExtension, appendPath, basename, commonPath, correctPath, cwd, delimiter, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, formatSlash, globToRegex, hasFileExtension, hasFileName, hasFilePath, hasFolderName, isParentPath, isSystemRoot, join, joinPaths, normalizeString, normalizeWindowsPath, parsePath, posix, relative, relativePath, relativeToCurrentDir, renameFile, replaceExtension, replacePath, resolve, resolveParentPath, resolvePath, resolvePaths, slash, stripStars, toAbsolutePath, toRelativePath, win32, withTrailingSlash, withoutTrailingSlash };

package/dist/index.d.mts

@@ -4,13 +4,13 @@ import { commonPath } from "./common.mjs";
 import { correctPath, normalizeString, normalizeWindowsPath, stripStars, toAbsolutePath, toRelativePath, withTrailingSlash, withoutTrailingSlash } from "./correct-path.mjs";
 import { cwd } from "./cwd.mjs";
 import { delimiter, posix, win32 } from "./delimiter.mjs";
-import { FindFileNameOptions, basename, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, hasFileExtension, hasFileName, hasFilePath, hasFolderName, parsePath, relative, relativePath, relativeToCurrentDir, renameFile, resolve, resolvePath, resolvePaths } from "./file-path-fns.mjs";
+import { FindFileExtensionOptions, FindFileNameOptions, basename, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, hasFileExtension, hasFileName, hasFilePath, hasFolderName, parsePath, relative, relativePath, relativeToCurrentDir, renameFile, resolve, resolvePath, resolvePaths } from "./file-path-fns.mjs";
 import { GlobToRegexOptions, globToRegex } from "./glob-to-regex.mjs";
 import { isParentPath } from "./is-parent-path.mjs";
 import { isSystemRoot } from "./is-root-dir.mjs";
 import { join, joinPaths } from "./join-paths.mjs";
-import { ABSOLUTE_PATH_REGEX, DRIVE_LETTER_REGEX, DRIVE_LETTER_START_REGEX, FILE_EXTENSION_REGEX, NPM_SCOPED_PACKAGE_REGEX, PACKAGE_PATH_REGEX, ROOT_FOLDER_REGEX, UNC_REGEX } from "./regex.mjs";
+import { ABSOLUTE_PATH_REGEX, DRIVE_LETTER_REGEX, DRIVE_LETTER_START_REGEX, FILE_EXTENSION_REGEX, FULL_FILE_EXTENSION_REGEX, NPM_SCOPED_PACKAGE_REGEX, PACKAGE_PATH_REGEX, ROOT_FOLDER_REGEX, UNC_REGEX } from "./regex.mjs";
 import { replaceExtension, replacePath } from "./replace.mjs";
 import { resolveParentPath } from "./resolve-parent-path.mjs";
 import { formatSlash, slash } from "./slash.mjs";
-export { ABSOLUTE_PATH_REGEX, AppendPathOptions, DEFAULT_ASSET_EXTS, DRIVE_LETTER_REGEX, DRIVE_LETTER_START_REGEX, FILE_EXTENSION_REGEX, FindFileNameOptions, GlobToRegexOptions, NPM_SCOPED_PACKAGE_REGEX, PACKAGE_PATH_REGEX, ROOT_FOLDER_REGEX, UNC_REGEX, append, appendExtension, appendPath, basename, commonPath, correctPath, cwd, delimiter, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, formatSlash, globToRegex, hasFileExtension, hasFileName, hasFilePath, hasFolderName, isParentPath, isSystemRoot, join, joinPaths, normalizeString, normalizeWindowsPath, parsePath, posix, relative, relativePath, relativeToCurrentDir, renameFile, replaceExtension, replacePath, resolve, resolveParentPath, resolvePath, resolvePaths, slash, stripStars, toAbsolutePath, toRelativePath, win32, withTrailingSlash, withoutTrailingSlash };
+export { ABSOLUTE_PATH_REGEX, AppendPathOptions, DEFAULT_ASSET_EXTS, DRIVE_LETTER_REGEX, DRIVE_LETTER_START_REGEX, FILE_EXTENSION_REGEX, FULL_FILE_EXTENSION_REGEX, FindFileExtensionOptions, FindFileNameOptions, GlobToRegexOptions, NPM_SCOPED_PACKAGE_REGEX, PACKAGE_PATH_REGEX, ROOT_FOLDER_REGEX, UNC_REGEX, append, appendExtension, appendPath, basename, commonPath, correctPath, cwd, delimiter, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, formatSlash, globToRegex, hasFileExtension, hasFileName, hasFilePath, hasFolderName, isParentPath, isSystemRoot, join, joinPaths, normalizeString, normalizeWindowsPath, parsePath, posix, relative, relativePath, relativeToCurrentDir, renameFile, replaceExtension, replacePath, resolve, resolveParentPath, resolvePath, resolvePaths, slash, stripStars, toAbsolutePath, toRelativePath, win32, withTrailingSlash, withoutTrailingSlash };

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { cwd } from "./cwd.mjs";
-import { ABSOLUTE_PATH_REGEX, DRIVE_LETTER_REGEX, DRIVE_LETTER_START_REGEX, FILE_EXTENSION_REGEX, NPM_SCOPED_PACKAGE_REGEX, PACKAGE_PATH_REGEX, ROOT_FOLDER_REGEX, UNC_REGEX } from "./regex.mjs";
+import { ABSOLUTE_PATH_REGEX, DRIVE_LETTER_REGEX, DRIVE_LETTER_START_REGEX, FILE_EXTENSION_REGEX, FULL_FILE_EXTENSION_REGEX, NPM_SCOPED_PACKAGE_REGEX, PACKAGE_PATH_REGEX, ROOT_FOLDER_REGEX, UNC_REGEX } from "./regex.mjs";
 import { formatSlash, slash } from "./slash.mjs";
 import { isParentPath } from "./is-parent-path.mjs";
 import { join, joinPaths } from "./join-paths.mjs";
@@ -14,4 +14,4 @@ import { isSystemRoot } from "./is-root-dir.mjs";
 import { replaceExtension, replacePath } from "./replace.mjs";
 import { resolveParentPath } from "./resolve-parent-path.mjs";
 
-export { ABSOLUTE_PATH_REGEX, DEFAULT_ASSET_EXTS, DRIVE_LETTER_REGEX, DRIVE_LETTER_START_REGEX, FILE_EXTENSION_REGEX, NPM_SCOPED_PACKAGE_REGEX, PACKAGE_PATH_REGEX, ROOT_FOLDER_REGEX, UNC_REGEX, append, appendExtension, appendPath, basename, commonPath, correctPath, cwd, delimiter, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, formatSlash, globToRegex, hasFileExtension, hasFileName, hasFilePath, hasFolderName, isParentPath, isSystemRoot, join, joinPaths, normalizeString, normalizeWindowsPath, parsePath, posix, relative, relativePath, relativeToCurrentDir, renameFile, replaceExtension, replacePath, resolve, resolveParentPath, resolvePath, resolvePaths, slash, stripStars, toAbsolutePath, toRelativePath, win32, withTrailingSlash, withoutTrailingSlash };
+export { ABSOLUTE_PATH_REGEX, DEFAULT_ASSET_EXTS, DRIVE_LETTER_REGEX, DRIVE_LETTER_START_REGEX, FILE_EXTENSION_REGEX, FULL_FILE_EXTENSION_REGEX, NPM_SCOPED_PACKAGE_REGEX, PACKAGE_PATH_REGEX, ROOT_FOLDER_REGEX, UNC_REGEX, append, appendExtension, appendPath, basename, commonPath, correctPath, cwd, delimiter, dirname, extname, findFileDotExtension, findFileDotExtensionSafe, findFileExtension, findFileExtensionSafe, findFileName, findFilePath, findFolderName, formatSlash, globToRegex, hasFileExtension, hasFileName, hasFilePath, hasFolderName, isParentPath, isSystemRoot, join, joinPaths, normalizeString, normalizeWindowsPath, parsePath, posix, relative, relativePath, relativeToCurrentDir, renameFile, replaceExtension, replacePath, resolve, resolveParentPath, resolvePath, resolvePaths, slash, stripStars, toAbsolutePath, toRelativePath, win32, withTrailingSlash, withoutTrailingSlash };

package/dist/regex.cjs

@@ -6,6 +6,7 @@ const UNC_REGEX = /^[/\\]{2}/;
 const ABSOLUTE_PATH_REGEX = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^~[/\\]|^[A-Z]:[/\\]/i;
 const ROOT_FOLDER_REGEX = /^\/([A-Z]:)?$/i;
 const FILE_EXTENSION_REGEX = /\.[0-9a-z]+$/i;
+const FULL_FILE_EXTENSION_REGEX = /(\.d)?\.[0-9a-z]+(\.map)?$/i;
 const PACKAGE_PATH_REGEX = /^@\w+\/.*$/;
 const NPM_SCOPED_PACKAGE_REGEX = /^(?:@[\w-]+\/)?[\w-]+$/;
 
@@ -14,6 +15,7 @@ exports.ABSOLUTE_PATH_REGEX = ABSOLUTE_PATH_REGEX;
 exports.DRIVE_LETTER_REGEX = DRIVE_LETTER_REGEX;
 exports.DRIVE_LETTER_START_REGEX = DRIVE_LETTER_START_REGEX;
 exports.FILE_EXTENSION_REGEX = FILE_EXTENSION_REGEX;
+exports.FULL_FILE_EXTENSION_REGEX = FULL_FILE_EXTENSION_REGEX;
 exports.NPM_SCOPED_PACKAGE_REGEX = NPM_SCOPED_PACKAGE_REGEX;
 exports.PACKAGE_PATH_REGEX = PACKAGE_PATH_REGEX;
 exports.ROOT_FOLDER_REGEX = ROOT_FOLDER_REGEX;

package/dist/regex.d.cts

@@ -5,8 +5,9 @@ declare const UNC_REGEX: RegExp;
 declare const ABSOLUTE_PATH_REGEX: RegExp;
 declare const ROOT_FOLDER_REGEX: RegExp;
 declare const FILE_EXTENSION_REGEX: RegExp;
+declare const FULL_FILE_EXTENSION_REGEX: RegExp;
 declare const PACKAGE_PATH_REGEX: RegExp;
 declare const NPM_SCOPED_PACKAGE_REGEX: RegExp;
 //#endregion
-export { ABSOLUTE_PATH_REGEX, DRIVE_LETTER_REGEX, DRIVE_LETTER_START_REGEX, FILE_EXTENSION_REGEX, NPM_SCOPED_PACKAGE_REGEX, PACKAGE_PATH_REGEX, ROOT_FOLDER_REGEX, UNC_REGEX };
+export { ABSOLUTE_PATH_REGEX, DRIVE_LETTER_REGEX, DRIVE_LETTER_START_REGEX, FILE_EXTENSION_REGEX, FULL_FILE_EXTENSION_REGEX, NPM_SCOPED_PACKAGE_REGEX, PACKAGE_PATH_REGEX, ROOT_FOLDER_REGEX, UNC_REGEX };
 //# sourceMappingURL=regex.d.cts.map

package/dist/regex.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"regex.d.cts","names":[],"sources":["../src/regex.ts"],"sourcesContent":[],"mappings":";cAkBa,0BAAwB;AAAxB,cACA,kBADuC,EACrB,MADM;AACxB,cAEA,SAFgC,EAEvB,MAFS;AAElB,cAEA,mBAFuB,EAEJ,MAFI;AAEvB,cAGA,iBAHmB,EAGF,MAF2B;AAE5C,cAEA,oBAFiB,EAEG,MAFgB;AAEpC,cAEA,kBAFoB,EAEF,MAFoB;AAEtC,cACA,wBADiC,EACT,MADS"}
+{"version":3,"file":"regex.d.cts","names":[],"sources":["../src/regex.ts"],"sourcesContent":[],"mappings":";cAkBa,0BAAwB;AAAxB,cACA,kBADuC,EACrB,MADM;AACxB,cAEA,SAFgC,EAEvB,MAFS;AAElB,cAEA,mBAFuB,EAEJ,MAFI;AAEvB,cAGA,iBAHmB,EAGF,MAF2B;AAE5C,cAEA,oBAFiB,EAEG,MAFgB;AAEpC,cACA,yBADsC,EACb,MADa;AACtC,cAEA,kBAFyD,EAEvC,MAFO;AAEzB,cACA,wBADiC,EACT,MADS"}

package/dist/regex.d.mts

@@ -5,8 +5,9 @@ declare const UNC_REGEX: RegExp;
 declare const ABSOLUTE_PATH_REGEX: RegExp;
 declare const ROOT_FOLDER_REGEX: RegExp;
 declare const FILE_EXTENSION_REGEX: RegExp;
+declare const FULL_FILE_EXTENSION_REGEX: RegExp;
 declare const PACKAGE_PATH_REGEX: RegExp;
 declare const NPM_SCOPED_PACKAGE_REGEX: RegExp;
 //#endregion
-export { ABSOLUTE_PATH_REGEX, DRIVE_LETTER_REGEX, DRIVE_LETTER_START_REGEX, FILE_EXTENSION_REGEX, NPM_SCOPED_PACKAGE_REGEX, PACKAGE_PATH_REGEX, ROOT_FOLDER_REGEX, UNC_REGEX };
+export { ABSOLUTE_PATH_REGEX, DRIVE_LETTER_REGEX, DRIVE_LETTER_START_REGEX, FILE_EXTENSION_REGEX, FULL_FILE_EXTENSION_REGEX, NPM_SCOPED_PACKAGE_REGEX, PACKAGE_PATH_REGEX, ROOT_FOLDER_REGEX, UNC_REGEX };
 //# sourceMappingURL=regex.d.mts.map

package/dist/regex.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"regex.d.mts","names":[],"sources":["../src/regex.ts"],"sourcesContent":[],"mappings":";cAkBa,0BAAwB;AAAxB,cACA,kBADuC,EACrB,MADM;AACxB,cAEA,SAFgC,EAEvB,MAFS;AAElB,cAEA,mBAFuB,EAEJ,MAFI;AAEvB,cAGA,iBAHmB,EAGF,MAF2B;AAE5C,cAEA,oBAFiB,EAEG,MAFgB;AAEpC,cAEA,kBAFoB,EAEF,MAFoB;AAEtC,cACA,wBADiC,EACT,MADS"}
+{"version":3,"file":"regex.d.mts","names":[],"sources":["../src/regex.ts"],"sourcesContent":[],"mappings":";cAkBa,0BAAwB;AAAxB,cACA,kBADuC,EACrB,MADM;AACxB,cAEA,SAFgC,EAEvB,MAFS;AAElB,cAEA,mBAFuB,EAEJ,MAFI;AAEvB,cAGA,iBAHmB,EAGF,MAF2B;AAE5C,cAEA,oBAFiB,EAEG,MAFgB;AAEpC,cACA,yBADsC,EACb,MADa;AACtC,cAEA,kBAFyD,EAEvC,MAFO;AAEzB,cACA,wBADiC,EACT,MADS"}

package/dist/regex.mjs

@@ -5,9 +5,10 @@ const UNC_REGEX = /^[/\\]{2}/;
 const ABSOLUTE_PATH_REGEX = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^~[/\\]|^[A-Z]:[/\\]/i;
 const ROOT_FOLDER_REGEX = /^\/([A-Z]:)?$/i;
 const FILE_EXTENSION_REGEX = /\.[0-9a-z]+$/i;
+const FULL_FILE_EXTENSION_REGEX = /(\.d)?\.[0-9a-z]+(\.map)?$/i;
 const PACKAGE_PATH_REGEX = /^@\w+\/.*$/;
 const NPM_SCOPED_PACKAGE_REGEX = /^(?:@[\w-]+\/)?[\w-]+$/;
 
 //#endregion
-export { ABSOLUTE_PATH_REGEX, DRIVE_LETTER_REGEX, DRIVE_LETTER_START_REGEX, FILE_EXTENSION_REGEX, NPM_SCOPED_PACKAGE_REGEX, PACKAGE_PATH_REGEX, ROOT_FOLDER_REGEX, UNC_REGEX };
+export { ABSOLUTE_PATH_REGEX, DRIVE_LETTER_REGEX, DRIVE_LETTER_START_REGEX, FILE_EXTENSION_REGEX, FULL_FILE_EXTENSION_REGEX, NPM_SCOPED_PACKAGE_REGEX, PACKAGE_PATH_REGEX, ROOT_FOLDER_REGEX, UNC_REGEX };
 //# sourceMappingURL=regex.mjs.map

package/dist/regex.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"regex.mjs","names":[],"sources":["../src/regex.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\nexport const DRIVE_LETTER_START_REGEX = /^[A-Z]:\\//i;\nexport const DRIVE_LETTER_REGEX = /^[A-Z]:$/i;\n\nexport const UNC_REGEX = /^[/\\\\]{2}/;\n\nexport const ABSOLUTE_PATH_REGEX =\n  /^[/\\\\](?![/\\\\])|^[/\\\\]{2}(?!\\.)|^~[/\\\\]|^[A-Z]:[/\\\\]/i;\n\nexport const ROOT_FOLDER_REGEX = /^\\/([A-Z]:)?$/i;\n\nexport const FILE_EXTENSION_REGEX = /\\.[0-9a-z]+$/i;\n\nexport const PACKAGE_PATH_REGEX = /^@\\w+\\/.*$/;\nexport const NPM_SCOPED_PACKAGE_REGEX = /^(?:@[\\w-]+\\/)?[\\w-]+$/;\n"],"mappings":";AAkBA,MAAa,2BAA2B;AACxC,MAAa,qBAAqB;AAElC,MAAa,YAAY;AAEzB,MAAa,sBACX;AAEF,MAAa,oBAAoB;AAEjC,MAAa,uBAAuB;AAEpC,MAAa,qBAAqB;AAClC,MAAa,2BAA2B"}
+{"version":3,"file":"regex.mjs","names":[],"sources":["../src/regex.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\nexport const DRIVE_LETTER_START_REGEX = /^[A-Z]:\\//i;\nexport const DRIVE_LETTER_REGEX = /^[A-Z]:$/i;\n\nexport const UNC_REGEX = /^[/\\\\]{2}/;\n\nexport const ABSOLUTE_PATH_REGEX =\n  /^[/\\\\](?![/\\\\])|^[/\\\\]{2}(?!\\.)|^~[/\\\\]|^[A-Z]:[/\\\\]/i;\n\nexport const ROOT_FOLDER_REGEX = /^\\/([A-Z]:)?$/i;\n\nexport const FILE_EXTENSION_REGEX = /\\.[0-9a-z]+$/i;\nexport const FULL_FILE_EXTENSION_REGEX = /(\\.d)?\\.[0-9a-z]+(\\.map)?$/i;\n\nexport const PACKAGE_PATH_REGEX = /^@\\w+\\/.*$/;\nexport const NPM_SCOPED_PACKAGE_REGEX = /^(?:@[\\w-]+\\/)?[\\w-]+$/;\n"],"mappings":";AAkBA,MAAa,2BAA2B;AACxC,MAAa,qBAAqB;AAElC,MAAa,YAAY;AAEzB,MAAa,sBACX;AAEF,MAAa,oBAAoB;AAEjC,MAAa,uBAAuB;AACpC,MAAa,4BAA4B;AAEzC,MAAa,qBAAqB;AAClC,MAAa,2BAA2B"}

package/dist/replace.cjs

@@ -35,8 +35,8 @@ function replacePath(childPath, parentPath = require_cwd.cwd()) {
 * @param replacement - The value (or an empty string) to replace the current extension with
 * @returns The path with the replaced extension
 */
-function replaceExtension(path, replacement = "") {
-	return path.replace(!replacement || replacement.includes(".") ? require_file_path_fns.findFileDotExtensionSafe(path) : require_file_path_fns.findFileExtensionSafe(path), replacement);
+function replaceExtension(path, replacement = "", options) {
+	return path.replace(!replacement || replacement.includes(".") ? require_file_path_fns.findFileDotExtensionSafe(path, options) : require_file_path_fns.findFileExtensionSafe(path, options), replacement);
 }
 
 //#endregion

package/dist/replace.d.cts

@@ -1,4 +1,7 @@
+import { FindFileExtensionOptions } from "./file-path-fns.cjs";
+
 //#region src/replace.d.ts
+
 /**
  * Replace the base path from the beginning of the given path.
  *
@@ -28,7 +31,7 @@ declare function replacePath(childPath: string, parentPath?: string): string;
  * @param replacement - The value (or an empty string) to replace the current extension with
  * @returns The path with the replaced extension
  */
-declare function replaceExtension(path: string, replacement?: string): string;
+declare function replaceExtension(path: string, replacement?: string, options?: FindFileExtensionOptions): string;
 //#endregion
 export { replaceExtension, replacePath };
 //# sourceMappingURL=replace.d.cts.map

package/dist/replace.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"replace.d.cts","names":[],"sources":["../src/replace.ts"],"sourcesContent":[],"mappings":";;AAuCA;AAwBA;;;;;;;;;;;iBAxBgB,WAAA;;;;;;;;;;;;;;;;iBAwBA,gBAAA"}
+{"version":3,"file":"replace.d.cts","names":[],"sources":["../src/replace.ts"],"sourcesContent":[],"mappings":";;;;;;AAwCA;AAwBA;;;;;;;;;;iBAxBgB,WAAA;;;;;;;;;;;;;;;;iBAwBA,gBAAA,+CAGJ"}

package/dist/replace.d.mts

@@ -1,4 +1,7 @@
+import { FindFileExtensionOptions } from "./file-path-fns.mjs";
+
 //#region src/replace.d.ts
+
 /**
  * Replace the base path from the beginning of the given path.
  *
@@ -28,7 +31,7 @@ declare function replacePath(childPath: string, parentPath?: string): string;
  * @param replacement - The value (or an empty string) to replace the current extension with
  * @returns The path with the replaced extension
  */
-declare function replaceExtension(path: string, replacement?: string): string;
+declare function replaceExtension(path: string, replacement?: string, options?: FindFileExtensionOptions): string;
 //#endregion
 export { replaceExtension, replacePath };
 //# sourceMappingURL=replace.d.mts.map

package/dist/replace.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"replace.d.mts","names":[],"sources":["../src/replace.ts"],"sourcesContent":[],"mappings":";;AAuCA;AAwBA;;;;;;;;;;;iBAxBgB,WAAA;;;;;;;;;;;;;;;;iBAwBA,gBAAA"}
+{"version":3,"file":"replace.d.mts","names":[],"sources":["../src/replace.ts"],"sourcesContent":[],"mappings":";;;;;;AAwCA;AAwBA;;;;;;;;;;iBAxBgB,WAAA;;;;;;;;;;;;;;;;iBAwBA,gBAAA,+CAGJ"}

package/dist/replace.mjs

@@ -35,8 +35,8 @@ function replacePath(childPath, parentPath = cwd()) {
 * @param replacement - The value (or an empty string) to replace the current extension with
 * @returns The path with the replaced extension
 */
-function replaceExtension(path, replacement = "") {
-	return path.replace(!replacement || replacement.includes(".") ? findFileDotExtensionSafe(path) : findFileExtensionSafe(path), replacement);
+function replaceExtension(path, replacement = "", options) {
+	return path.replace(!replacement || replacement.includes(".") ? findFileDotExtensionSafe(path, options) : findFileExtensionSafe(path, options), replacement);
 }
 
 //#endregion

package/dist/replace.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"replace.mjs","names":[],"sources":["../src/replace.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 { cwd } from \"./cwd\";\nimport {\n  findFileDotExtensionSafe,\n  findFileExtensionSafe\n} from \"./file-path-fns\";\nimport { isParentPath } from \"./is-parent-path\";\nimport { slash } from \"./slash\";\n\n/**\n * Replace the base path from the beginning of the given path.\n *\n * @example\n * ```ts\n * replacePath(\"/home/user/project/src/index.ts\", \"/home/user/project\");\n * // returns \"src/index.ts\"\n * ```\n *\n * @param childPath - The child path to replace the {@link parentPath} substring from\n * @param parentPath - The parent path to remove from the {@link childPath} parameter\n * @returns The {@link childPath} with the {@link parentPath} path removed\n */\nexport function replacePath(\n  childPath: string,\n  parentPath: string = cwd()\n): string {\n  return isParentPath(childPath, parentPath)\n    ? slash(childPath).replace(slash(parentPath), \"\").replace(/^\\//, \"\")\n    : childPath;\n}\n\n/**\n * Replace the extension of a given path with the provided value.\n *\n * @example\n * ```ts\n * replaceExtension(\"/home/user/project/src/index.ts\", \".js\");\n * // returns \"/home/user/project/src/index.js\"\n * replaceExtension(\"/home/user/project/src/index.ts\");\n * // returns \"/home/user/project/src/index\"\n * ```\n *\n * @param path - The path that will have its current extension replaced\n * @param replacement - The value (or an empty string) to replace the current extension with\n * @returns The path with the replaced extension\n */\nexport function replaceExtension(path: string, replacement = \"\"): string {\n  return path.replace(\n    !replacement || replacement.includes(\".\")\n      ? findFileDotExtensionSafe(path)\n      : findFileExtensionSafe(path),\n    replacement\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,YACd,WACA,aAAqB,KAAK,EAClB;AACR,QAAO,aAAa,WAAW,WAAW,GACtC,MAAM,UAAU,CAAC,QAAQ,MAAM,WAAW,EAAE,GAAG,CAAC,QAAQ,OAAO,GAAG,GAClE;;;;;;;;;;;;;;;;;AAkBN,SAAgB,iBAAiB,MAAc,cAAc,IAAY;AACvE,QAAO,KAAK,QACV,CAAC,eAAe,YAAY,SAAS,IAAI,GACrC,yBAAyB,KAAK,GAC9B,sBAAsB,KAAK,EAC/B,YACD"}
+{"version":3,"file":"replace.mjs","names":[],"sources":["../src/replace.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 { cwd } from \"./cwd\";\nimport type { FindFileExtensionOptions } from \"./file-path-fns\";\nimport {\n  findFileDotExtensionSafe,\n  findFileExtensionSafe\n} from \"./file-path-fns\";\nimport { isParentPath } from \"./is-parent-path\";\nimport { slash } from \"./slash\";\n\n/**\n * Replace the base path from the beginning of the given path.\n *\n * @example\n * ```ts\n * replacePath(\"/home/user/project/src/index.ts\", \"/home/user/project\");\n * // returns \"src/index.ts\"\n * ```\n *\n * @param childPath - The child path to replace the {@link parentPath} substring from\n * @param parentPath - The parent path to remove from the {@link childPath} parameter\n * @returns The {@link childPath} with the {@link parentPath} path removed\n */\nexport function replacePath(\n  childPath: string,\n  parentPath: string = cwd()\n): string {\n  return isParentPath(childPath, parentPath)\n    ? slash(childPath).replace(slash(parentPath), \"\").replace(/^\\//, \"\")\n    : childPath;\n}\n\n/**\n * Replace the extension of a given path with the provided value.\n *\n * @example\n * ```ts\n * replaceExtension(\"/home/user/project/src/index.ts\", \".js\");\n * // returns \"/home/user/project/src/index.js\"\n * replaceExtension(\"/home/user/project/src/index.ts\");\n * // returns \"/home/user/project/src/index\"\n * ```\n *\n * @param path - The path that will have its current extension replaced\n * @param replacement - The value (or an empty string) to replace the current extension with\n * @returns The path with the replaced extension\n */\nexport function replaceExtension(\n  path: string,\n  replacement = \"\",\n  options?: FindFileExtensionOptions\n): string {\n  return path.replace(\n    !replacement || replacement.includes(\".\")\n      ? findFileDotExtensionSafe(path, options)\n      : findFileExtensionSafe(path, options),\n    replacement\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,YACd,WACA,aAAqB,KAAK,EAClB;AACR,QAAO,aAAa,WAAW,WAAW,GACtC,MAAM,UAAU,CAAC,QAAQ,MAAM,WAAW,EAAE,GAAG,CAAC,QAAQ,OAAO,GAAG,GAClE;;;;;;;;;;;;;;;;;AAkBN,SAAgB,iBACd,MACA,cAAc,IACd,SACQ;AACR,QAAO,KAAK,QACV,CAAC,eAAe,YAAY,SAAS,IAAI,GACrC,yBAAyB,MAAM,QAAQ,GACvC,sBAAsB,MAAM,QAAQ,EACxC,YACD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stryke/path",
-  "version": "0.25.3",
+  "version": "0.26.1",
   "type": "module",
   "description": "A package containing various utilities that expand the functionality of NodeJs's built-in `path` module",
   "repository": {
@@ -78,12 +78,12 @@
   },
   "types": "./dist/index.d.cts",
   "devDependencies": {
-    "@storm-software/testing-tools": "^1.119.74",
-    "@stryke/convert": "^0.6.34",
-    "@stryke/type-checks": "^0.5.19",
-    "@stryke/types": "^0.10.33",
+    "@storm-software/testing-tools": "^1.119.75",
+    "@stryke/convert": "^0.6.36",
+    "@stryke/type-checks": "^0.5.21",
+    "@stryke/types": "^0.10.35",
     "tsdown": "^0.17.2"
   },
   "publishConfig": { "access": "public" },
-  "gitHead": "e0cedae14a70843b0d60ab6d8d36ec368d230310"
+  "gitHead": "1716c9e1c03b391ce3ffa33d31b3fc572517442a"
 }