@dbx-tools/path 0.9.118 → 0.9.120

package/README.md

@@ -12,14 +12,17 @@ and documentation tooling.
 ```ts
 import { find, ignore } from "@dbx-tools/path";
 
-const files = find
-  .findFiles(["packages/**/src/**/*.ts"], {
-    ignore: ignore.ignorePatterns(),
-  })
-  .toArray();
+for await (const file of find.findFiles(["packages/**/src/**/*.ts"], {
+  ignore: ignore.ignorePatterns(),
+})) {
+  await processFile(file);
+}
+
+const files = find.findFilesSync(["packages/**/src/**/*.ts"]).toArray();
 ```
 
-`find.findFiles()` returns a lazy `Sequence<string>` from
+`find.findFiles()` streams matches asynchronously. `find.findFilesSync()`
+returns a lazy `Sequence<string>` from
 [`@dbx-tools/shared-core`](../../shared/core), so callers can map/filter without
 materializing immediately.
 
@@ -81,7 +84,7 @@ like synthesis does.
 ```ts
 import { watch } from "@dbx-tools/path";
 
-const watcher = watch.watchFiles(["packages/**/src/**/*.ts"], {
+const watcher = await watch.watchFiles(["packages/**/src/**/*.ts"], {
   ignoreInitial: true,
 });
 

package/index.ts

@@ -3,14 +3,17 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/path";
-export const PACKAGE_VERSION = "0.9.118";
+export const PACKAGE_VERSION = "0.9.120";
 export * as find from "./src/find.ts";
+export * as gitIgnore from "./src/git-ignore.ts";
 export * as ignore from "./src/ignore.ts";
 export * as match from "./src/match.ts";
 export * as pattern from "./src/pattern.ts";
 export * as scan from "./src/scan.ts";
 export * as watch from "./src/watch.ts";
 export type { FileFindOptions } from "./src/find.ts";
+export { GitIgnore } from "./src/git-ignore.ts";
+export type { GitIgnoreLoadOptions } from "./src/git-ignore.ts";
 export type { IgnorePatternOptions } from "./src/ignore.ts";
 export type { PathMatchPredicate, PathMatcher, PathMatchInput } from "./src/match.ts";
 export { FOLLOW_SYMLINKS_DEFAULT } from "./src/scan.ts";

package/lib/index.d.ts

@@ -1,12 +1,15 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/path";
-export declare const PACKAGE_VERSION = "0.9.118";
+export declare const PACKAGE_VERSION = "0.9.120";
 export * as find from "./src/find.ts";
+export * as gitIgnore from "./src/git-ignore.ts";
 export * as ignore from "./src/ignore.ts";
 export * as match from "./src/match.ts";
 export * as pattern from "./src/pattern.ts";
 export * as scan from "./src/scan.ts";
 export * as watch from "./src/watch.ts";
 export type { FileFindOptions } from "./src/find.ts";
+export { GitIgnore } from "./src/git-ignore.ts";
+export type { GitIgnoreLoadOptions } from "./src/git-ignore.ts";
 export type { IgnorePatternOptions } from "./src/ignore.ts";
 export type { PathMatchPredicate, PathMatcher, PathMatchInput } from "./src/match.ts";
 export { FOLLOW_SYMLINKS_DEFAULT } from "./src/scan.ts";

package/lib/index.js

@@ -2,12 +2,14 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/path";
-export const PACKAGE_VERSION = "0.9.118";
+export const PACKAGE_VERSION = "0.9.120";
 export * as find from "./src/find.js";
+export * as gitIgnore from "./src/git-ignore.js";
 export * as ignore from "./src/ignore.js";
 export * as match from "./src/match.js";
 export * as pattern from "./src/pattern.js";
 export * as scan from "./src/scan.js";
 export * as watch from "./src/watch.js";
+export { GitIgnore } from "./src/git-ignore.js";
 export { FOLLOW_SYMLINKS_DEFAULT } from "./src/scan.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxpQkFBaUIsQ0FBQztBQUNwRCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsU0FBUyxDQUFDO0FBQ3pDLE9BQU8sS0FBSyxJQUFJLE1BQU0sZUFBZSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxNQUFNLE1BQU0saUJBQWlCLENBQUM7QUFDMUMsT0FBTyxLQUFLLEtBQUssTUFBTSxnQkFBZ0IsQ0FBQztBQUN4QyxPQUFPLEtBQUssT0FBTyxNQUFNLGtCQUFrQixDQUFDO0FBQzVDLE9BQU8sS0FBSyxJQUFJLE1BQU0sZUFBZSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxLQUFLLE1BQU0sZ0JBQWdCLENBQUM7QUFJeEMsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sZUFBZSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR0VORVJBVEVEIGJ5IHByb2plbiB3YXRjaCAtIERPIE5PVCBFRElULlxuLy8gUmVnZW5lcmF0ZWQgZnJvbSB0aGUgZXhwb3J0aW5nIG1vZHVsZXMgaW4gLi9zcmMuXG4vLyBIYW5kIGVkaXRzIGFyZSBvdmVyd3JpdHRlbiBvbiB0aGUgbmV4dCB3YXRjaDsgdGhpcyBmaWxlIGlzIHJlYWQtb25seS5cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfSURFTlRJRklFUiA9IFwiQGRieC10b29scy9wYXRoXCI7XG5leHBvcnQgY29uc3QgUEFDS0FHRV9WRVJTSU9OID0gXCIwLjkuMTE4XCI7XG5leHBvcnQgKiBhcyBmaW5kIGZyb20gXCIuL3NyYy9maW5kLnRzXCI7XG5leHBvcnQgKiBhcyBpZ25vcmUgZnJvbSBcIi4vc3JjL2lnbm9yZS50c1wiO1xuZXhwb3J0ICogYXMgbWF0Y2ggZnJvbSBcIi4vc3JjL21hdGNoLnRzXCI7XG5leHBvcnQgKiBhcyBwYXR0ZXJuIGZyb20gXCIuL3NyYy9wYXR0ZXJuLnRzXCI7XG5leHBvcnQgKiBhcyBzY2FuIGZyb20gXCIuL3NyYy9zY2FuLnRzXCI7XG5leHBvcnQgKiBhcyB3YXRjaCBmcm9tIFwiLi9zcmMvd2F0Y2gudHNcIjtcbmV4cG9ydCB0eXBlIHsgRmlsZUZpbmRPcHRpb25zIH0gZnJvbSBcIi4vc3JjL2ZpbmQudHNcIjtcbmV4cG9ydCB0eXBlIHsgSWdub3JlUGF0dGVybk9wdGlvbnMgfSBmcm9tIFwiLi9zcmMvaWdub3JlLnRzXCI7XG5leHBvcnQgdHlwZSB7IFBhdGhNYXRjaFByZWRpY2F0ZSwgUGF0aE1hdGNoZXIsIFBhdGhNYXRjaElucHV0IH0gZnJvbSBcIi4vc3JjL21hdGNoLnRzXCI7XG5leHBvcnQgeyBGT0xMT1dfU1lNTElOS1NfREVGQVVMVCB9IGZyb20gXCIuL3NyYy9zY2FuLnRzXCI7XG5leHBvcnQgdHlwZSB7IEZpbGVTY2FuT3B0aW9ucywgRmlsZVNjYW5JZ25vcmVPcHRpb25zIH0gZnJvbSBcIi4vc3JjL3NjYW4udHNcIjtcbmV4cG9ydCB0eXBlIHsgRmlsZVdhdGNoT3B0aW9ucyB9IGZyb20gXCIuL3NyYy93YXRjaC50c1wiO1xuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/find.d.ts

@@ -1,9 +1,10 @@
 /**
  * Repository-consistent file discovery over `glob`.
  *
- * Reuse {@link findFiles} when package discovery, generation, cleanup, or docs
- * tooling must honor the same ignore catalogue and symlink defaults as watchers.
- * Direct `glob` calls should be reserved for behavior that intentionally differs.
+ * Reuse {@link findFiles} or {@link findFilesSync} when package discovery,
+ * generation, cleanup, or docs tooling must honor the same ignore catalogue and
+ * symlink defaults as watchers. Direct `glob` calls should be reserved for
+ * behavior that intentionally differs.
  *
  * @module
  */
@@ -12,7 +13,7 @@ import { IgnoreLike, type GlobOptionsWithFileTypesUnset } from "glob";
 import { PathMatchInput } from "./match.ts";
 import { FileScanOptions } from "./scan.ts";
 type FileFindIgnore = PathMatchInput | readonly PathMatchInput[] | IgnoreLike;
-/** Glob, root, ignore, and symlink options for {@link findFiles}. */
+/** Glob, root, ignore, and symlink options for {@link findFiles} and {@link findFilesSync}. */
 export interface FileFindOptions extends Omit<GlobOptionsWithFileTypesUnset, "ignore" | "follow" | "dot" | "cwd" | "includeChildMatches">, Omit<FileScanOptions, "ignore" | "cwd"> {
     cwd?: string | URL;
     ignore?: FileFindIgnore;
@@ -23,5 +24,7 @@ export interface FileFindOptions extends Omit<GlobOptionsWithFileTypesUnset, "ig
  * in which case only that predicate applies). The ignore list mirrors what
  * {@link watchFiles} feeds through its matchers.
  */
-export declare function findFiles(pattern: string | string[], options?: FileFindOptions): Sequence<string>;
+export declare function findFiles(pattern: string | string[], options?: FileFindOptions): AsyncGenerator<string>;
+/** Synchronous counterpart to {@link findFiles}. */
+export declare function findFilesSync(pattern: string | string[], options?: FileFindOptions): Sequence<string>;
 export {};

package/lib/src/find.js

@@ -1,14 +1,16 @@
 /**
  * Repository-consistent file discovery over `glob`.
  *
- * Reuse {@link findFiles} when package discovery, generation, cleanup, or docs
- * tooling must honor the same ignore catalogue and symlink defaults as watchers.
- * Direct `glob` calls should be reserved for behavior that intentionally differs.
+ * Reuse {@link findFiles} or {@link findFilesSync} when package discovery,
+ * generation, cleanup, or docs tooling must honor the same ignore catalogue and
+ * symlink defaults as watchers. Direct `glob` calls should be reserved for
+ * behavior that intentionally differs.
  *
  * @module
  */
 import { object } from "@dbx-tools/shared-core";
-import { globIterateSync } from "glob";
+import { globIterate, globIterateSync, } from "glob";
+import { GitIgnore } from "./git-ignore.js";
 import { ignorePathMatcher } from "./ignore.js";
 import { pathMatchTests, toPathMatcher } from "./match.js";
 import { FOLLOW_SYMLINKS_DEFAULT } from "./scan.js";
@@ -18,16 +20,36 @@ import { FOLLOW_SYMLINKS_DEFAULT } from "./scan.js";
  * in which case only that predicate applies). The ignore list mirrors what
  * {@link watchFiles} feeds through its matchers.
  */
-export function findFiles(pattern, options) {
-    return object.sequence(globIterateSync(pattern, toGlobOptions(options)));
+export async function* findFiles(pattern, options) {
+    yield* globIterate(pattern, await toGlobOptions(options));
 }
-function toGlobOptions(options) {
+/** Synchronous counterpart to {@link findFiles}. */
+export function findFilesSync(pattern, options) {
+    return object.sequence(globIterateSync(pattern, toGlobOptionsSync(options)));
+}
+async function toGlobOptions(options) {
+    const { cwd, ignoreOptions, followSymlinks } = options ?? {};
+    const root = cwd ?? process.cwd();
+    const gitIgnore = ignoreOptions?.git
+        ? await GitIgnore.load(root, { ignoreOptions, followSymlinks })
+        : undefined;
+    return buildGlobOptions(options, gitIgnore);
+}
+function toGlobOptionsSync(options) {
+    const { cwd, ignoreOptions, followSymlinks } = options ?? {};
+    const root = cwd ?? process.cwd();
+    const gitIgnore = ignoreOptions?.git
+        ? GitIgnore.loadSync(root, { ignoreOptions, followSymlinks })
+        : undefined;
+    return buildGlobOptions(options, gitIgnore);
+}
+function buildGlobOptions(options, gitIgnore) {
     const { cwd, ignore, ignoreOptions, followSymlinks, ...restOptions } = options ?? {};
     return {
         ...restOptions,
         cwd: cwd ?? process.cwd(),
         follow: followSymlinks ?? FOLLOW_SYMLINKS_DEFAULT,
-        ignore: normalizeIgnore(ignore, ignoreOptions),
+        ignore: normalizeIgnore(ignore, ignoreOptions, gitIgnore),
     };
 }
 const IGNORE_LIKE_FIELDS = [
@@ -49,7 +71,7 @@ function isIgnoreLike(value) {
     return false;
 }
 /**
- * Builds the {@link IgnoreLike} object {@link findFiles} hands to `glob`.
+ * Builds the {@link IgnoreLike} object file discovery hands to `glob`.
  *
  * A caller-supplied `IgnoreLike` (an object, not string/array) is consulted
  * first - its `ignored`/`childrenIgnored` win - after which the shared
@@ -58,7 +80,7 @@ function isIgnoreLike(value) {
  * many paths per directory. Caller string/array patterns are merged into the
  * matcher, and `add` forwards to both the caller object and the matcher.
  */
-function normalizeIgnore(ignore, ignoreOptions) {
+function normalizeIgnore(ignore, ignoreOptions, gitIgnore) {
     const ignoreLike = isIgnoreLike(ignore) ? ignore : undefined;
     const ignorePathMatcherInputs = ignore === undefined || ignoreLike ? undefined : Array.isArray(ignore) ? [...ignore] : [ignore];
     const predicateOnly = ignorePathMatcherInputs?.length === 1 && typeof ignorePathMatcherInputs[0] === "function";
@@ -73,6 +95,8 @@ function normalizeIgnore(ignore, ignoreOptions) {
             if (ignoreLike?.ignored?.(path))
                 return true;
             const patheRelative = path.relative();
+            if (gitIgnore?.ignores(patheRelative, path.isDirectory()))
+                return true;
             const ignore = ignoreMatcher(patheRelative);
             return ignore;
         },
@@ -81,6 +105,8 @@ function normalizeIgnore(ignore, ignoreOptions) {
                 return true;
             const patheRelative = path.relative();
             if (patheRelative) {
+                if (gitIgnore?.ignores(patheRelative, true))
+                    return true;
                 if (ignoreMatcher(patheRelative)) {
                     return true;
                 }
@@ -108,10 +134,10 @@ if (import.meta.main) {
             test: true,
         },
     });
-    for (const file of files) {
+    for await (const file of files) {
         console.log(file);
     }
     const elapsed = performance.now() - startTime;
     console.log(`Elapsed: ${elapsed}ms`);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"find.js","sourceRoot":"","sources":["../../src/find.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Repository-consistent file discovery over `glob`.\n *\n * Reuse {@link findFiles} when package discovery, generation, cleanup, or docs\n * tooling must honor the same ignore catalogue and symlink defaults as watchers.\n * Direct `glob` calls should be reserved for behavior that intentionally differs.\n *\n * @module\n */\n\nimport { object, type Sequence } from \"@dbx-tools/shared-core\";\nimport { globIterateSync, IgnoreLike, type GlobOptionsWithFileTypesUnset } from \"glob\";\nimport { ignorePathMatcher } from \"./ignore.ts\";\nimport { PathMatcher, PathMatchInput, pathMatchTests, toPathMatcher } from \"./match.ts\";\nimport { FileScanIgnoreOptions, FileScanOptions, FOLLOW_SYMLINKS_DEFAULT } from \"./scan.ts\";\n\ntype FileFindIgnore = PathMatchInput | readonly PathMatchInput[] | IgnoreLike;\n\n/** Glob, root, ignore, and symlink options for {@link findFiles}. */\nexport interface FileFindOptions\n  extends\n    Omit<\n      GlobOptionsWithFileTypesUnset,\n      \"ignore\" | \"follow\" | \"dot\" | \"cwd\" | \"includeChildMatches\"\n    >,\n    Omit<FileScanOptions, \"ignore\" | \"cwd\"> {\n  cwd?: string | URL;\n  ignore?: FileFindIgnore;\n}\n/**\n * Recursively lists files matching `pattern`, ignoring the shared default groups\n * plus any caller `ignore` patterns (unless `ignore` is a lone predicate function,\n * in which case only that predicate applies). The ignore list mirrors what\n * {@link watchFiles} feeds through its matchers.\n */\nexport function findFiles(pattern: string | string[], options?: FileFindOptions): Sequence<string> {\n  return object.sequence(globIterateSync(pattern, toGlobOptions(options)));\n}\n\nfunction toGlobOptions(options: FileFindOptions | undefined): GlobOptionsWithFileTypesUnset {\n  const { cwd, ignore, ignoreOptions, followSymlinks, ...restOptions } = options ?? {};\n  return {\n    ...restOptions,\n    cwd: cwd ?? process.cwd(),\n    follow: followSymlinks ?? FOLLOW_SYMLINKS_DEFAULT,\n    ignore: normalizeIgnore(ignore, ignoreOptions),\n  };\n}\n\nconst IGNORE_LIKE_FIELDS = [\n  \"ignored\",\n  \"childrenIgnored\",\n  \"add\",\n] as const satisfies readonly (keyof IgnoreLike)[];\n\nfunction isIgnoreLike(value: unknown): value is IgnoreLike {\n  if (Array.isArray(value)) return false;\n  if (typeof value === \"object\" && value !== null) {\n    for (const field of IGNORE_LIKE_FIELDS) {\n      if (field in value && typeof (value as any)[field] !== \"function\") {\n        return false;\n      }\n    }\n    return true;\n  }\n  return false;\n}\n/**\n * Builds the {@link IgnoreLike} object {@link findFiles} hands to `glob`.\n *\n * A caller-supplied `IgnoreLike` (an object, not string/array) is consulted\n * first - its `ignored`/`childrenIgnored` win - after which the shared\n * {@link ignorePathMatcher} (the same matcher {@link watchFiles} uses) decides based on the\n * package-relative path. `cacheDirectoryStats` is enabled because glob probes\n * many paths per directory. Caller string/array patterns are merged into the\n * matcher, and `add` forwards to both the caller object and the matcher.\n */\nfunction normalizeIgnore(\n  ignore: FileFindIgnore | undefined,\n  ignoreOptions: FileScanIgnoreOptions | undefined,\n): IgnoreLike {\n  const ignoreLike: IgnoreLike | undefined = isIgnoreLike(ignore) ? ignore : undefined;\n  const ignorePathMatcherInputs: PathMatchInput[] | undefined =\n    ignore === undefined || ignoreLike ? undefined : Array.isArray(ignore) ? [...ignore] : [ignore];\n\n  const predicateOnly =\n    ignorePathMatcherInputs?.length === 1 && typeof ignorePathMatcherInputs[0] === \"function\";\n\n  let ignoreMatcher: PathMatcher = predicateOnly\n    ? toPathMatcher(ignorePathMatcherInputs[0])\n    : ignorePathMatcher(ignoreOptions);\n  if (ignorePathMatcherInputs && !predicateOnly) {\n    ignoreMatcher = ignoreMatcher.or(...pathMatchTests(...ignorePathMatcherInputs));\n  }\n  return {\n    ignored(path) {\n      if (ignoreLike?.ignored?.(path)) return true;\n      const patheRelative = path.relative();\n      const ignore = ignoreMatcher(patheRelative);\n      return ignore;\n    },\n    childrenIgnored(path) {\n      if (ignoreLike?.childrenIgnored?.(path)) return true;\n      const patheRelative = path.relative();\n      if (patheRelative) {\n        if (ignoreMatcher(patheRelative)) {\n          return true;\n        } else if (ignoreMatcher(patheRelative + \"/\")) {\n          return true;\n        }\n      }\n      return false;\n    },\n    add(ignore) {\n      ignoreLike?.add?.(ignore);\n      ignoreMatcher = ignoreMatcher.or(...pathMatchTests(ignore));\n    },\n  };\n}\n\n// Manual demo: run this file directly (`bun src/find.ts`) to print the\n// files findFiles keeps for this package under the given ignore options.\nif (import.meta.main) {\n  const startTime = performance.now();\n  const cwd = process.cwd();\n  console.log(`Scanning: ${cwd}`);\n\n  const files = findFiles(\"**/*.*\", {\n    ignore: [\"**/index.ts\", \"**/example/**\", \"**/*.md\"],\n    ignoreOptions: {\n      test: true,\n    },\n  });\n  for (const file of files) {\n    console.log(file);\n  }\n  const elapsed = performance.now() - startTime;\n  console.log(`Elapsed: ${elapsed}ms`);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"find.js","sourceRoot":"","sources":["../../src/find.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Repository-consistent file discovery over `glob`.\n *\n * Reuse {@link findFiles} or {@link findFilesSync} when package discovery,\n * generation, cleanup, or docs tooling must honor the same ignore catalogue and\n * symlink defaults as watchers. Direct `glob` calls should be reserved for\n * behavior that intentionally differs.\n *\n * @module\n */\n\nimport { object, type Sequence } from \"@dbx-tools/shared-core\";\nimport {\n  globIterate,\n  globIterateSync,\n  IgnoreLike,\n  type GlobOptionsWithFileTypesUnset,\n} from \"glob\";\nimport { GitIgnore } from \"./git-ignore.ts\";\nimport { ignorePathMatcher } from \"./ignore.ts\";\nimport { PathMatcher, PathMatchInput, pathMatchTests, toPathMatcher } from \"./match.ts\";\nimport { FileScanIgnoreOptions, FileScanOptions, FOLLOW_SYMLINKS_DEFAULT } from \"./scan.ts\";\n\ntype FileFindIgnore = PathMatchInput | readonly PathMatchInput[] | IgnoreLike;\n\n/** Glob, root, ignore, and symlink options for {@link findFiles} and {@link findFilesSync}. */\nexport interface FileFindOptions\n  extends\n    Omit<\n      GlobOptionsWithFileTypesUnset,\n      \"ignore\" | \"follow\" | \"dot\" | \"cwd\" | \"includeChildMatches\"\n    >,\n    Omit<FileScanOptions, \"ignore\" | \"cwd\"> {\n  cwd?: string | URL;\n  ignore?: FileFindIgnore;\n}\n/**\n * Recursively lists files matching `pattern`, ignoring the shared default groups\n * plus any caller `ignore` patterns (unless `ignore` is a lone predicate function,\n * in which case only that predicate applies). The ignore list mirrors what\n * {@link watchFiles} feeds through its matchers.\n */\nexport async function* findFiles(\n  pattern: string | string[],\n  options?: FileFindOptions,\n): AsyncGenerator<string> {\n  yield* globIterate(pattern, await toGlobOptions(options));\n}\n\n/** Synchronous counterpart to {@link findFiles}. */\nexport function findFilesSync(\n  pattern: string | string[],\n  options?: FileFindOptions,\n): Sequence<string> {\n  return object.sequence(globIterateSync(pattern, toGlobOptionsSync(options)));\n}\n\nasync function toGlobOptions(\n  options: FileFindOptions | undefined,\n): Promise<GlobOptionsWithFileTypesUnset> {\n  const { cwd, ignoreOptions, followSymlinks } = options ?? {};\n  const root = cwd ?? process.cwd();\n  const gitIgnore = ignoreOptions?.git\n    ? await GitIgnore.load(root, { ignoreOptions, followSymlinks })\n    : undefined;\n  return buildGlobOptions(options, gitIgnore);\n}\n\nfunction toGlobOptionsSync(options: FileFindOptions | undefined): GlobOptionsWithFileTypesUnset {\n  const { cwd, ignoreOptions, followSymlinks } = options ?? {};\n  const root = cwd ?? process.cwd();\n  const gitIgnore = ignoreOptions?.git\n    ? GitIgnore.loadSync(root, { ignoreOptions, followSymlinks })\n    : undefined;\n  return buildGlobOptions(options, gitIgnore);\n}\n\nfunction buildGlobOptions(\n  options: FileFindOptions | undefined,\n  gitIgnore: GitIgnore | undefined,\n): GlobOptionsWithFileTypesUnset {\n  const { cwd, ignore, ignoreOptions, followSymlinks, ...restOptions } = options ?? {};\n  return {\n    ...restOptions,\n    cwd: cwd ?? process.cwd(),\n    follow: followSymlinks ?? FOLLOW_SYMLINKS_DEFAULT,\n    ignore: normalizeIgnore(ignore, ignoreOptions, gitIgnore),\n  };\n}\n\nconst IGNORE_LIKE_FIELDS = [\n  \"ignored\",\n  \"childrenIgnored\",\n  \"add\",\n] as const satisfies readonly (keyof IgnoreLike)[];\n\nfunction isIgnoreLike(value: unknown): value is IgnoreLike {\n  if (Array.isArray(value)) return false;\n  if (typeof value === \"object\" && value !== null) {\n    for (const field of IGNORE_LIKE_FIELDS) {\n      if (field in value && typeof (value as any)[field] !== \"function\") {\n        return false;\n      }\n    }\n    return true;\n  }\n  return false;\n}\n/**\n * Builds the {@link IgnoreLike} object file discovery hands to `glob`.\n *\n * A caller-supplied `IgnoreLike` (an object, not string/array) is consulted\n * first - its `ignored`/`childrenIgnored` win - after which the shared\n * {@link ignorePathMatcher} (the same matcher {@link watchFiles} uses) decides based on the\n * package-relative path. `cacheDirectoryStats` is enabled because glob probes\n * many paths per directory. Caller string/array patterns are merged into the\n * matcher, and `add` forwards to both the caller object and the matcher.\n */\nfunction normalizeIgnore(\n  ignore: FileFindIgnore | undefined,\n  ignoreOptions: FileScanIgnoreOptions | undefined,\n  gitIgnore: GitIgnore | undefined,\n): IgnoreLike {\n  const ignoreLike: IgnoreLike | undefined = isIgnoreLike(ignore) ? ignore : undefined;\n  const ignorePathMatcherInputs: PathMatchInput[] | undefined =\n    ignore === undefined || ignoreLike ? undefined : Array.isArray(ignore) ? [...ignore] : [ignore];\n\n  const predicateOnly =\n    ignorePathMatcherInputs?.length === 1 && typeof ignorePathMatcherInputs[0] === \"function\";\n\n  let ignoreMatcher: PathMatcher = predicateOnly\n    ? toPathMatcher(ignorePathMatcherInputs[0])\n    : ignorePathMatcher(ignoreOptions);\n  if (ignorePathMatcherInputs && !predicateOnly) {\n    ignoreMatcher = ignoreMatcher.or(...pathMatchTests(...ignorePathMatcherInputs));\n  }\n  return {\n    ignored(path) {\n      if (ignoreLike?.ignored?.(path)) return true;\n      const patheRelative = path.relative();\n      if (gitIgnore?.ignores(patheRelative, path.isDirectory())) return true;\n      const ignore = ignoreMatcher(patheRelative);\n      return ignore;\n    },\n    childrenIgnored(path) {\n      if (ignoreLike?.childrenIgnored?.(path)) return true;\n      const patheRelative = path.relative();\n      if (patheRelative) {\n        if (gitIgnore?.ignores(patheRelative, true)) return true;\n        if (ignoreMatcher(patheRelative)) {\n          return true;\n        } else if (ignoreMatcher(patheRelative + \"/\")) {\n          return true;\n        }\n      }\n      return false;\n    },\n    add(ignore) {\n      ignoreLike?.add?.(ignore);\n      ignoreMatcher = ignoreMatcher.or(...pathMatchTests(ignore));\n    },\n  };\n}\n\n// Manual demo: run this file directly (`bun src/find.ts`) to print the\n// files findFiles keeps for this package under the given ignore options.\nif (import.meta.main) {\n  const startTime = performance.now();\n  const cwd = process.cwd();\n  console.log(`Scanning: ${cwd}`);\n\n  const files = findFiles(\"**/*.*\", {\n    ignore: [\"**/index.ts\", \"**/example/**\", \"**/*.md\"],\n    ignoreOptions: {\n      test: true,\n    },\n  });\n  for await (const file of files) {\n    console.log(file);\n  }\n  const elapsed = performance.now() - startTime;\n  console.log(`Elapsed: ${elapsed}ms`);\n}\n"]}

package/lib/src/git-ignore.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Mutable, Git-compatible `.gitignore` path matching.
+ *
+ * Rule syntax is owned by the `ignore` package, whose compatibility suite
+ * compares behavior with `git check-ignore`. This module adds repository and
+ * nested-file scoping plus in-memory add, update, and removal.
+ *
+ * @module
+ */
+import type { IgnorePatternOptions } from "./ignore.ts";
+import { type PathMatcher } from "./match.ts";
+/** Options used while discovering `.gitignore` files beneath a root. */
+export interface GitIgnoreLoadOptions {
+    /** Built-in directory groups pruned while looking for ignore files. */
+    ignoreOptions?: IgnorePatternOptions;
+    /** Follow symlinked directories during discovery. Defaults to false. */
+    followSymlinks?: boolean;
+}
+/** Mutable path predicate composed from root and nested `.gitignore` files. */
+export declare class GitIgnore {
+    readonly root: string;
+    /** Stable composable matcher that observes later {@link set}, {@link delete}, and {@link clear} calls. */
+    readonly matcher: PathMatcher;
+    private readonly files;
+    private rules;
+    constructor(root: string | URL);
+    /** Load every applicable `.gitignore` beneath {@link root}. */
+    static load(root: string | URL, options?: GitIgnoreLoadOptions): Promise<GitIgnore>;
+    /** Synchronous counterpart to {@link GitIgnore.load}. */
+    static loadSync(root: string | URL, options?: GitIgnoreLoadOptions): GitIgnore;
+    /** Whether `path` names a `.gitignore` control file. */
+    static isFile(path: string): boolean;
+    /** Add or replace one `.gitignore` file and its in-memory content. */
+    set(path: string, content: string): void;
+    /** Remove one `.gitignore` file. Returns whether it was registered. */
+    delete(path: string): boolean;
+    /** Remove every registered `.gitignore`. */
+    clear(): void;
+    /** Return the retained content for a registered `.gitignore`. */
+    get(path: string): string | undefined;
+    /** Whether a path is ignored after applying parent then nested rule files. */
+    ignores(path: string, directory?: boolean): boolean;
+    private relativePath;
+    private refreshRules;
+}

package/lib/src/git-ignore.js

@@ -0,0 +1,161 @@
+/**
+ * Mutable, Git-compatible `.gitignore` path matching.
+ *
+ * Rule syntax is owned by the `ignore` package, whose compatibility suite
+ * compares behavior with `git check-ignore`. This module adds repository and
+ * nested-file scoping plus in-memory add, update, and removal.
+ *
+ * @module
+ */
+import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { glob, globSync } from "glob";
+import ignore from "ignore";
+import { ignorePathMatcher } from "./ignore.js";
+import { toPathMatcher } from "./match.js";
+/** Mutable path predicate composed from root and nested `.gitignore` files. */
+export class GitIgnore {
+    root;
+    /** Stable composable matcher that observes later {@link set}, {@link delete}, and {@link clear} calls. */
+    matcher = toPathMatcher((path) => this.ignores(path));
+    files = new Map();
+    rules = [];
+    constructor(root) {
+        this.root = resolve(root instanceof URL ? fileURLToPath(root) : root);
+    }
+    /** Load every applicable `.gitignore` beneath {@link root}. */
+    static async load(root, options = {}) {
+        const result = new GitIgnore(root);
+        for (const path of await glob("**/.gitignore", discoveryOptions(result.root, options))) {
+            result.set(path, await readFile(resolve(result.root, path), "utf8"));
+        }
+        return result;
+    }
+    /** Synchronous counterpart to {@link GitIgnore.load}. */
+    static loadSync(root, options = {}) {
+        const result = new GitIgnore(root);
+        for (const path of globSync("**/.gitignore", discoveryOptions(result.root, options))) {
+            result.set(path, readFileSync(resolve(result.root, path), "utf8"));
+        }
+        return result;
+    }
+    /** Whether `path` names a `.gitignore` control file. */
+    static isFile(path) {
+        return basename(path) === ".gitignore";
+    }
+    /** Add or replace one `.gitignore` file and its in-memory content. */
+    set(path, content) {
+        const relativePath = this.relativePath(path);
+        if (!relativePath || !GitIgnore.isFile(relativePath)) {
+            throw new TypeError(`Git ignore path must name a .gitignore under ${this.root}: ${path}`);
+        }
+        this.files.set(relativePath, {
+            content,
+            directory: toPosix(dirname(relativePath)) === "." ? "" : toPosix(dirname(relativePath)),
+            matcher: ignore().add(content),
+            path: relativePath,
+        });
+        this.refreshRules();
+    }
+    /** Remove one `.gitignore` file. Returns whether it was registered. */
+    delete(path) {
+        const relativePath = this.relativePath(path);
+        if (!relativePath)
+            return false;
+        const deleted = this.files.delete(relativePath);
+        if (deleted)
+            this.refreshRules();
+        return deleted;
+    }
+    /** Remove every registered `.gitignore`. */
+    clear() {
+        this.files.clear();
+        this.rules = [];
+    }
+    /** Return the retained content for a registered `.gitignore`. */
+    get(path) {
+        const relativePath = this.relativePath(path);
+        return relativePath ? this.files.get(relativePath)?.content : undefined;
+    }
+    /** Whether a path is ignored after applying parent then nested rule files. */
+    ignores(path, directory = false) {
+        const relativePath = this.relativePath(path);
+        if (!relativePath || relativePath === ".")
+            return false;
+        let ignored = false;
+        for (const rules of this.rules) {
+            const scopedPath = pathWithin(rules.directory, relativePath);
+            if (scopedPath === undefined || scopedPath === "")
+                continue;
+            if (ignoredParent(rules.matcher, scopedPath))
+                return true;
+            const result = rules.matcher.test(directory ? `${trimSlash(scopedPath)}/` : scopedPath);
+            if (result.ignored)
+                ignored = true;
+            if (result.unignored)
+                ignored = false;
+        }
+        return ignored;
+    }
+    relativePath(path) {
+        const absolute = isAbsolute(path) ? resolve(path) : resolve(this.root, path);
+        const relativePath = relative(this.root, absolute);
+        if (relativePath === "" || relativePath === ".")
+            return ".";
+        if (relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+            return undefined;
+        }
+        return toPosix(relativePath);
+    }
+    refreshRules() {
+        this.rules = [...this.files.values()].sort((left, right) => pathDepth(left.directory) - pathDepth(right.directory) ||
+            left.path.localeCompare(right.path));
+    }
+}
+function discoveryOptions(root, options) {
+    const matcher = ignorePathMatcher(options.ignoreOptions);
+    return {
+        cwd: root,
+        dot: true,
+        follow: options.followSymlinks ?? false,
+        ignore: {
+            ignored(path) {
+                const relativePath = path.relative();
+                return !GitIgnore.isFile(relativePath) && matcher(relativePath);
+            },
+            childrenIgnored(path) {
+                const relativePath = path.relative();
+                return matcher(relativePath) || matcher(`${relativePath}/`);
+            },
+        },
+        nodir: true,
+    };
+}
+function ignoredParent(matcher, path) {
+    const segments = trimSlash(path).split("/");
+    const parentCount = segments.length - 1;
+    for (let index = 1; index <= parentCount; index++) {
+        if (matcher.test(`${segments.slice(0, index).join("/")}/`).ignored)
+            return true;
+    }
+    return false;
+}
+function pathWithin(directory, path) {
+    if (!directory)
+        return path;
+    if (path === directory)
+        return "";
+    return path.startsWith(`${directory}/`) ? path.slice(directory.length + 1) : undefined;
+}
+function pathDepth(path) {
+    return path ? path.split("/").length : 0;
+}
+function trimSlash(path) {
+    return path.replace(/^\/+|\/+$/g, "");
+}
+function toPosix(path) {
+    return path.split(sep).join("/");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"git-ignore.js","sourceRoot":"","sources":["../../src/git-ignore.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Mutable, Git-compatible `.gitignore` path matching.\n *\n * Rule syntax is owned by the `ignore` package, whose compatibility suite\n * compares behavior with `git check-ignore`. This module adds repository and\n * nested-file scoping plus in-memory add, update, and removal.\n *\n * @module\n */\n\nimport { readFileSync } from \"node:fs\";\nimport { readFile } from \"node:fs/promises\";\nimport { basename, dirname, isAbsolute, relative, resolve, sep } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { glob, globSync, type IgnoreLike } from \"glob\";\nimport ignore from \"ignore\";\nimport type { IgnorePatternOptions } from \"./ignore.ts\";\nimport { ignorePathMatcher } from \"./ignore.ts\";\nimport { toPathMatcher, type PathMatcher } from \"./match.ts\";\n\ninterface GitIgnoreRuleSet {\n  content: string;\n  directory: string;\n  matcher: ReturnType<typeof ignore>;\n  path: string;\n}\n\n/** Options used while discovering `.gitignore` files beneath a root. */\nexport interface GitIgnoreLoadOptions {\n  /** Built-in directory groups pruned while looking for ignore files. */\n  ignoreOptions?: IgnorePatternOptions;\n  /** Follow symlinked directories during discovery. Defaults to false. */\n  followSymlinks?: boolean;\n}\n\n/** Mutable path predicate composed from root and nested `.gitignore` files. */\nexport class GitIgnore {\n  readonly root: string;\n  /** Stable composable matcher that observes later {@link set}, {@link delete}, and {@link clear} calls. */\n  readonly matcher: PathMatcher = toPathMatcher((path) => this.ignores(path));\n\n  private readonly files = new Map<string, GitIgnoreRuleSet>();\n  private rules: GitIgnoreRuleSet[] = [];\n\n  constructor(root: string | URL) {\n    this.root = resolve(root instanceof URL ? fileURLToPath(root) : root);\n  }\n\n  /** Load every applicable `.gitignore` beneath {@link root}. */\n  static async load(\n    root: string | URL,\n    options: GitIgnoreLoadOptions = {},\n  ): Promise<GitIgnore> {\n    const result = new GitIgnore(root);\n    for (const path of await glob(\"**/.gitignore\", discoveryOptions(result.root, options))) {\n      result.set(path, await readFile(resolve(result.root, path), \"utf8\"));\n    }\n    return result;\n  }\n\n  /** Synchronous counterpart to {@link GitIgnore.load}. */\n  static loadSync(root: string | URL, options: GitIgnoreLoadOptions = {}): GitIgnore {\n    const result = new GitIgnore(root);\n    for (const path of globSync(\"**/.gitignore\", discoveryOptions(result.root, options))) {\n      result.set(path, readFileSync(resolve(result.root, path), \"utf8\"));\n    }\n    return result;\n  }\n\n  /** Whether `path` names a `.gitignore` control file. */\n  static isFile(path: string): boolean {\n    return basename(path) === \".gitignore\";\n  }\n\n  /** Add or replace one `.gitignore` file and its in-memory content. */\n  set(path: string, content: string): void {\n    const relativePath = this.relativePath(path);\n    if (!relativePath || !GitIgnore.isFile(relativePath)) {\n      throw new TypeError(`Git ignore path must name a .gitignore under ${this.root}: ${path}`);\n    }\n    this.files.set(relativePath, {\n      content,\n      directory: toPosix(dirname(relativePath)) === \".\" ? \"\" : toPosix(dirname(relativePath)),\n      matcher: ignore().add(content),\n      path: relativePath,\n    });\n    this.refreshRules();\n  }\n\n  /** Remove one `.gitignore` file. Returns whether it was registered. */\n  delete(path: string): boolean {\n    const relativePath = this.relativePath(path);\n    if (!relativePath) return false;\n    const deleted = this.files.delete(relativePath);\n    if (deleted) this.refreshRules();\n    return deleted;\n  }\n\n  /** Remove every registered `.gitignore`. */\n  clear(): void {\n    this.files.clear();\n    this.rules = [];\n  }\n\n  /** Return the retained content for a registered `.gitignore`. */\n  get(path: string): string | undefined {\n    const relativePath = this.relativePath(path);\n    return relativePath ? this.files.get(relativePath)?.content : undefined;\n  }\n\n  /** Whether a path is ignored after applying parent then nested rule files. */\n  ignores(path: string, directory: boolean = false): boolean {\n    const relativePath = this.relativePath(path);\n    if (!relativePath || relativePath === \".\") return false;\n    let ignored = false;\n    for (const rules of this.rules) {\n      const scopedPath = pathWithin(rules.directory, relativePath);\n      if (scopedPath === undefined || scopedPath === \"\") continue;\n      if (ignoredParent(rules.matcher, scopedPath)) return true;\n      const result = rules.matcher.test(directory ? `${trimSlash(scopedPath)}/` : scopedPath);\n      if (result.ignored) ignored = true;\n      if (result.unignored) ignored = false;\n    }\n    return ignored;\n  }\n\n  private relativePath(path: string): string | undefined {\n    const absolute = isAbsolute(path) ? resolve(path) : resolve(this.root, path);\n    const relativePath = relative(this.root, absolute);\n    if (relativePath === \"\" || relativePath === \".\") return \".\";\n    if (relativePath === \"..\" || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {\n      return undefined;\n    }\n    return toPosix(relativePath);\n  }\n\n  private refreshRules(): void {\n    this.rules = [...this.files.values()].sort(\n      (left, right) =>\n        pathDepth(left.directory) - pathDepth(right.directory) ||\n        left.path.localeCompare(right.path),\n    );\n  }\n}\n\nfunction discoveryOptions(\n  root: string,\n  options: GitIgnoreLoadOptions,\n): {\n  cwd: string;\n  dot: true;\n  follow: boolean;\n  ignore: IgnoreLike;\n  nodir: true;\n} {\n  const matcher = ignorePathMatcher(options.ignoreOptions);\n  return {\n    cwd: root,\n    dot: true,\n    follow: options.followSymlinks ?? false,\n    ignore: {\n      ignored(path) {\n        const relativePath = path.relative();\n        return !GitIgnore.isFile(relativePath) && matcher(relativePath);\n      },\n      childrenIgnored(path) {\n        const relativePath = path.relative();\n        return matcher(relativePath) || matcher(`${relativePath}/`);\n      },\n    },\n    nodir: true,\n  };\n}\n\nfunction ignoredParent(matcher: ReturnType<typeof ignore>, path: string): boolean {\n  const segments = trimSlash(path).split(\"/\");\n  const parentCount = segments.length - 1;\n  for (let index = 1; index <= parentCount; index++) {\n    if (matcher.test(`${segments.slice(0, index).join(\"/\")}/`).ignored) return true;\n  }\n  return false;\n}\n\nfunction pathWithin(directory: string, path: string): string | undefined {\n  if (!directory) return path;\n  if (path === directory) return \"\";\n  return path.startsWith(`${directory}/`) ? path.slice(directory.length + 1) : undefined;\n}\n\nfunction pathDepth(path: string): number {\n  return path ? path.split(\"/\").length : 0;\n}\n\nfunction trimSlash(path: string): string {\n  return path.replace(/^\\/+|\\/+$/g, \"\");\n}\n\nfunction toPosix(path: string): string {\n  return path.split(sep).join(\"/\");\n}\n"]}

package/lib/src/scan.d.ts

@@ -7,7 +7,7 @@
  *
  * @module
  */
-import { IgnorePatternOptions } from "./ignore.ts";
+import type { IgnorePatternOptions } from "./ignore.ts";
 import { PathMatchInput } from "./match.ts";
 /** Shared default used by file discovery and watching to avoid traversing symlinks. */
 export declare const FOLLOW_SYMLINKS_DEFAULT = false;
@@ -37,5 +37,11 @@ export interface FileScanOptions {
      */
     signal?: AbortSignal;
 }
-/** Options controlling the generated ignore pattern list. */
-export type FileScanIgnoreOptions = IgnorePatternOptions;
+/** Options controlling built-in and repository `.gitignore` matching. */
+export interface FileScanIgnoreOptions extends IgnorePatternOptions {
+    /**
+     * Load root and nested `.gitignore` files using Git-compatible semantics.
+     * Defaults to false.
+     */
+    git?: boolean;
+}

package/lib/src/scan.js

@@ -9,4 +9,4 @@
  */
 /** Shared default used by file discovery and watching to avoid traversing symlinks. */
 export const FOLLOW_SYMLINKS_DEFAULT = false;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Nhbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zY2FuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7OztHQVFHO0FBS0gsdUZBQXVGO0FBQ3ZGLE1BQU0sQ0FBQyxNQUFNLHVCQUF1QixHQUFHLEtBQUssQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogU2hhcmVkIHNjYW4gb3B0aW9ucyB1c2VkIGJ5IGZpbGUgZGlzY292ZXJ5IGFuZCB3YXRjaGluZy5cbiAqXG4gKiBSZXVzZSB0aGVzZSB0eXBlcyBzbyBwYXRoLWJhc2VkIHV0aWxpdGllcyBhZ3JlZSBvbiByb290cywgaWdub3JlIHBvbGljeSxcbiAqIHN5bWxpbmsgYmVoYXZpb3IsIGFuZCBjYW5jZWxsYXRpb24gcmF0aGVyIHRoYW4gaW52ZW50aW5nIHBhcmFsbGVsIG9wdGlvblxuICogc2hhcGVzLlxuICpcbiAqIEBtb2R1bGVcbiAqL1xuXG5pbXBvcnQgeyBJZ25vcmVQYXR0ZXJuT3B0aW9ucyB9IGZyb20gXCIuL2lnbm9yZS50c1wiO1xuaW1wb3J0IHsgUGF0aE1hdGNoSW5wdXQgfSBmcm9tIFwiLi9tYXRjaC50c1wiO1xuXG4vKiogU2hhcmVkIGRlZmF1bHQgdXNlZCBieSBmaWxlIGRpc2NvdmVyeSBhbmQgd2F0Y2hpbmcgdG8gYXZvaWQgdHJhdmVyc2luZyBzeW1saW5rcy4gKi9cbmV4cG9ydCBjb25zdCBGT0xMT1dfU1lNTElOS1NfREVGQVVMVCA9IGZhbHNlO1xuXG4vKiogQ29tbW9uIHJvb3QsIGlnbm9yZSwgc3ltbGluaywgYW5kIGNhbmNlbGxhdGlvbiBzZXR0aW5ncyBmb3IgZmlsZXN5c3RlbSBzY2Fucy4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRmlsZVNjYW5PcHRpb25zIHtcbiAgLyoqXG4gICAqIEJhc2UgZGlyZWN0b3J5IHVzZWQgdG8gcmVzb2x2ZSByZWxhdGl2ZSBwYXRocy5cbiAgICovXG4gIGN3ZD86IHN0cmluZztcblxuICAvKipcbiAgICogSWdub3JlIGZpbGVzIG9yIGRpcmVjdG9yaWVzIG1hdGNoaW5nIHRoZXNlIHBhdHRlcm5zIG9yIHByZWRpY2F0ZXMuXG4gICAqL1xuICBpZ25vcmU/OiBQYXRoTWF0Y2hJbnB1dCB8IHJlYWRvbmx5IFBhdGhNYXRjaElucHV0W107XG4gIGlnbm9yZU9wdGlvbnM/OiBGaWxlU2Nhbklnbm9yZU9wdGlvbnM7XG4gIC8qKlxuICAgKiBGb2xsb3cgc3ltYm9saWMgbGlua3MuXG4gICAqXG4gICAqIE1hcHMgdG86XG4gICAqICAgZ2xvYjogZm9sbG93XG4gICAqICAgY2hva2lkYXI6IGZvbGxvd1N5bWxpbmtzXG4gICAqL1xuICBmb2xsb3dTeW1saW5rcz86IGJvb2xlYW47XG5cbiAgLyoqXG4gICAqIEFib3J0IGFuIGluLXByb2dyZXNzIG9wZXJhdGlvbi5cbiAgICpcbiAgICogSWdub3JlZCBieSBjaG9raWRhciBhZnRlciB0aGUgd2F0Y2hlciBoYXMgYmVlbiBjcmVhdGVkLlxuICAgKi9cbiAgc2lnbmFsPzogQWJvcnRTaWduYWw7XG59XG5cbi8qKiBPcHRpb25zIGNvbnRyb2xsaW5nIHRoZSBnZW5lcmF0ZWQgaWdub3JlIHBhdHRlcm4gbGlzdC4gKi9cbmV4cG9ydCB0eXBlIEZpbGVTY2FuSWdub3JlT3B0aW9ucyA9IElnbm9yZVBhdHRlcm5PcHRpb25zO1xuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/watch.d.ts

@@ -8,7 +8,7 @@
  *
  * @module
  */
-import { ChokidarOptions, MatchFunction } from "chokidar";
+import { ChokidarOptions, MatchFunction, type FSWatcher } from "chokidar";
 import { FileScanOptions } from "./scan.ts";
 /** Chokidar options extended with the shared dbx-tools ignore configuration. */
 export interface FileWatchOptions extends Omit<ChokidarOptions, "ignored">, Omit<FileScanOptions, "ignore"> {
@@ -19,4 +19,4 @@ export interface FileWatchOptions extends Omit<ChokidarOptions, "ignored">, Omit
  * ignore groups so it prunes the same paths {@link findFiles} skips for the
  * same patterns.
  */
-export declare function watchFiles(paths: string | string[], options?: FileWatchOptions): import("chokidar").FSWatcher;
+export declare function watchFiles(paths: string | string[], options?: FileWatchOptions): Promise<FSWatcher>;