@poe-platform/safe-bash 0.1.798 → 0.1.800

package/dist/safe-bash/command-chunks/chunk-3LSOYLNV.js

@@ -0,0 +1,1091 @@
+import {
+  FindFormatBudget,
+  compileFindFormat
+} from "./chunk-5ZMZ573Q.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-find/src/find.ts
+init_buffer();
+import { tryGetMemoryDirectoryEntryNamesSync } from "@poe-platform/safe-fs/core";
+import { basename, FsError, getCommandArguments, resolvePath } from "../../safe-bash-contracts/index.js";
+import { assertCommandRequirements } from "../../safe-bash-contracts/command-requirements.js";
+import { PublicDiagnostic } from "../../safe-bash-contracts/diagnostics.js";
+import { escapeText } from "../../safe-bash-contracts/escaping.js";
+import { getRuntimeBackingFileSystem, isSyncResolved } from "../../safe-bash-contracts/runtime-control.js";
+import { byteLength, writeEncodedBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+import { createDirectoryReader } from "../../safe-bash-io-engine/commands/directory-admission.js";
+import { filesystemCommandRequirements } from "../../safe-bash-io-engine/commands/filesystem-requirements.js";
+import { modeChange } from "../../safe-bash-io-engine/commands/mode-change.js";
+import { builtInDirectContextExecutors, codeOf, define, diagnostic, integer, output, outputRange, pathOf, replaceArgument, RESOLVED_EXIT_ZERO, UsageError } from "../../safe-bash-io-engine/internal.js";
+import { compilePattern } from "../../safe-bash-io-engine/shell/pattern.js";
+var SYNTHETIC_FILE_STAT = Object.freeze({ type: "file", size: 0, mode: 420, mtimeMs: 0, atimeMs: 0, ctimeMs: 0 });
+var SYNTHETIC_DIR_STAT = Object.freeze({ type: "directory", size: 0, mode: 493, mtimeMs: 0, atimeMs: 0, ctimeMs: 0 });
+var SYNTHETIC_SYMLINK_STAT = Object.freeze({ type: "symlink", size: 0, mode: 511, mtimeMs: 0, atimeMs: 0, ctimeMs: 0 });
+var SYNTHETIC_CHAR_STAT = Object.freeze({ type: "character", size: 0, mode: 438, mtimeMs: 0, atimeMs: 0, ctimeMs: 0 });
+var FIND_DIR_REQUIREMENTS = Object.freeze(["directory"]);
+var cachedFindPatternsCS = /* @__PURE__ */ new Map();
+var cachedFindPatternsCI = /* @__PURE__ */ new Map();
+function getCachedFindPattern(pattern, caseInsensitive) {
+  for (let i = 0; i < pattern.length; i++) {
+    const c = pattern.charCodeAt(i);
+    if (c === 91 || c === 92 || c === 93) return void 0;
+  }
+  const map = caseInsensitive ? cachedFindPatternsCI : cachedFindPatternsCS;
+  let fn = map.get(pattern);
+  if (!fn) {
+    if (map.size >= 64) map.clear();
+    const star = pattern.indexOf("*");
+    if (!caseInsensitive && pattern.indexOf("?") === -1 && star !== -1 && pattern.indexOf("*", star + 1) === -1) {
+      const prefix = pattern.slice(0, star);
+      const suffix = pattern.slice(star + 1);
+      const minLen = prefix.length + suffix.length;
+      fn = (text) => text.length >= minLen && text.startsWith(prefix) && text.endsWith(suffix);
+    } else {
+      let rxSrc = "^";
+      for (let i = 0; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (ch === "*") rxSrc += ".*";
+        else if (ch === "?") rxSrc += ".";
+        else if (".+^${}()|[]\\".includes(ch)) rxSrc += "\\" + ch;
+        else rxSrc += ch;
+      }
+      rxSrc += "$";
+      const rx = new RegExp(rxSrc, caseInsensitive ? "si" : "s");
+      fn = (text) => rx.test(text);
+    }
+    map.set(pattern, fn);
+  }
+  return fn;
+}
+var sharedFindPrintBuf = new Uint8Array(8192);
+function writeUtf8(buf, pos, s) {
+  const len = s.length;
+  for (let i = 0; i < len; i++) {
+    const c = s.charCodeAt(i);
+    if (c >= 128) return writeEncodedBytes(buf, s, pos, "utf8");
+    buf[pos + i] = c;
+  }
+  return len;
+}
+var sharedFindPrintBufInUse = false;
+function finishFindPrintBufAsync() {
+  sharedFindPrintBufInUse = false;
+  return RESOLVED_EXIT_ZERO;
+}
+var findKeyScratch = new Array(256).fill("");
+var findKeyScratchTop = 0;
+var findKeySorted = true;
+var findKeyAllFiles = true;
+var findKeyPrev = "";
+var findKeyCurrentMatch;
+var SHELLSORT_GAPS = [701, 301, 132, 57, 23, 10, 4, 1];
+function collectFindKey(v, k) {
+  if (v.type !== "file") findKeyAllFiles = false;
+  if (findKeyCurrentMatch !== void 0 && !findKeyCurrentMatch(k)) return;
+  if (findKeyPrev > k) findKeySorted = false;
+  findKeyPrev = k;
+  if (findKeyScratchTop === findKeyScratch.length) findKeyScratch.push(k);
+  else findKeyScratch[findKeyScratchTop] = k;
+  findKeyScratchTop++;
+}
+function sortFindKeyRange(start, end) {
+  const len = end - start;
+  for (let g = 0; g < SHELLSORT_GAPS.length; g++) {
+    const gap = SHELLSORT_GAPS[g];
+    if (gap >= len) continue;
+    for (let i = start + gap; i < end; i++) {
+      const key = findKeyScratch[i];
+      let j = i;
+      while (j >= start + gap && findKeyScratch[j - gap] > key) {
+        findKeyScratch[j] = findKeyScratch[j - gap];
+        j -= gap;
+      }
+      findKeyScratch[j] = key;
+    }
+  }
+}
+function stageAndSortFindKeys(map, baseOffset, match) {
+  findKeyScratchTop = baseOffset;
+  findKeySorted = true;
+  findKeyAllFiles = true;
+  findKeyPrev = "";
+  findKeyCurrentMatch = match;
+  map.forEach(collectFindKey);
+  findKeyCurrentMatch = void 0;
+  if (!findKeySorted) {
+    sortFindKeyRange(baseOffset, findKeyScratchTop);
+  }
+  return findKeyScratchTop;
+}
+function syntheticStatFor(type) {
+  return type === "file" ? SYNTHETIC_FILE_STAT : type === "directory" ? SYNTHETIC_DIR_STAT : type === "symlink" ? SYNTHETIC_SYMLINK_STAT : SYNTHETIC_CHAR_STAT;
+}
+function createFindDefinitions(execute, maxDirectoryEntries) {
+  const readDirectory = createDirectoryReader(maxDirectoryEntries);
+  const defs = [define("find", (context) => {
+    if (!context.argumentValues && context.args.length === 3 && (context.args[1] === "-name" || context.args[1] === "-iname") && !sharedFindPrintBufInUse && !context.signal.aborted) {
+      const rootDisplay = context.args[0];
+      if (rootDisplay && !rootDisplay.startsWith("-") && rootDisplay !== "!" && rootDisplay !== "(") {
+        const fastBacking = context._fastMemoryBackingFs;
+        const backing = fastBacking ?? getRuntimeBackingFileSystem(context.fs);
+        if (backing !== void 0 && backing.capabilitiesFor === void 0 && backing.capabilities.readOnly !== true && backing.capabilities.readdir !== false && backing.capabilities.realpath !== false) {
+          const path = pathOf(context, rootDisplay);
+          if (path !== "/dev" && !path.startsWith("/dev/")) {
+            const match = getCachedFindPattern(context.args[2], context.args[1] === "-iname");
+            const memDirEntries = match !== void 0 ? tryGetMemoryDirectoryEntryNamesSync(backing, path) : void 0;
+            if (match !== void 0 && memDirEntries !== void 0 && memDirEntries.size <= (maxDirectoryEntries ?? Infinity)) {
+              const stdoutPipe = context.stdout;
+              if (stdoutPipe.lineCountOnly === 0 && typeof stdoutPipe.writeLineCountSync === "function") {
+                const fastMap = memDirEntries;
+                if (typeof fastMap._next === "number" && fastMap._keys !== void 0 && fastMap._vals !== void 0) {
+                  let parent = rootDisplay;
+                  while (parent.endsWith("/") && parent.length > 1) parent = parent.slice(0, -1);
+                  const pLen = parent === "/" ? 0 : escapeText(parent, "display").length;
+                  const rootName = basename(rootDisplay) || "/";
+                  let matchCount = 0;
+                  let totalBytes = 0;
+                  let allFiles = true;
+                  if (match(rootName)) {
+                    matchCount = 1;
+                    totalBytes = escapeText(rootDisplay, "display").length + 1;
+                  }
+                  const next = fastMap._next;
+                  const keys = fastMap._keys;
+                  const vals = fastMap._vals;
+                  for (let i = 0; i < next; i++) {
+                    const v = vals[i];
+                    if (v !== void 0) {
+                      if (v.type !== "file") {
+                        allFiles = false;
+                        break;
+                      }
+                      const k = keys[i];
+                      if (match(k)) {
+                        matchCount++;
+                        totalBytes += pLen + k.length + 2;
+                      }
+                    }
+                  }
+                  if (allFiles) {
+                    assertCommandRequirements(context, filesystemCommandRequirements.ls, FIND_DIR_REQUIREMENTS, backing.capabilities);
+                    if (fastBacking !== void 0) context._chargeFastFsOp();
+                    if (stdoutPipe.writeLineCountSync(matchCount, totalBytes)) {
+                      return RESOLVED_EXIT_ZERO;
+                    }
+                  }
+                }
+              }
+              const keyBase = findKeyScratchTop;
+              const keyEnd = stageAndSortFindKeys(memDirEntries, keyBase, match);
+              if (findKeyAllFiles) {
+                try {
+                  assertCommandRequirements(context, filesystemCommandRequirements.ls, FIND_DIR_REQUIREMENTS, backing.capabilities);
+                  if (fastBacking !== void 0) context._chargeFastFsOp();
+                  let parent = rootDisplay;
+                  while (parent.endsWith("/") && parent.length > 1) parent = parent.slice(0, -1);
+                  const escapedParent = escapeText(parent === "/" ? "" : parent, "display");
+                  const rootName = basename(rootDisplay) || "/";
+                  sharedFindPrintBufInUse = true;
+                  let printPos = 0;
+                  let overflow = false;
+                  if (match(rootName)) {
+                    const escRoot = escapeText(rootDisplay, "display");
+                    if (escRoot.length + 1 <= sharedFindPrintBuf.length) {
+                      for (let c = 0; c < escRoot.length; c++) sharedFindPrintBuf[printPos++] = escRoot.charCodeAt(c);
+                      sharedFindPrintBuf[printPos++] = 10;
+                    } else {
+                      overflow = true;
+                    }
+                  }
+                  if (!overflow) {
+                    const pLen = escapedParent.length;
+                    for (let i = keyBase; i < keyEnd; i++) {
+                      const childName = findKeyScratch[i];
+                      const escChild = escapeText(childName, "display");
+                      const cLen = escChild.length;
+                      if (printPos + pLen + cLen + 2 > sharedFindPrintBuf.length) {
+                        overflow = true;
+                        break;
+                      }
+                      for (let c = 0; c < pLen; c++) sharedFindPrintBuf[printPos++] = escapedParent.charCodeAt(c);
+                      sharedFindPrintBuf[printPos++] = 47;
+                      for (let c = 0; c < cLen; c++) sharedFindPrintBuf[printPos++] = escChild.charCodeAt(c);
+                      sharedFindPrintBuf[printPos++] = 10;
+                    }
+                  }
+                  if (!overflow) {
+                    if (printPos === 0) {
+                      sharedFindPrintBufInUse = false;
+                      return RESOLVED_EXIT_ZERO;
+                    }
+                    const stdoutSink = context.stdout;
+                    if (!stdoutSink.isPipeStage && typeof stdoutSink.writeRangeSync === "function" && stdoutSink.writeRangeSync(sharedFindPrintBuf, printPos) !== false) {
+                      sharedFindPrintBufInUse = false;
+                      return RESOLVED_EXIT_ZERO;
+                    }
+                    const p = outputRange(context, sharedFindPrintBuf, printPos);
+                    if (isSyncResolved(p)) {
+                      sharedFindPrintBufInUse = false;
+                      return RESOLVED_EXIT_ZERO;
+                    }
+                    return p.then(finishFindPrintBufAsync, (error) => {
+                      sharedFindPrintBuf = new Uint8Array(sharedFindPrintBuf.length);
+                      sharedFindPrintBufInUse = false;
+                      throw error;
+                    });
+                  }
+                  sharedFindPrintBufInUse = false;
+                } catch (error) {
+                  if (sharedFindPrintBufInUse) {
+                    sharedFindPrintBuf = new Uint8Array(sharedFindPrintBuf.length);
+                    sharedFindPrintBufInUse = false;
+                  }
+                  throw error;
+                } finally {
+                  findKeyScratch.fill("", keyBase, keyEnd);
+                  findKeyScratchTop = keyBase;
+                }
+              } else {
+                findKeyScratch.fill("", keyBase, keyEnd);
+                findKeyScratchTop = keyBase;
+              }
+            }
+          }
+        }
+      }
+    }
+    return executeFindSlow(context);
+  })];
+  if (maxDirectoryEntries === void 0) builtInDirectContextExecutors.add(defs[0].execute);
+  return defs;
+  async function executeFindSlow(context) {
+    const startedAt = Date.now();
+    const rawArgumentValues = context.argumentValues ? getCommandArguments(context) : void 0;
+    const args = rawArgumentValues ? [...rawArgumentValues.args] : [...context.args];
+    const values = rawArgumentValues ? [...rawArgumentValues.values] : [...context.args];
+    let follow = "-P";
+    let debugTree = false;
+    while (["-P", "-L", "-H", "-D"].includes(args[0] ?? "")) {
+      const option = args.shift();
+      values.shift();
+      if (option !== "-D") {
+        follow = option;
+        continue;
+      }
+      const debug = args.shift();
+      values.shift();
+      if (debug === void 0) throw new UsageError("-D requires a debug option");
+      if (debug !== "tree") throw new UsageError(`unsupported debug option '${debug}' (supported: tree)`);
+      debugTree = true;
+    }
+    if (args[0] === "--") {
+      args.shift();
+      values.shift();
+    }
+    const roots = [];
+    while (args.length && !args[0].startsWith("-") && !["!", "("].includes(args[0])) {
+      roots.push(args.shift());
+      values.shift();
+    }
+    if (!roots.length) roots.push(".");
+    let maxDepth = Infinity;
+    let minDepth = 0;
+    let depthFirst = false;
+    let explicitDepth = false;
+    let offset = 0;
+    let explicitAction = false;
+    let quitRequested = false;
+    let exitCode = 0;
+    let deletes = false;
+    let prunes = false;
+    let needsStat = false;
+    let needsDisplay = false;
+    const references = /* @__PURE__ */ new Map();
+    const flushes = [];
+    const formats = [];
+    const formatBudget = new FindFormatBudget(context);
+    const trees = /* @__PURE__ */ new Map();
+    const primary = () => {
+      const start = offset;
+      const expression = parsePrimary();
+      if (debugTree && !trees.has(expression)) trees.set(expression, JSON.stringify(args.slice(start, offset)));
+      return expression;
+    };
+    const parsePrimary = () => {
+      const token = args[offset++];
+      if (token === void 0) throw new UsageError("missing expression");
+      if (token === "!" || token === "-not") {
+        const inner = primary();
+        const expression = (entry) => {
+          const res = inner(entry);
+          return typeof res === "boolean" ? !res : res.then((v) => !v);
+        };
+        if (debugTree) trees.set(expression, `NOT(${trees.get(inner)})`);
+        return expression;
+      }
+      if (token === "(") {
+        const inner = disjunction();
+        if (args[offset++] !== ")") throw new UsageError("missing ')'");
+        return inner;
+      }
+      if (token === "-depth") {
+        depthFirst = true;
+        explicitDepth = true;
+        return () => true;
+      }
+      if (token === "-maxdepth" || token === "-mindepth") {
+        const operand = args[offset++];
+        if (operand === void 0) throw new UsageError(`${token} requires a number`);
+        const number = integer(operand);
+        if (token === "-maxdepth") maxDepth = number;
+        else minDepth = number;
+        return () => true;
+      }
+      if (["-name", "-iname", "-path", "-ipath", "-wholename", "-iwholename", "-regex", "-iregex", "-type", "-perm", "-links", "-size", "-mtime", "-mmin", "-amin", "-cmin", "-newer"].includes(token)) {
+        const operand = args[offset++];
+        if (operand === void 0) throw new UsageError(`${token} requires an argument`);
+        if (token === "-regex" || token === "-iregex") {
+          needsDisplay = true;
+          let regex;
+          try {
+            regex = new RegExp(`^(?:${operand})$`, token === "-iregex" ? "iu" : "u");
+          } catch {
+            throw new UsageError(`invalid regular expression '${operand}'`);
+          }
+          return (entry) => regex.test(entry.display);
+        }
+        if (token === "-newer") {
+          needsStat = true;
+          references.set(operand, 0);
+          return (entry) => entry.stat.mtimeMs > references.get(operand);
+        }
+        if (token === "-mtime" || token === "-mmin" || token === "-amin" || token === "-cmin") {
+          needsStat = true;
+          const match = /^([+-]?)([0-9]+)$/u.exec(operand);
+          if (!match) throw new UsageError(`invalid time '${operand}'`);
+          const amount = integer(match[2]);
+          const unit = token === "-mtime" ? 864e5 : 6e4;
+          const origin = startedAt - (token === "-mtime" ? match[1] === "-" ? 1e3 : unit : 0);
+          const reference = origin - amount * unit;
+          if (!Number.isSafeInteger(amount * unit) || !Number.isSafeInteger(reference) || !Number.isSafeInteger(reference + unit)) {
+            throw new UsageError(`invalid time '${operand}': comparison is out of range`);
+          }
+          return async (entry) => {
+            const stamp = token === "-amin" ? entry.stat.atimeMs ?? entry.stat.mtimeMs : token === "-cmin" ? entry.stat.ctimeMs ?? entry.stat.mtimeMs : entry.stat.mtimeMs;
+            const delta = stamp - reference;
+            return match[1] === "+" ? delta < 0 : match[1] === "-" ? delta > 0 : delta > 0 && delta <= unit;
+          };
+        }
+        if (token === "-type") {
+          const types = { f: "file", d: "directory", l: "symlink", c: "character" };
+          const specialModes = { b: 24576, p: 4096, s: 49152 };
+          const requested = operand.split(",");
+          if (requested.some((type) => !types[type] && !specialModes[type])) throw new UsageError(`unsupported file type '${operand}'`);
+          if (requested.some((type) => Boolean(specialModes[type]))) needsStat = true;
+          if (requested.length === 1 && types[requested[0]]) {
+            const expectedType = types[requested[0]];
+            return (entry) => entry.stat.type === expectedType;
+          }
+          return (entry) => requested.some((type) => specialModes[type] ? (entry.stat.mode & 61440) === specialModes[type] : entry.stat.type === types[type]);
+        }
+        if (token === "-perm") {
+          needsStat = true;
+          const comparison = operand[0] === "-" || operand[0] === "/" || operand[0] === "+" && /^[0-7]/u.test(operand.slice(1)) ? operand[0] : "";
+          const spec = comparison ? operand.slice(1) : operand;
+          const evalMode = modeChange(spec, 0);
+          return async (entry) => {
+            const bits = evalMode({ mode: 0, type: entry.stat.type });
+            const permissions = entry.stat.mode & 4095;
+            return comparison === "-" ? (permissions & bits) === bits : comparison === "/" || comparison === "+" ? bits === 0 || (permissions & bits) !== 0 : permissions === bits;
+          };
+        }
+        if (token === "-links") {
+          needsStat = true;
+          const comparison = operand[0] === "+" || operand[0] === "-" ? operand[0] : "";
+          const digits = comparison ? operand.slice(1) : operand;
+          if (!digits || [...digits].some((digit) => digit < "0" || digit > "9")) throw new UsageError(`invalid link count '${operand}'`);
+          const count = integer(digits);
+          return async (entry) => {
+            if (entry.stat.nlink === void 0) throw new FsError("ENOTSUP", { path: entry.path, message: "link count unavailable" });
+            return comparison === "+" ? entry.stat.nlink > count : comparison === "-" ? entry.stat.nlink < count : entry.stat.nlink === count;
+          };
+        }
+        if (token === "-size") {
+          needsStat = true;
+          const comparison = operand[0] === "+" || operand[0] === "-" ? operand[0] : "";
+          const units = { c: 1, w: 2, b: 512, k: 1024, M: 1048576, G: 1073741824 };
+          const suffix = operand.at(-1);
+          const unit = units[suffix] ?? 512;
+          const digits = operand.slice(comparison ? 1 : 0, units[suffix] === void 0 ? void 0 : -1);
+          if (!digits || [...digits].some((digit) => digit < "0" || digit > "9")) throw new UsageError(`invalid size '${operand}'`);
+          const size = integer(digits);
+          return async (entry) => comparison === "+" ? Math.ceil(entry.stat.size / unit) > size : comparison === "-" ? Math.ceil(entry.stat.size / unit) < size : Math.ceil(entry.stat.size / unit) === size;
+        }
+        const ignoreCase = token === "-iname" || token === "-ipath" || token === "-iwholename";
+        const work = {
+          remaining: Infinity,
+          signal: context.signal,
+          exhausted() {
+            throw new UsageError(`pattern work limit exceeded for '${operand}'`);
+          }
+        };
+        const matcherPromise = compilePattern(operand, work, ignoreCase);
+        let compiledMatcher;
+        formats.push(async () => {
+          compiledMatcher = await matcherPromise;
+        });
+        const useName = token === "-name" || token === "-iname";
+        if (!useName) needsDisplay = true;
+        return (entry) => compiledMatcher(useName ? entry.name : entry.display);
+      }
+      if (token === "-true" || token === "-false") return () => token === "-true";
+      if (token === "-empty") {
+        needsStat = true;
+        return async (entry) => entry.stat.type === "directory" ? !(await readDirectory(context, entry.path)).length : entry.stat.type === "file" && entry.stat.size === 0;
+      }
+      if (token === "-prune") {
+        prunes = true;
+        return (entry) => {
+          entry.prune = true;
+          return true;
+        };
+      }
+      if (token === "-quit") {
+        explicitAction = true;
+        return () => {
+          quitRequested = true;
+          return true;
+        };
+      }
+      if (token === "-delete") {
+        explicitAction = true;
+        depthFirst = true;
+        deletes = true;
+        return async (entry) => {
+          context.signal.throwIfAborted();
+          if (basename(entry.display) === ".") return true;
+          try {
+            const directory = entry.stat.type === "directory" && !entry.symlink;
+            const capabilities = await context.fs.capabilitiesFor?.(entry.path, { signal: context.signal }) ?? context.fs.capabilities;
+            assertCommandRequirements(
+              context,
+              directory ? filesystemCommandRequirements.rmdir : filesystemCommandRequirements.rm,
+              [directory ? "directory" : "file"],
+              capabilities
+            );
+            if (directory) {
+              if (!context.fs.rmdir || capabilities.snapshotRmdir) throw new FsError("ENOTSUP", { syscall: "rmdir", path: entry.path });
+              await context.fs.rmdir(entry.path, { signal: context.signal });
+            } else await context.fs.rm(entry.path, { recursive: false, signal: context.signal });
+            context.signal.throwIfAborted();
+            return true;
+          } catch (error) {
+            await diagnostic(context, error);
+            exitCode = 1;
+            return false;
+          }
+        };
+      }
+      if (token === "-print" || token === "-print0") {
+        explicitAction = true;
+        return async (entry) => {
+          await output(context, token === "-print0" ? `${entry.display}\0` : `${escapeText(entry.display, "display")}
+`);
+          return true;
+        };
+      }
+      if (token === "-printf") {
+        needsStat = true;
+        if (args[offset] === void 0) throw new UsageError("-printf requires a format");
+        const operand = values[offset++];
+        let render;
+        formats.push(async () => {
+          render = await compileFindFormat(operand, formatBudget);
+        });
+        explicitAction = true;
+        return async (entry) => {
+          await render(entry);
+          return true;
+        };
+      }
+      if (token === "-exec") {
+        explicitAction = true;
+        const command = [];
+        const start = offset;
+        while (args[offset] !== void 0 && args[offset] !== ";" && !(args[offset] === "+" && args[offset - 1] === "{}")) command.push(args[offset++]);
+        const commandArguments = (rawArgumentValues ?? getCommandArguments(context)).withValues(values.slice(start, offset));
+        const terminator = args[offset++];
+        if (!command.length || terminator === void 0) throw new UsageError("-exec requires a command terminated by ';' or '+'");
+        if (terminator === ";") return async (entry) => {
+          const invocation = commandArguments.withValues(commandArguments.values.map((argument, index) => replaceArgument(typeof argument === "string" ? argument : commandArguments.bytes(index), "{}", entry.display)));
+          const childArguments = invocation.slice(1);
+          return (await execute({ ...context, command: invocation.args[0], args: childArguments.args, argumentValues: childArguments, env: { ...context.env } })).exitCode === 0;
+        };
+        if (command.at(-1) !== "{}" || command.slice(0, -1).some((argument) => argument.includes("{}"))) throw new UsageError("batched -exec requires exactly one final '{}' argument");
+        const pending = [];
+        let bytes = 0;
+        const flush = async () => {
+          if (!pending.length) return;
+          const childArguments = commandArguments.withValues([...commandArguments.values.slice(1, -1), ...pending]);
+          const result = await execute({ ...context, command: command[0], args: childArguments.args, argumentValues: childArguments, env: { ...context.env } });
+          if (result.exitCode !== 0) exitCode = 1;
+          pending.length = 0;
+          bytes = 0;
+        };
+        flushes.push(flush);
+        return async (entry) => {
+          const size = byteLength(entry.display) + 1;
+          if (pending.length >= 1e3 || bytes + size > 65536) await flush();
+          pending.push(entry.display);
+          bytes += size;
+          return true;
+        };
+      }
+      throw new UsageError(`unsupported expression '${token}'`);
+    };
+    const conjunction = () => {
+      let predicate = primary();
+      while (offset < args.length && !["-o", "-or", ",", ")"].includes(args[offset])) {
+        if (args[offset] === "-a" || args[offset] === "-and") offset++;
+        const left = predicate;
+        const right = primary();
+        predicate = (entry) => {
+          const l = left(entry);
+          return typeof l === "boolean" ? l ? right(entry) : false : l.then((lv) => lv ? right(entry) : false);
+        };
+        if (debugTree) trees.set(predicate, `AND(${trees.get(left)}, ${trees.get(right)})`);
+      }
+      return predicate;
+    };
+    const disjunction = () => {
+      let predicate = conjunction();
+      while (args[offset] === "-o" || args[offset] === "-or") {
+        offset++;
+        const left = predicate;
+        const right = conjunction();
+        predicate = (entry) => {
+          const l = left(entry);
+          return typeof l === "boolean" ? l ? true : right(entry) : l.then((lv) => lv ? true : right(entry));
+        };
+        if (debugTree) trees.set(predicate, `OR(${trees.get(left)}, ${trees.get(right)})`);
+      }
+      while (args[offset] === ",") {
+        offset++;
+        const left = predicate;
+        const right = conjunction();
+        predicate = (entry) => {
+          const l = left(entry);
+          return typeof l === "boolean" ? right(entry) : l.then(() => right(entry));
+        };
+        if (debugTree) trees.set(predicate, `LIST(${trees.get(left)}, ${trees.get(right)})`);
+      }
+      return predicate;
+    };
+    const evaluate = args.length ? disjunction() : () => true;
+    if (offset !== args.length) throw new UsageError(`unexpected expression '${args[offset]}'`);
+    for (const prepare of formats) await prepare();
+    if (deletes && prunes && !explicitDepth) throw new PublicDiagnostic("-delete implies -depth; -prune is ineffective unless -depth is explicitly supplied");
+    if (debugTree) {
+      const tree = trees.get(evaluate) ?? "true";
+      await context.stderr.write(new TextEncoder().encode(`find: virtual expression tree (evaluation order; no optimizer)
+${explicitAction ? tree : `AND(${tree}, implicit -print)`}
+`));
+    }
+    for (const reference of references.keys()) {
+      context.signal.throwIfAborted();
+      const path = pathOf(context, reference);
+      let stat;
+      try {
+        stat = await context.fs[follow !== "-P" ? "stat" : "lstat"](path, { signal: context.signal });
+      } catch (error) {
+        context.signal.throwIfAborted();
+        if (follow === "-P" || codeOf(error) !== "ENOENT") throw error;
+        stat = await context.fs.lstat(path, { signal: context.signal });
+      }
+      context.signal.throwIfAborted();
+      references.set(reference, stat.mtimeMs);
+    }
+    const useSharedPrintBuf = !sharedFindPrintBufInUse;
+    if (useSharedPrintBuf) sharedFindPrintBufInUse = true;
+    const printBuf = useSharedPrintBuf ? sharedFindPrintBuf : new Uint8Array(8192);
+    let printPos = 0;
+    const flushPrintBuffer = () => {
+      if (printPos === 0) return void 0;
+      const chunk = Uint8Array.prototype.slice.call(printBuf, 0, printPos);
+      printPos = 0;
+      const p = output(context, chunk);
+      return isSyncResolved(p) ? void 0 : p;
+    };
+    const appendPrintLine = async (escaped) => {
+      const maxNeed = escaped.length * 3 + 1;
+      if (printPos + maxNeed > printBuf.length) {
+        const fp = flushPrintBuffer();
+        if (fp) await fp;
+      }
+      if (maxNeed > printBuf.length) {
+        const p = output(context, `${escaped}
+`);
+        if (!isSyncResolved(p)) await p;
+        return;
+      }
+      printPos += writeUtf8(printBuf, printPos, escaped);
+      printBuf[printPos++] = 10;
+    };
+    const appendPrintChild = (escapedParent, escapedChild) => {
+      const maxNeed = (escapedParent.length + escapedChild.length) * 3 + 2;
+      if (printPos + maxNeed <= printBuf.length) {
+        printPos += writeUtf8(printBuf, printPos, escapedParent);
+        printBuf[printPos++] = 47;
+        printPos += writeUtf8(printBuf, printPos, escapedChild);
+        printBuf[printPos++] = 10;
+        return;
+      }
+      return (async () => {
+        const fp = flushPrintBuffer();
+        if (fp) await fp;
+        if (maxNeed > printBuf.length) {
+          const p = output(context, `${escapedParent}/${escapedChild}
+`);
+          if (!isSyncResolved(p)) await p;
+          return;
+        }
+        printPos += writeUtf8(printBuf, printPos, escapedParent);
+        printBuf[printPos++] = 47;
+        printPos += writeUtf8(printBuf, printPos, escapedChild);
+        printBuf[printPos++] = 10;
+      })();
+    };
+    const canSkipChildStat = !needsStat && !explicitAction && follow !== "-L";
+    const backing = getRuntimeBackingFileSystem(context.fs);
+    const maxEntriesLimit = maxDirectoryEntries ?? Infinity;
+    let uniformDirAdmitted = false;
+    const scratchChildEntry = { path: "", display: "", name: "", stat: SYNTHETIC_FILE_STAT, symlink: false, depth: 0, root: "", relative: "", prune: false };
+    const visit = async (display, depth, ancestors, root, relative, knownName, knownType) => {
+      if (quitRequested) return;
+      context.signal.throwIfAborted();
+      const path = pathOf(context, display);
+      try {
+        const memDirEntries = canSkipChildStat && backing !== void 0 && backing.capabilitiesFor === void 0 && context.fs.capabilities.readOnly !== true && context.fs.capabilities.readdir !== false && context.fs.capabilities.realpath !== false && path !== "/dev" && !path.startsWith("/dev/") ? tryGetMemoryDirectoryEntryNamesSync(backing, path) : void 0;
+        let stat;
+        let symlink;
+        if (memDirEntries !== void 0) {
+          if (!uniformDirAdmitted) {
+            assertCommandRequirements(context, filesystemCommandRequirements.ls, ["directory"]);
+            uniformDirAdmitted = true;
+          }
+          stat = SYNTHETIC_DIR_STAT;
+          symlink = false;
+        } else if (knownType !== void 0 && canSkipChildStat && !(knownType === "symlink" && follow === "-H" && depth === 0)) {
+          stat = syntheticStatFor(knownType);
+          symlink = knownType === "symlink";
+        } else {
+          stat = await context.fs.lstat(path, { signal: context.signal });
+          symlink = stat.type === "symlink";
+          if ((follow === "-L" || follow === "-H" && depth === 0) && symlink) {
+            try {
+              stat = await context.fs.stat(path, { signal: context.signal });
+            } catch (error) {
+              if (codeOf(error) !== "ENOENT") throw error;
+            }
+          }
+        }
+        const entry = { path, display, name: knownName ?? (basename(display) || "/"), stat, symlink, depth, root, relative, prune: false };
+        if (!depthFirst && depth >= minDepth) {
+          const res = evaluate(entry);
+          const ok = typeof res === "boolean" ? res : await res;
+          if (ok && !explicitAction) await appendPrintLine(escapeText(display, "display"));
+          if (quitRequested) return;
+        }
+        if (stat.type === "directory" && depth < maxDepth && (!entry.prune || depthFirst)) {
+          const physical = memDirEntries !== void 0 ? path : await context.fs.realpath(path, { signal: context.signal });
+          if (ancestors.has(physical)) throw new FsError("ELOOP", { path });
+          let next;
+          let parent = display;
+          while (parent.endsWith("/")) parent = parent.slice(0, -1);
+          const escapedParent = canSkipChildStat && !needsDisplay ? escapeText(parent, "display") : "";
+          const childDepth = depth + 1;
+          if (memDirEntries !== void 0 && memDirEntries.size <= maxEntriesLimit) {
+            const keyBase = findKeyScratchTop;
+            const keyEnd = stageAndSortFindKeys(memDirEntries, keyBase);
+            try {
+              for (let i = keyBase; i < keyEnd; i++) {
+                if (quitRequested) return;
+                const childName = findKeyScratch[i];
+                const childType = memDirEntries.get(childName).type;
+                if (childType === "file" && childDepth <= 1024) {
+                  if (childDepth >= minDepth) {
+                    scratchChildEntry.name = childName;
+                    scratchChildEntry.depth = childDepth;
+                    scratchChildEntry.root = root;
+                    scratchChildEntry.prune = false;
+                    if (needsDisplay) {
+                      const childDisplay2 = `${parent}/${childName}`;
+                      scratchChildEntry.display = childDisplay2;
+                      scratchChildEntry.path = pathOf(context, childDisplay2);
+                      scratchChildEntry.relative = relative ? `${relative}/${childName}` : childName;
+                    }
+                    const res = evaluate(scratchChildEntry);
+                    const ok = typeof res === "boolean" ? res : await res;
+                    if (ok) {
+                      if (needsDisplay) await appendPrintLine(escapeText(scratchChildEntry.display, "display"));
+                      else {
+                        const pending = appendPrintChild(escapedParent, escapeText(childName, "display"));
+                        if (pending) await pending;
+                      }
+                    }
+                  }
+                  continue;
+                }
+                next ??= new Set(ancestors).add(physical);
+                const childDisplay = `${parent}/${childName}`;
+                const childRel = relative ? `${relative}/${childName}` : childName;
+                await visit(childDisplay, childDepth, next, root, childRel, childName, childType);
+              }
+            } finally {
+              findKeyScratch.fill("", keyBase, keyEnd);
+              findKeyScratchTop = keyBase;
+            }
+          } else {
+            const children = await readDirectory(context, path, true);
+            for (const child of children) {
+              if (quitRequested) return;
+              if (canSkipChildStat && child.type === "file" && childDepth <= 1024) {
+                if (childDepth >= minDepth) {
+                  scratchChildEntry.name = child.name;
+                  scratchChildEntry.depth = childDepth;
+                  scratchChildEntry.root = root;
+                  scratchChildEntry.prune = false;
+                  if (needsDisplay) {
+                    const childDisplay2 = `${parent}/${child.name}`;
+                    scratchChildEntry.display = childDisplay2;
+                    scratchChildEntry.path = pathOf(context, childDisplay2);
+                    scratchChildEntry.relative = relative ? `${relative}/${child.name}` : child.name;
+                  }
+                  const res = evaluate(scratchChildEntry);
+                  const ok = typeof res === "boolean" ? res : await res;
+                  if (ok) {
+                    if (needsDisplay) await appendPrintLine(escapeText(scratchChildEntry.display, "display"));
+                    else {
+                      const pending = appendPrintChild(escapedParent, escapeText(child.name, "display"));
+                      if (pending) await pending;
+                    }
+                  }
+                }
+                continue;
+              }
+              next ??= new Set(ancestors).add(physical);
+              const childDisplay = `${parent}/${child.name}`;
+              const childRel = relative ? `${relative}/${child.name}` : child.name;
+              await visit(childDisplay, childDepth, next, root, childRel, child.name, child.type);
+            }
+          }
+        }
+        if (depthFirst && depth >= minDepth) {
+          const res = evaluate(entry);
+          const ok = typeof res === "boolean" ? res : await res;
+          if (ok && !explicitAction) await appendPrintLine(escapeText(display, "display"));
+        }
+        if (depth === 0 && printPos > 0) {
+          const fp = flushPrintBuffer();
+          if (fp) await fp;
+        }
+      } catch (error) {
+        const fp = flushPrintBuffer();
+        if (fp) await fp;
+        await diagnostic(context, error);
+        exitCode = 1;
+      }
+    };
+    try {
+      for (const root of roots) {
+        if (quitRequested) break;
+        await visit(root, 0, /* @__PURE__ */ new Set(), root, "");
+      }
+      const fp = flushPrintBuffer();
+      if (fp) await fp;
+      for (const flush of flushes) await flush();
+      return { exitCode };
+    } finally {
+      if (useSharedPrintBuf) sharedFindPrintBufInUse = false;
+    }
+  }
+}
+function evalSyncFind(rawArgs, cwd, inspectNode, allowNullBytes = false) {
+  try {
+    const args = [...rawArgs];
+    let follow = "-P";
+    while (args[0] === "-P" || args[0] === "-L" || args[0] === "-H") {
+      follow = args.shift();
+    }
+    if (args[0] === "-D") return void 0;
+    if (args[0] === "--") args.shift();
+    const roots = [];
+    while (args.length && !args[0].startsWith("-") && args[0] !== "!" && args[0] !== "(") {
+      roots.push(args.shift());
+    }
+    if (roots.length === 0) roots.push(".");
+    if (roots.length > 16) return void 0;
+    for (let i = 0; i < roots.length; i++) {
+      const rp = resolvePath(cwd, roots[i]);
+      if (rp === "/dev" || rp.startsWith("/dev/")) return void 0;
+    }
+    let maxDepth = Infinity;
+    let minDepth = 0;
+    let depthFirst = false;
+    let explicitAction = false;
+    let quitNow = false;
+    let offset = 0;
+    let customOut = "";
+    let usedCustomOut = false;
+    const outLines = [];
+    const primary = () => {
+      const token = args[offset++];
+      if (token === void 0) throw new Error("eof");
+      if (token === "(") {
+        const inner = disjunction();
+        if (args[offset++] !== ")") throw new Error("unclosed");
+        return inner;
+      }
+      if (token === "!" || token === "-not") {
+        const inner = primary();
+        return (entry) => !inner(entry);
+      }
+      if (token === "-depth" || token === "-d") {
+        depthFirst = true;
+        return () => true;
+      }
+      if (token === "-maxdepth" || token === "-mindepth") {
+        const operand = args[offset++];
+        if (operand === void 0 || !/^[0-9]+$/.test(operand)) throw new Error("depth");
+        const parsed = Number(operand);
+        if (token === "-maxdepth") maxDepth = parsed;
+        else minDepth = parsed;
+        return () => true;
+      }
+      if (token === "-true" || token === "-false") return () => token === "-true";
+      if (token === "-empty") {
+        return (entry) => entry.type === "directory" ? entry.childrenCount === 0 : entry.type === "file" && entry.size === 0;
+      }
+      if (token === "-prune") {
+        return (entry) => {
+          entry.prune = true;
+          return true;
+        };
+      }
+      if (token === "-quit") {
+        explicitAction = true;
+        return () => {
+          quitNow = true;
+          return true;
+        };
+      }
+      if (token === "-print") {
+        explicitAction = true;
+        return (entry) => {
+          if (usedCustomOut) customOut += escapeText(entry.display, "display") + "\n";
+          else outLines.push(escapeText(entry.display, "display"));
+          return true;
+        };
+      }
+      if (token === "-print0") {
+        if (!allowNullBytes) throw new Error("print0");
+        explicitAction = true;
+        usedCustomOut = true;
+        return (entry) => {
+          customOut += escapeText(entry.display, "display") + "\0";
+          return true;
+        };
+      }
+      if (token === "-printf") {
+        const fmt = args[offset++];
+        if (fmt === void 0) throw new Error("printf");
+        for (let k = 0; k < fmt.length; k++) {
+          if (fmt[k] === "\\") {
+            const nxt = fmt[++k];
+            if (nxt !== "n" && nxt !== "t" && nxt !== "r" && nxt !== "\\") throw new Error("printf-esc");
+          } else if (fmt[k] === "%") {
+            const nxt = fmt[++k];
+            if (!nxt || !"pfhPsdym%".includes(nxt)) throw new Error("printf-dir");
+          }
+        }
+        explicitAction = true;
+        usedCustomOut = true;
+        return (entry) => {
+          let rendered = "";
+          for (let k = 0; k < fmt.length; k++) {
+            if (fmt[k] === "\\") {
+              const nxt = fmt[++k];
+              rendered += nxt === "n" ? "\n" : nxt === "t" ? "	" : nxt === "r" ? "\r" : "\\";
+            } else if (fmt[k] === "%") {
+              const nxt = fmt[++k];
+              if (nxt === "%") rendered += "%";
+              else if (nxt === "p") rendered += entry.display;
+              else if (nxt === "f") rendered += entry.name;
+              else if (nxt === "h") {
+                const slash = entry.display.lastIndexOf("/");
+                rendered += slash < 0 ? "." : slash === 0 ? "/" : entry.display.slice(0, slash);
+              } else if (nxt === "P") rendered += entry.relative;
+              else if (nxt === "s") rendered += String(entry.size);
+              else if (nxt === "d") rendered += String(entry.depth);
+              else if (nxt === "y") rendered += entry.type === "directory" ? "d" : entry.type === "symlink" ? "l" : "f";
+              else if (nxt === "m") rendered += (entry.mode & 4095).toString(8).padStart(3, "0");
+            } else {
+              rendered += fmt[k];
+            }
+          }
+          customOut += rendered;
+          return true;
+        };
+      }
+      if (token === "-regex" || token === "-iregex") {
+        const operand = args[offset++];
+        if (operand === void 0) throw new Error("regex");
+        const re = new RegExp("^(?:" + operand + ")$", token === "-iregex" ? "i" : "");
+        return (entry) => re.test(entry.display);
+      }
+      if (token === "-name" || token === "-iname" || token === "-path" || token === "-wholename" || token === "-ipath" || token === "-iwholename" || token === "-type" || token === "-size" || token === "-links" || token === "-perm") {
+        const operand = args[offset++];
+        if (operand === void 0) throw new Error("operand");
+        if (token === "-type") {
+          const types = { f: "file", d: "directory", l: "symlink" };
+          const specialModes = { c: 8192, b: 24576, p: 4096, s: 49152 };
+          const requested = operand.split(",");
+          if (requested.some((t) => t.length !== 1 || !(t in types || t in specialModes))) throw new Error("type");
+          return (entry) => requested.some(
+            (t) => specialModes[t] ? (entry.mode & 61440) === specialModes[t] : entry.type === types[t]
+          );
+        }
+        if (token === "-size") {
+          const comparison = operand[0] === "+" || operand[0] === "-" ? operand[0] : "";
+          const units = { c: 1, w: 2, b: 512, k: 1024, M: 1048576, G: 1073741824 };
+          const suffix = operand.at(-1);
+          const unit = units[suffix] ?? 512;
+          const digits = operand.slice(comparison ? 1 : 0, units[suffix] === void 0 ? void 0 : -1);
+          if (!digits || !/^[0-9]+$/.test(digits)) throw new Error("size");
+          const size = Number(digits);
+          return (entry) => comparison === "+" ? Math.ceil(entry.size / unit) > size : comparison === "-" ? Math.ceil(entry.size / unit) < size : Math.ceil(entry.size / unit) === size;
+        }
+        if (token === "-links") {
+          const comparison = operand[0] === "+" || operand[0] === "-" ? operand[0] : "";
+          const digits = comparison ? operand.slice(1) : operand;
+          if (!digits || !/^[0-9]+$/.test(digits)) throw new Error("links");
+          const count = Number(digits);
+          return (entry) => comparison === "+" ? entry.nlink > count : comparison === "-" ? entry.nlink < count : entry.nlink === count;
+        }
+        if (token === "-perm") {
+          const comparison = operand[0] === "-" || operand[0] === "/" || operand[0] === "+" && /^[0-7]/u.test(operand.slice(1)) ? operand[0] : "";
+          const spec = comparison ? operand.slice(1) : operand;
+          const evalMode = modeChange(spec, 0);
+          return (entry) => {
+            const bits = evalMode({ mode: 0, type: entry.type });
+            const permissions = entry.mode & 4095;
+            return comparison === "-" ? (permissions & bits) === bits : comparison === "/" || comparison === "+" ? bits === 0 || (permissions & bits) !== 0 : permissions === bits;
+          };
+        }
+        const ignoreCase = token === "-iname" || token === "-ipath" || token === "-iwholename";
+        const fn = getCachedFindPattern(operand, ignoreCase);
+        if (!fn) throw new Error("pattern");
+        const useName = token === "-name" || token === "-iname";
+        return (entry) => fn(useName ? entry.name : entry.display);
+      }
+      throw new Error("unsupported");
+    };
+    const conjunction = () => {
+      let pred = primary();
+      while (offset < args.length && !["-o", "-or", ",", ")"].includes(args[offset])) {
+        if (args[offset] === "-a" || args[offset] === "-and") offset++;
+        const left = pred;
+        const right = primary();
+        pred = (entry) => left(entry) && right(entry);
+      }
+      return pred;
+    };
+    const disjunction = () => {
+      let pred = conjunction();
+      while (args[offset] === "-o" || args[offset] === "-or") {
+        offset++;
+        const left = pred;
+        const right = conjunction();
+        pred = (entry) => left(entry) || right(entry);
+      }
+      while (args[offset] === ",") {
+        offset++;
+        const left = pred;
+        const right = conjunction();
+        pred = (entry) => {
+          left(entry);
+          return right(entry);
+        };
+      }
+      return pred;
+    };
+    const evaluate = args.length ? disjunction() : () => true;
+    if (offset !== args.length) return void 0;
+    let visitedNodes = 0;
+    const visit = (display, relative, depth, ancestors, knownName) => {
+      if (quitNow) return true;
+      if (++visitedNodes > 1024) return false;
+      const absPath = resolvePath(cwd, display);
+      if (absPath === "/dev" || absPath.startsWith("/dev/")) return false;
+      const shouldFollow = follow === "-L" || follow === "-H" && depth === 0;
+      let info = inspectNode(absPath, false);
+      if (!info) return false;
+      if (shouldFollow && info.type === "symlink") {
+        const followed = inspectNode(absPath, true);
+        if (followed) info = followed;
+      }
+      const entry = {
+        display,
+        name: knownName ?? (basename(display) || "/"),
+        relative,
+        depth,
+        type: info.type,
+        size: info.size,
+        mode: info.mode,
+        nlink: info.nlink ?? (info.type === "directory" ? 2 : 1),
+        childrenCount: info.children ? info.children.length : 0,
+        prune: false
+      };
+      if (!depthFirst && depth >= minDepth) {
+        const ok = evaluate(entry);
+        if (ok && !explicitAction) outLines.push(escapeText(display, "display"));
+        if (quitNow) return true;
+      }
+      if (info.type === "directory" && depth < maxDepth && (!entry.prune || depthFirst)) {
+        const ino = info.ino ?? -1;
+        if (ino !== -1 && ancestors.has(ino)) return false;
+        const nextAncestors = ino !== -1 ? new Set(ancestors).add(ino) : ancestors;
+        let parent = display;
+        while (parent.endsWith("/")) parent = parent.slice(0, -1);
+        const sorted = info.children ? [...info.children].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0) : [];
+        for (let i = 0; i < sorted.length; i++) {
+          if (quitNow) break;
+          const child = sorted[i];
+          const childDisplay = `${parent}/${child.name}`;
+          const childRel = relative ? `${relative}/${child.name}` : child.name;
+          if (!visit(childDisplay, childRel, depth + 1, nextAncestors, child.name)) return false;
+        }
+      }
+      if (!quitNow && depthFirst && depth >= minDepth) {
+        const ok = evaluate(entry);
+        if (ok && !explicitAction) outLines.push(escapeText(display, "display"));
+      }
+      return true;
+    };
+    for (let i = 0; i < roots.length; i++) {
+      if (quitNow) break;
+      if (!visit(roots[i], "", 0, /* @__PURE__ */ new Set())) return void 0;
+    }
+    if (usedCustomOut) return customOut;
+    return outLines.length > 0 ? outLines.join("\n") + "\n" : "";
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  createFindDefinitions,
+  evalSyncFind
+};