@visulima/fs 5.0.0-alpha.12 → 5.0.0-alpha.14

package/CHANGELOG.md

@@ -1,3 +1,32 @@
+## @visulima/fs [5.0.0-alpha.14](https://github.com/visulima/visulima/compare/@visulima/fs@5.0.0-alpha.13...@visulima/fs@5.0.0-alpha.14) (2026-05-06)
+
+### Miscellaneous Chores
+
+* **fs:** apply prettier and eslint quote-style auto-fix ([cc5525e](https://github.com/visulima/visulima/commit/cc5525e0d5fe37f689ca7357cf274b88b604aba0))
+* **fs:** housekeeping cleanup ([95e8643](https://github.com/visulima/visulima/commit/95e8643922856fa21bd7b6830ff0e94e29c1b783))
+
+### Continuous Integration
+
+* integrate codspeed for benchmark tracking ([e758f3d](https://github.com/visulima/visulima/commit/e758f3da491cc00d3f8bbf10d7ba3fdf8deb5325))
+
+
+### Dependencies
+
+* **@visulima/error:** upgraded to 6.0.0-alpha.16
+
+## @visulima/fs [5.0.0-alpha.13](https://github.com/visulima/visulima/compare/@visulima/fs@5.0.0-alpha.12...@visulima/fs@5.0.0-alpha.13) (2026-05-04)
+
+### Miscellaneous Chores
+
+* **fs:** upgrade packem to 2.0.0-alpha.76 ([3dfa709](https://github.com/visulima/visulima/commit/3dfa709d723dd74576ce7003c63c11858c1e72e3))
+* re-sort workspace package.json files via vis sort-package-json ([f625696](https://github.com/visulima/visulima/commit/f625696cfac974325774b3243e1a83c3d23acbd7))
+* simplify pnpm-workspace packages list ([7cab221](https://github.com/visulima/visulima/commit/7cab221163632d9b7aa044a6f88c49083103a869))
+
+
+### Dependencies
+
+* **@visulima/error:** upgraded to 6.0.0-alpha.15
+
 ## @visulima/fs [5.0.0-alpha.12](https://github.com/visulima/visulima/compare/@visulima/fs@5.0.0-alpha.11...@visulima/fs@5.0.0-alpha.12) (2026-04-22)
 
 ### Bug Fixes

package/LICENSE.md

@@ -57,11 +57,14 @@ Repository: git+https://github.com/visulima/visulima.git
 >
 >
 > # Licenses of bundled dependencies
+>
 > The published @visulima/error artifact additionally contains code with the following licenses:
 > MIT
 >
 > # Bundled dependencies:
+>
 > ## is-plain-obj
+>
 > License: MIT
 > By: Sindre Sorhus
 > Repository: sindresorhus/is-plain-obj
@@ -75,6 +78,33 @@ Repository: git+https://github.com/visulima/visulima.git
 > > The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 > >
 > > THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+>
+>
+>
+>
+>
+> # Licenses of bundled types
+> The published @visulima/error artifact additionally contains code with the following licenses:
+> Apache-2.0
+>
+> # Bundled types:
+> ## ai
+> License: Apache-2.0
+> Repository: https://github.com/vercel/ai
+>
+> > Copyright 2023 Vercel, Inc.
+> >
+> > Licensed under the Apache License, Version 2.0 (the "License");
+> > you may not use this file except in compliance with the License.
+> > You may obtain a copy of the License at
+> >
+> >     http://www.apache.org/licenses/LICENSE-2.0
+> >
+> > Unless required by applicable law or agreed to in writing, software
+> > distributed under the License is distributed on an "AS IS" BASIS,
+> > WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+> > See the License for the specific language governing permissions and
+> > limitations under the License.
 
 ---------------------------------------
 
@@ -281,14 +311,11 @@ Repository: git+https://github.com/SuperchupuDev/tinyglobby.git
 <!-- TYPE_DEPENDENCIES -->
 
 # Licenses of bundled types
-
 The published @visulima/fs artifact additionally contains code with the following licenses:
-MIT
+ISC, MIT
 
 # Bundled types:
-
 ## is-fs-case-sensitive
-
 License: MIT
 By: Hiroki Osame
 Repository: privatenumber/is-fs-case-sensitive
@@ -315,4 +342,25 @@ Repository: privatenumber/is-fs-case-sensitive
 > OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 > SOFTWARE.
 
+---------------------------------------
+
+## yaml
+License: ISC
+By: Eemeli Aro
+Repository: github:eemeli/yaml
+
+> Copyright Eemeli Aro <eemeli@gmail.com>
+>
+> Permission to use, copy, modify, and/or distribute this software for any purpose
+> with or without fee is hereby granted, provided that the above copyright notice
+> and this permission notice appear in all copies.
+>
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+> REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+> FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+> INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+> OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+> TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+> THIS SOFTWARE.
+
 <!-- /TYPE_DEPENDENCIES -->

package/dist/eol.d.ts

@@ -1,6 +1,36 @@
+/** End-of-line character for POSIX platforms such as macOS and Linux. */
 declare const LF: "\n";
+/** End-of-line character for Windows platforms. */
 declare const CRLF: "\r\n";
+/**
+* End-of-line character evaluated for the current platform.
+*/
 declare const EOL: "\n" | "\r\n";
+/**
+* Detect the EOL character for string input.
+* Returns null if no newline.
+* @param content The string content to detect the EOL from.
+* @example
+* ```javascript
+* import { detect } from "@visulima/fs/eol";
+*
+* detect("Hello\r\nWorld"); // "\r\n"
+* detect("Hello\nWorld"); // "\n"
+* detect("HelloWorld"); // null
+* ```
+*/
 declare const detect: (content: string) => typeof EOL | null;
+/**
+* Format the file to the targeted EOL.
+* @param content The string content to format.
+* @param eol The target EOL character.
+* @example
+* ```javascript
+* import { format, LF, CRLF } from "@visulima/fs/eol";
+*
+* format("Hello\r\nWorld\nUnix", LF); // "Hello\nWorld\nUnix"
+* format("Hello\nWorld\r\nWindows", CRLF); // "Hello\r\nWorld\r\nWindows"
+* ```
+*/
 declare const format: (content: string, eol: typeof EOL) => string;
 export { CRLF, EOL, LF, detect, format };

package/dist/eol.js

@@ -1,26 +1,3 @@
-import { createRequire as __cjs_createRequire } from "node:module";
-
-const __cjs_require = __cjs_createRequire(import.meta.url);
-
-const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
-
-const {
-  platform
-} = __cjs_getProcess;
-
-const regDetect = /\r?\n/g;
-const LF = "\n";
-const CRLF = "\r\n";
-const EOL = platform === "win32" ? CRLF : LF;
-const detect = (content) => {
-  const matched = content.match(regDetect);
-  if (!matched || matched.length === 0) {
-    return null;
-  }
-  const crlf = matched.filter((newline) => newline === CRLF).length;
-  const lf = matched.length - crlf;
-  return crlf > lf ? CRLF : LF;
-};
-const format = (content, eol) => content.replaceAll(regDetect, eol);
-
-export { CRLF, EOL, LF, detect, format };
+var f=Object.defineProperty;var c=(t,e)=>f(t,"name",{value:e,configurable:!0});import{createRequire as u}from"node:module";const h=u(import.meta.url),p=typeof globalThis<"u"&&typeof globalThis.process<"u"?globalThis.process:process,{platform:g}=p;var m=Object.defineProperty,n=c((t,e)=>m(t,"name",{value:e,configurable:!0}),"r");const s=/\r?\n/g,l=`
+`,r=`\r
+`,b=g==="win32"?r:l,j=n(t=>{const e=t.match(s);if(!e||e.length===0)return null;const o=e.filter(i=>i===r).length,a=e.length-o;return o>a?r:l},"detect"),q=n((t,e)=>t.replaceAll(s,e),"format");export{r as CRLF,b as EOL,l as LF,j as detect,q as format};

package/dist/error.d.ts

@@ -1,43 +1,273 @@
-export { J as JSONError } from "./packem_shared/json-error.d-DgKaeuIf.js";
+export { J as JSONError } from "./packem_shared/json-error.d-DVILOyHc.js";
+/**
+* Error thrown when a file or directory already exists at a specified path, and an operation was expecting it not to.
+* @example
+* ```javascript
+* import { AlreadyExistsError } from "@visulima/fs/error"; // Assuming it's exported from an index or directly
+* import { ensureSymlinkSync } from "@visulima/fs"; // Or any function that might throw this
+* import { join } from "node:path";
+*
+* try {
+*   // Example: ensureSymlinkSync might throw this if a file (not a symlink) already exists at linkName
+*   // For demonstration, let's assume someFunction internally throws it:
+*   const someFunctionThatMightThrow = (path) => {
+*      if (path === "/tmp/existing-file.txt") { // Simulate a check
+*          throw new AlreadyExistsError(`file already exists at '/tmp/existing-file.txt'`);
+*      }
+*   }
+*   someFunctionThatMightThrow("/tmp/existing-file.txt");
+* } catch (error) {
+*   if (error instanceof AlreadyExistsError) {
+*     console.error(`Operation failed because path exists: ${error.message}`);
+*     console.error(`Error code: ${error.code}`); // EEXIST
+*   } else {
+*     console.error("An unexpected error occurred:", error);
+*   }
+* }
+* ```
+*/
 declare class AlreadyExistsError extends Error {
+  /**
+  * Creates a new instance.
+  * @param message
+  */
   constructor(message: string);
   get code(): string;
   set code(_name: string);
-  get name(): string;
-  set name(_name: string);
+  override get name(): string;
+  override set name(_name: string);
 }
+/**
+* Error thrown when an operation that is not allowed on a directory is attempted.
+* This typically occurs when a file-specific operation is used on a directory path.
+* @example
+* ```javascript
+* import { DirectoryError } from "@visulima/fs/error";
+* import { readFile } from "@visulima/fs"; // Or any function that might throw this
+* import { join } from "node:path";
+*
+* const attemptToReadFileFromDir = async () => {
+*   try {
+*     // Attempting to read a directory as if it were a file
+*     // This is a conceptual example; readFile might throw a different error first
+*     // depending on its internal checks, but EISDIR is the underlying system error.
+*     // Forcing the scenario:
+*     const pretendReadFileOnDir = (path) => {
+*       if (path === "/tmp/my-directory") { // Simulate a directory path
+*         throw new DirectoryError(`read '/tmp/my-directory'`);
+*       }
+*     }
+*     pretendReadFileOnDir("/tmp/my-directory");
+*     // await readFile(join("/tmp", "my-directory"));
+*   } catch (error) {
+*     if (error instanceof DirectoryError) {
+*       console.error(`Operation failed, path is a directory: ${error.message}`);
+*       console.error(`Error code: ${error.code}`); // EISDIR
+*     } else {
+*       console.error("An unexpected error occurred:", error);
+*     }
+*   }
+* };
+*
+* attemptToReadFileFromDir();
+* ```
+*/
 declare class DirectoryError extends Error {
+  /**
+  * Creates a new instance.
+  * @param message
+  */
   constructor(message: string);
   get code(): string;
   set code(_name: string);
-  get name(): string;
-  set name(_name: string);
+  override get name(): string;
+  override set name(_name: string);
 }
+/**
+* Error thrown when a directory is not empty.
+* @example
+* ```javascript
+* import { NotEmptyError } from "@visulima/fs/error";
+* import { rmdir } from "node:fs/promises"; // Or any fs function that might throw this system error
+* import { join } from "node:path";
+*
+* const attemptToRemoveNonEmptyDir = async () => {
+*   const dirPath = join("/tmp", "my-non-empty-dir"); // Assume this directory exists and has files
+*   try {
+*     // Forcing the scenario for demonstration, as rmdir might throw its own specific error.
+*     // Node.js fs operations that encounter a non-empty directory when expecting an empty one
+*     // typically throw an error with code ENOTEMPTY.
+*     const simulateNotEmpty = (path) => {
+*       if (path === dirPath) { // Simulate check for non-empty
+*          throw new NotEmptyError(`rmdir '${dirPath}'`);
+*       }
+*     }
+*     simulateNotEmpty(dirPath);
+*     // await rmdir(dirPath); // This would likely throw an error with code ENOTEMPTY
+*   } catch (error) {
+*     if (error instanceof NotEmptyError) {
+*       console.error(`Operation failed, directory is not empty: ${error.message}`);
+*       console.error(`Error code: ${error.code}`); // ENOTEMPTY
+*     } else {
+*       console.error("An unexpected error occurred:", error);
+*     }
+*   }
+* };
+*
+* // You would need to set up a non-empty directory at /tmp/my-non-empty-dir for a real test
+* // import { ensureDirSync, writeFileSync } from "@visulima/fs";
+* // ensureDirSync(dirPath);
+* // writeFileSync(join(dirPath, "somefile.txt"), "content");
+*
+* attemptToRemoveNonEmptyDir();
+* ```
+*/
 declare class NotEmptyError extends Error {
+  /**
+  * Creates a new instance.
+  * @param message
+  */
   constructor(message: string);
   get code(): string;
   set code(_name: string);
-  get name(): string;
-  set name(_name: string);
+  override get name(): string;
+  override set name(_name: string);
 }
+/**
+* Error thrown when a file or directory is not found at a specified path.
+* @example
+* ```javascript
+* import { NotFoundError } from "@visulima/fs/error";
+* import { readFile } from "@visulima/fs"; // Or any function that might throw this
+* import { join } from "node:path";
+*
+* const tryReadingNonExistentFile = async () => {
+*   const filePath = join("/tmp", "this-file-does-not-exist.txt");
+*   try {
+*     // Forcing the scenario for demonstration, as readFile itself would throw this.
+*     const simulateNotFound = (path) => {
+*        if (path === filePath) {
+*           throw new NotFoundError(`no such file or directory, open '${filePath}'`);
+*        }
+*     }
+*     simulateNotFound(filePath);
+*     // await readFile(filePath);
+*   } catch (error) {
+*     if (error instanceof NotFoundError) {
+*       console.error(`Operation failed, path not found: ${error.message}`);
+*       console.error(`Error code: ${error.code}`); // ENOENT
+*     } else {
+*       console.error("An unexpected error occurred:", error);
+*     }
+*   }
+* };
+*
+* tryReadingNonExistentFile();
+* ```
+*/
 declare class NotFoundError extends Error {
+  /**
+  * Creates a new instance.
+  * @param message
+  */
   constructor(message: string);
   get code(): string;
   set code(_name: string);
-  get name(): string;
-  set name(_name: string);
+  override get name(): string;
+  override set name(_name: string);
 }
+/**
+* Error thrown when an operation is not permitted due to insufficient privileges
+* or other access control restrictions.
+* @example
+* ```javascript
+* import { PermissionError } from "@visulima/fs/error";
+* import { writeFile } from "@visulima/fs"; // Or any function that might throw this
+* import { join } from "node:path";
+*
+* const tryWritingToProtectedFile = async () => {
+*   const filePath = join("/root", "protected-file.txt"); // A path that typically requires root privileges
+*   try {
+*     // Forcing the scenario for demonstration, as writeFile itself would throw this.
+*     const simulatePermissionError = (path) => {
+*        if (path === filePath) {
+*           throw new PermissionError(`open '${filePath}'`);
+*        }
+*     }
+*     simulatePermissionError(filePath);
+*     // await writeFile(filePath, "test content");
+*   } catch (error) {
+*     if (error instanceof PermissionError) {
+*       console.error(`Operation not permitted: ${error.message}`);
+*       console.error(`Error code: ${error.code}`); // EPERM
+*     } else {
+*       console.error("An unexpected error occurred:", error);
+*     }
+*   }
+* };
+*
+* tryWritingToProtectedFile();
+* ```
+*/
 declare class PermissionError extends Error {
+  /**
+  * Creates a new instance.
+  * @param message
+  */
   constructor(message: string);
   get code(): string;
   set code(_name: string);
-  get name(): string;
-  set name(_name: string);
+  override get name(): string;
+  override set name(_name: string);
 }
+/**
+* Error thrown in walk or walkSync during iteration.
+* @example
+* ```javascript
+* import { WalkError } from "@visulima/fs/error";
+* import { walk } from "@visulima/fs";
+* import { join } from "node:path";
+*
+* const processDirectory = async () => {
+*   const dirToWalk = join("/tmp", "non-existent-or-permission-denied-dir");
+*   try {
+*     // Forcing the scenario: walk might throw a WalkError if it encounters an issue
+*     // like a directory it cannot read during the walk process.
+*     const simulateWalkError = async (rootDir) => {
+*       // Let's say readdir inside walk fails for a subdirectory.
+*       const underlyingError = new Error("Permission denied reading subdirectory");
+*       throw new WalkError(underlyingError, rootDir);
+*     }
+*     // This is conceptual. In a real scenario, 'walk' itself would throw.
+*     // for await (const entry of walk(dirToWalk)) {
+*     //   console.log(entry.path);
+*     // }
+*     await simulateWalkError(dirToWalk);
+*   } catch (error) {
+*     if (error instanceof WalkError) {
+*       console.error(`Error during directory walk of "${error.root}": ${error.message}`);
+*       if (error.cause) {
+*         console.error(`Underlying cause: ${error.cause}`);
+*       }
+*     } else {
+*       console.error("An unexpected error occurred:", error);
+*     }
+*   }
+* };
+*
+* processDirectory();
+* ```
+*/
 declare class WalkError extends Error {
+  /** File path of the root that's being walked. */
   root: string;
+  /**
+  * Constructs a new instance.
+  * @param cause The underlying error or reason for the walk failure.
+  * @param root The root directory path where the walk operation started or encountered the error.
+  */
   constructor(cause: unknown, root: string);
-  get name(): string;
-  set name(_name: string);
+  override get name(): string;
+  override set name(_name: string);
 }
 export { AlreadyExistsError, DirectoryError, NotEmptyError, NotFoundError, PermissionError, WalkError };

package/dist/error.js

@@ -1,7 +1 @@
-export { default as AlreadyExistsError } from './packem_shared/AlreadyExistsError-6Y9hjgMn.js';
-export { default as DirectoryError } from './packem_shared/DirectoryError-BfYPkIYP.js';
-export { default as JSONError } from './packem_shared/JSONError-BkHRnInH.js';
-export { default as NotEmptyError } from './packem_shared/NotEmptyError-B21RUlVr.js';
-export { default as NotFoundError } from './packem_shared/NotFoundError-BIp61X6k.js';
-export { default as PermissionError } from './packem_shared/PermissionError-CjoiJgip.js';
-export { default as WalkError } from './packem_shared/WalkError-DER5A43G.js';
+import{default as t}from"./packem_shared/AlreadyExistsError-CEu6_Tjb.js";import{default as a}from"./packem_shared/DirectoryError-ddlbUV8C.js";import{default as s}from"./packem_shared/JSONError-D7h6PNWc.js";import{default as l}from"./packem_shared/NotEmptyError-DMh1o7UL.js";import{default as E}from"./packem_shared/NotFoundError-BPiW0icm.js";import{default as u}from"./packem_shared/PermissionError-B1Emi5a9.js";import{default as i}from"./packem_shared/WalkError-Olmh4908.js";export{t as AlreadyExistsError,a as DirectoryError,s as JSONError,l as NotEmptyError,E as NotFoundError,u as PermissionError,i as WalkError};

package/dist/glob-parent.d.ts

@@ -1,5 +1,35 @@
+/**
+* Options accepted by {@link globParent}.
+*/
 interface GlobParentOptions {
+  /**
+  * On Windows, flip backslashes to forward slashes before analysing the pattern.
+  *
+  * Disable when the input contains backslash escape sequences you want to preserve.
+  * @default true
+  */
   flipBackslashes?: boolean;
 }
+/**
+* Extracts the non-glob parent directory from a glob pattern.
+*
+* Useful when you need to know which directory to watch or walk for a given pattern — for example
+* `src/**\/*.ts` → `src`, `foo/{a,b}/*.js` → `foo`. Patterns without glob characters are returned
+* unchanged.
+*
+* Powered by [`glob-parent`](https://github.com/gulpjs/glob-parent) which is bundled into the built output so
+* it does not appear as a runtime dependency of `@visulima/fs`.
+* @param pattern The glob pattern to inspect.
+* @param options Optional configuration. See {@link GlobParentOptions}.
+* @returns The static parent path of the glob.
+* @example
+* ```javascript
+* import { globParent } from "@visulima/fs";
+*
+* globParent("src/**\/*.ts"); // "src"
+* globParent("foo/{a,b}/*.js"); // "foo"
+* globParent("foo/bar.js"); // "foo/bar.js"
+* ```
+*/
 declare const globParent: (pattern: string, options?: GlobParentOptions) => string;
 export { type GlobParentOptions, globParent as default };

package/dist/glob-parent.js

@@ -1,90 +1 @@
-import { createRequire as __cjs_createRequire } from "node:module";
-
-const __cjs_require = __cjs_createRequire(import.meta.url);
-
-const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
-
-const __cjs_getBuiltinModule = (module) => {
-    // Check if we're in Node.js and version supports getBuiltinModule
-    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
-        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
-        // Node.js 20.16.0+ and 22.3.0+
-        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
-            return __cjs_getProcess.getBuiltinModule(module);
-        }
-    }
-    // Fallback to createRequire
-    return __cjs_require(module);
-};
-
-import { g as getDefaultExportFromCjs } from './packem_shared/_commonjsHelpers-BqLXS_qQ.js';
-import { r as requireIsGlob } from './packem_shared/index-bhgnhm4u.js';
-const require$$1 = __cjs_getBuiltinModule("path");
-const require$$2 = __cjs_getBuiltinModule("os");
-
-var globParent$1;
-var hasRequiredGlobParent;
-
-function requireGlobParent () {
-	if (hasRequiredGlobParent) return globParent$1;
-	hasRequiredGlobParent = 1;
-	var isGlob = requireIsGlob();
-	var pathPosixDirname = require$$1.posix.dirname;
-	var isWin32 = require$$2.platform() === "win32";
-	var slash = "/";
-	var backslash = /\\/g;
-	var escaped = /\\([!*?|[\](){}])/g;
-	globParent$1 = function globParent(str, opts) {
-	  var options = Object.assign({ flipBackslashes: true }, opts);
-	  if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {
-	    str = str.replace(backslash, slash);
-	  }
-	  if (isEnclosure(str)) {
-	    str += slash;
-	  }
-	  str += "a";
-	  do {
-	    str = pathPosixDirname(str);
-	  } while (isGlobby(str));
-	  return str.replace(escaped, "$1");
-	};
-	function isEnclosure(str) {
-	  var lastChar = str.slice(-1);
-	  var enclosureStart;
-	  switch (lastChar) {
-	    case "}":
-	      enclosureStart = "{";
-	      break;
-	    case "]":
-	      enclosureStart = "[";
-	      break;
-	    default:
-	      return false;
-	  }
-	  var foundIndex = str.indexOf(enclosureStart);
-	  if (foundIndex < 0) {
-	    return false;
-	  }
-	  return str.slice(foundIndex + 1, -1).includes(slash);
-	}
-	function isGlobby(str) {
-	  if (/\([^()]+$/.test(str)) {
-	    return true;
-	  }
-	  if (str[0] === "{" || str[0] === "[") {
-	    return true;
-	  }
-	  if (/[^\\][{[]/.test(str)) {
-	    return true;
-	  }
-	  return isGlob(str);
-	}
-	return globParent$1;
-}
-
-var globParentExports = requireGlobParent();
-const globParentImpl = /*@__PURE__*/getDefaultExportFromCjs(globParentExports);
-
-const globParent = (pattern, options) => globParentImpl(pattern, options);
-
-export { globParent as default };
+var _=Object.defineProperty;var t=(s,r)=>_(s,"name",{value:r,configurable:!0});import{createRequire as P}from"node:module";import{g as q}from"./packem_shared/_commonjsHelpers-D6W6KoPK.js";import{r as x}from"./packem_shared/index-K-NNTkpb.js";const j=P(import.meta.url),i=typeof globalThis<"u"&&typeof globalThis.process<"u"?globalThis.process:process,d=t(s=>{if(typeof i<"u"&&i.versions&&i.versions.node){const[r,a]=i.versions.node.split(".").map(Number);if(r>22||r===22&&a>=3||r===20&&a>=16)return i.getBuiltinModule(s)}return j(s)},"__cjs_getBuiltinModule"),y=d("path"),G=d("os");var u,b;function $(){if(b)return u;b=1;var s=Object.defineProperty,r=t((e,n)=>s(e,"name",{value:n,configurable:!0}),"n"),a=x(),g=y.posix.dirname,m=G.platform()==="win32",l="/",v=/\\/g,h=/\\([!*?|[\](){}])/g;u=r(function(e,n){var o=Object.assign({flipBackslashes:!0},n);o.flipBackslashes&&m&&e.indexOf(l)<0&&(e=e.replace(v,l)),c(e)&&(e+=l),e+="a";do e=g(e);while(f(e));return e.replace(h,"$1")},"globParent");function c(e){var n=e.slice(-1),o;switch(n){case"}":o="{";break;case"]":o="[";break;default:return!1}var p=e.indexOf(o);return p<0?!1:e.slice(p+1,-1).includes(l)}t(c,"isEnclosure"),r(c,"isEnclosure");function f(e){return/\([^()]+$/.test(e)||e[0]==="{"||e[0]==="["||/[^\\][{[]/.test(e)?!0:a(e)}return t(f,"isGlobby"),r(f,"isGlobby"),u}t($,"requireGlobParent");var k=$();const O=q(k);var B=Object.defineProperty,E=t((s,r)=>B(s,"name",{value:r,configurable:!0}),"e");const M=E((s,r)=>O(s,r),"globParent");export{M as default};

package/dist/glob.d.ts

@@ -1,5 +1,4 @@
-export { g as glob, a as globSync } from "./packem_shared/glob-sync.d-BlGjS68e.js";
-export { type G as GlobOptions } from "./packem_shared/types.d-CYpAhWov.js";
+export { g as glob, a as globSync } from "./packem_shared/glob-sync.d-p6lOZXnE.js";
+export { type G as GlobOptions } from "./packem_shared/types.d-BsmmADqx.js";
 import 'node:fs';
 import 'tinyglobby';
-import './options';

package/dist/glob.js

@@ -1,2 +1 @@
-export { default as glob } from './packem_shared/glob-DY8l7izD.js';
-export { default as globSync } from './packem_shared/globSync-5P2KJf_g.js';
+import{default as e}from"./packem_shared/glob-MHJQjR39.js";import{default as l}from"./packem_shared/globSync-CwzlELgS.js";export{e as glob,l as globSync};