@poe-platform/safe-bash 0.1.812 → 0.1.813

package/dist/safe-bash/command-chunks/{chunk-47NEG4UO.js → chunk-3JST2Q7G.js}

@@ -16,8 +16,8 @@ import {
 } from "./chunk-VXIC7SS3.js";
 
 // packages/safe-bash-command-diff/src/diff.ts
-import { closeDocumentResources as closeDocumentResources2 } from "../../safe-bash-diff-engine/document.js";
-import { PagedStorage as PagedStorage3 } from "@poe-platform/safe-fs/storage";
+import { closeDocumentResources as closeDocumentResources3 } from "../../safe-bash-diff-engine/document.js";
+import { PagedStorage as PagedStorage4 } from "@poe-platform/safe-fs/storage";
 
 // packages/safe-bash-command-diff/src/indexed.ts
 import { writeDiagnostic } from "../../safe-bash-contracts/escaping.js";
@@ -156,6 +156,7 @@ async function renderEd(next, count, group, budget, append) {
   for (let index = count - 1; index >= 0; index--) {
     const change = await group(index);
     budget.hunk();
+    if (change.ignored) continue;
     const start = change.oldStart + 1, end = change.oldStart + change.oldCount;
     const range2 = change.oldCount > 1 ? `${start},${end}` : `${start}`;
     await append(encodeBytes2(`${change.oldCount ? range2 : change.oldStart}${change.oldCount ? change.newCount ? "c" : "d" : "a"}
@@ -219,26 +220,26 @@ async function renderSideBySide(old, next, count, group, options, budget, append
     return (await document.data.read(8 + bounds.end - 1, 1))[0] === 10;
   };
   const row = async (left, right, common) => {
-    if (common && options.suppressCommon) return;
+    if (common && left !== void 0 && right !== void 0 && options.suppressCommon) return;
     if (options.width > budget.limits.maxOutputBytes) throw new ToolError("output byte limit exceeded");
     const leftLf = await terminated(old, left), rightLf = await terminated(next, right);
-    const marker = common ? " " : left === void 0 ? ">" : right === void 0 ? "<" : !leftLf && rightLf ? "\\" : leftLf && !rightLf ? "/" : "|";
+    const marker = common ? left === void 0 ? ")" : right === void 0 ? "(" : " " : left === void 0 ? ">" : right === void 0 ? "<" : !leftLf && rightLf ? "\\" : leftLf && !rightLf ? "/" : "|";
     const colored = options.color && (marker === "<" || marker === ">");
     if (colored) await append(encodeBytes2(`\x1B[${marker === "<" ? 31 : 32}m`));
     const column = left === void 0 ? 0 : await clipped(old, left, half, options.expand, utf8, append);
-    if (common && options.leftColumn) {
+    if (marker === " " && options.leftColumn) {
       await padding(column, markerColumn);
       await append(encodeBytes2("(" + (leftLf ? "\n" : "")));
       return;
     }
-    if (!common) {
+    if (marker !== " ") {
       await padding(column, markerColumn);
       await append(encodeBytes2(marker));
     }
     if (right !== void 0) {
       const bounds = await next.line(right);
       if (bounds.end - bounds.start > Number(rightLf)) {
-        await padding(common ? column : markerColumn + 1, rightStart);
+        await padding(marker === " " ? column : markerColumn + 1, rightStart);
         await clipped(next, right, half, options.expand, utf8, append);
       }
     }
@@ -246,9 +247,20 @@ async function renderSideBySide(old, next, count, group, options, budget, append
     if (colored) await append(encodeBytes2("\x1B[0m"));
   };
   let oldPosition = 0, newPosition = 0;
-  for (let index = 0; index < count; index++) {
-    const change = await group(index);
-    while (oldPosition < change.oldStart) await row(oldPosition++, newPosition++, true);
+  for (let index = 0; index <= count; ) {
+    let change;
+    while (index < count) {
+      const candidate = await group(index++);
+      if (!candidate.ignored) {
+        change = candidate;
+        break;
+      }
+    }
+    const oldEnd = change?.oldStart ?? old.length, newEnd = change?.newStart ?? next.length;
+    while (oldPosition < oldEnd || newPosition < newEnd) {
+      await row(oldPosition < oldEnd ? oldPosition++ : void 0, newPosition < newEnd ? newPosition++ : void 0, true);
+    }
+    if (!change) break;
     budget.hunk();
     for (let offset = 0; offset < Math.max(change.oldCount, change.newCount); offset++) {
       await row(
@@ -260,12 +272,85 @@ async function renderSideBySide(old, next, count, group, options, budget, append
     oldPosition = change.oldStart + change.oldCount;
     newPosition = change.newStart + change.newCount;
   }
-  while (oldPosition < old.length) await row(oldPosition++, newPosition++, true);
 }
 
 // packages/safe-bash-command-diff/src/indexed.ts
-import { PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
-import { IndexedDocument, closeDocumentResources } from "../../safe-bash-diff-engine/document.js";
+import { encodeBytes as encodeBytes3 } from "../../safe-bash-io-engine/byte-encoding.js";
+
+// packages/safe-bash-command-diff/src/indexed-pattern.ts
+import { IntegerTable, PagedStorage as PagedStorage2, PagedStorageCache } from "@poe-platform/safe-fs/storage";
+import { closeDocumentResources } from "../../safe-bash-diff-engine/document.js";
+async function matchesPattern(pattern, document, start, end, utf8, budget) {
+  if (await pattern.supportsStreamTest(budget)) return pattern.testStream(documentText(document, start, end, utf8), budget);
+  const cache = new PagedStorageCache(16);
+  const text = new PagedStorage2(budget.context, 16, cache);
+  const records = new PagedStorage2(budget.context, 16, cache);
+  const index = new PagedStorage2(budget.context, 16, cache);
+  const hashes = new IntegerTable(index, 256);
+  let length = 0, cursor = 8, tail = 8;
+  const record = async (offset) => {
+    const header = await records.read(offset, 16);
+    const size = new DataView(header.buffer).getFloat64(8, true);
+    const result = new Uint8Array(size);
+    for (let at = 0; at < size; at += 16384) result.set(await records.read(offset + at, Math.min(16384, size - at)), at);
+    return result;
+  };
+  try {
+    for await (const chunk of documentText(document, start, end, utf8)) {
+      for (let at = 0; at < chunk.length; at += 8192) {
+        const count = Math.min(8192, chunk.length - at), bytes = new Uint8Array(count * 2), view = new DataView(bytes.buffer);
+        for (let unit = 0; unit < count; unit++) view.setUint16(unit * 2, chunk.charCodeAt(at + unit), true);
+        await text.append(bytes);
+        length += count;
+        budget.step(count);
+        const pause = budget.checkpoint();
+        if (pause) await pause;
+      }
+    }
+    return await pattern.testStored({
+      length,
+      async read(start2, count) {
+        const bytes = await text.read(8 + start2 * 2, count * 2), view = new DataView(bytes.buffer);
+        let result = "";
+        for (let at = 0; at < count; at++) result += String.fromCharCode(view.getUint16(at * 2, true));
+        return result;
+      },
+      async enqueue(state) {
+        const bytes = new Uint8Array(16 + state.length * 8), view = new DataView(bytes.buffer);
+        view.setFloat64(8, bytes.length, true);
+        for (let at = 0; at < state.length; at++) view.setFloat64(16 + at * 8, state[at], true);
+        let hash = 2166136261;
+        for (let at = 8; at < bytes.length; at++) hash = Math.imul(hash ^ bytes[at], 16777619) >>> 0;
+        const head = Number(await hashes.get(BigInt(hash)) ?? 0n);
+        for (let offset2 = head; offset2; ) {
+          const previous = await record(offset2);
+          budget.step(previous.length);
+          const pause = budget.checkpoint();
+          if (pause) await pause;
+          if (previous.length === bytes.length && previous.subarray(8).every((byte, at) => byte === bytes[at + 8])) return;
+          offset2 = new DataView(previous.buffer).getFloat64(0, true);
+        }
+        view.setFloat64(0, head, true);
+        const offset = await records.append(bytes);
+        tail = offset + bytes.length;
+        await hashes.set(BigInt(hash), BigInt(offset));
+        budget.step(bytes.length);
+      },
+      async dequeue() {
+        if (cursor === tail) return void 0;
+        const bytes = await record(cursor), view = new DataView(bytes.buffer);
+        cursor += bytes.length;
+        return Array.from({ length: (bytes.length - 16) / 8 }, (_, at) => view.getFloat64(16 + at * 8, true));
+      }
+    }, budget);
+  } finally {
+    await closeDocumentResources([text, records, index]);
+  }
+}
+
+// packages/safe-bash-command-diff/src/indexed.ts
+import { PagedStorage as PagedStorage3 } from "@poe-platform/safe-fs/storage";
+import { IndexedDocument, closeDocumentResources as closeDocumentResources2 } from "../../safe-bash-diff-engine/document.js";
 import { ToolError as ToolError2 } from "../../safe-bash-diff-engine/shared.js";
 var encoder = new TextEncoder();
 async function buildGroups(old, next, matrix, groups, budget, admitLines = true) {
@@ -304,7 +389,7 @@ async function buildGroups(old, next, matrix, groups, budget, admitLines = true)
   let group;
   const flush = async () => {
     if (!group) return;
-    const bytes = new Uint8Array(32), view = new DataView(bytes.buffer);
+    const bytes = new Uint8Array(40), view = new DataView(bytes.buffer);
     view.setFloat64(0, group.oldStart, true);
     view.setFloat64(8, group.newStart, true);
     view.setFloat64(16, group.oldCount, true);
@@ -338,6 +423,16 @@ async function buildGroups(old, next, matrix, groups, budget, admitLines = true)
 function range(start, count, unified = false) {
   return count === 0 ? `${start}${unified ? ",0" : ""}` : count === 1 ? `${start + 1}` : `${start + 1},${unified ? count : start + count}`;
 }
+async function blank(document, position, whitespace) {
+  const bounds = await document.line(position);
+  let end = bounds.end;
+  if ((await document.data.read(8 + end - 1, 1))[0] === 10) end--;
+  if (!whitespace) return bounds.start === end;
+  for await (const bytes of document.range(bounds.start, end)) {
+    for (const byte of bytes) if (byte !== 32 && byte !== 9 && byte !== 11 && byte !== 12 && byte !== 13) return false;
+  }
+  return true;
+}
 async function line(document, position, prefix, output, color) {
   const { append, options, utf8 } = output;
   const bounds = await document.line(position);
@@ -364,15 +459,15 @@ async function indexedDiff(budget, options, left, right, nested, append, sources
     else await document.load(input);
   };
   const keys = [];
-  const matrix = new PagedStorage2(budget.context, 8), groups = new PagedStorage2(budget.context, 16);
+  const matrix = new PagedStorage3(budget.context, 8), groups = new PagedStorage3(budget.context, 16);
   budget.context.registerCleanup?.(() => matrix.close());
   budget.context.registerCleanup?.(() => groups.close());
   const text = async (value, color) => {
     await append(encoder.encode(color === void 0 ? value : colorText(value, color, options)));
   };
   const group = async (index) => {
-    const bytes = await groups.read(8 + index * 32, 32), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    return { oldStart: view.getFloat64(0, true), newStart: view.getFloat64(8, true), oldCount: view.getFloat64(16, true), newCount: view.getFloat64(24, true) };
+    const bytes = await groups.read(8 + index * 40, 40), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return { oldStart: view.getFloat64(0, true), newStart: view.getFloat64(8, true), oldCount: view.getFloat64(16, true), newCount: view.getFloat64(24, true), ignored: !!view.getUint8(32) };
   };
   try {
     await load(old, sources.left);
@@ -428,7 +523,7 @@ async function indexedDiff(budget, options, left, right, nested, append, sources
       await oldKeys.load(comparisonSource(old, options, utf8));
       await nextKeys.load(comparisonSource(next, options, utf8));
     }
-    if (options.brief) {
+    if (options.brief && !options.ignoreBlank && !options.ignorePatterns.length) {
       let same = oldKeys.size === nextKeys.size && oldKeys.length === nextKeys.length;
       for (let index = 0; same && index < oldKeys.length; index++) same = await oldKeys.equal(index, nextKeys, index);
       if (!same) {
@@ -441,20 +536,53 @@ async function indexedDiff(budget, options, left, right, nested, append, sources
     }
     const render = { append, options, utf8: old.validUtf8 && next.validUtf8 };
     const count = sameRaw ? 0 : await buildGroups(oldKeys, nextKeys, matrix, groups, budget, !counted);
+    let visible = count;
+    if (options.ignoreBlank || options.ignorePatterns.length) for (let index = 0; index < count; index++) {
+      const change = await group(index);
+      let ignored = true;
+      for (const [document, start, length] of [[old, change.oldStart, change.oldCount], [next, change.newStart, change.newCount]]) {
+        for (let row = 0; row < length; row++) {
+          budget.step();
+          let matches = options.ignoreBlank && await blank(document, start + row, options.whitespace !== "exact");
+          const bounds = await document.line(start + row);
+          const bodyEnd = bounds.end - Number((await document.data.read(8 + bounds.end - 1, 1))[0] === 10);
+          for (const pattern of options.ignorePatterns) {
+            if (await matchesPattern(pattern, document, bounds.start, bodyEnd, render.utf8, budget)) {
+              matches = true;
+              break;
+            }
+          }
+          ignored &&= matches;
+          const checkpoint = budget.checkpoint();
+          if (checkpoint) await checkpoint;
+        }
+      }
+      if (ignored) {
+        visible--;
+        await groups.write(8 + index * 40 + 32, new Uint8Array([1]));
+      }
+    }
+    if (options.brief) {
+      if (visible) await text(`Files ${options.labels[0] ?? left} and ${options.labels[1] ?? right} differ
+`);
+      else if (options.reportSame && !trouble) await text(`Files ${options.labels[0] ?? left} and ${options.labels[1] ?? right} are identical
+`);
+      return { different: visible > 0, trouble };
+    }
     if (options.format === "side") {
-      if (nested && (count || !options.suppressCommon)) await text(["diff", ...options.optionArgs.map(quoteDiffArgument), quoteDiffName(options.labels[0] ?? left), quoteDiffName(options.labels[1] ?? right)].join(" ") + "\n");
-      await renderSideBySide(old, next, count, group, options, budget, append);
-      if (!count && options.reportSame) await text(`Files ${options.labels[0] ?? left} and ${options.labels[1] ?? right} are identical
+      if (nested && (visible || !options.suppressCommon)) await text(["diff", ...options.optionArgs.map(quoteDiffArgument), quoteDiffName(options.labels[0] ?? left), quoteDiffName(options.labels[1] ?? right)].join(" ") + "\n");
+      if (!nested || visible || !options.suppressCommon) await renderSideBySide(old, next, count, group, options, budget, append);
+      if (!visible && options.reportSame && !trouble) await text(`Files ${options.labels[0] ?? left} and ${options.labels[1] ?? right} are identical
 `);
-      return { different: count > 0, trouble };
+      return { different: visible > 0, trouble };
     }
-    if (!count) {
+    if (!visible && (options.format !== "ifdef" || !count)) {
       if (options.format === "ifdef") for await (const bytes of old.range(0, old.size)) await append(bytes);
       if (options.reportSame && !trouble) await text(`Files ${options.labels[0] ?? left} and ${options.labels[1] ?? right} are identical
 `);
       return { different: false, trouble };
     }
-    if (nested) await text(["diff", ...options.optionArgs.map(quoteDiffArgument), quoteDiffName(options.labels[0] ?? left), quoteDiffName(options.labels[1] ?? right)].join(" ") + "\n");
+    if (nested && visible) await text(["diff", ...options.optionArgs.map(quoteDiffArgument), quoteDiffName(options.labels[0] ?? left), quoteDiffName(options.labels[1] ?? right)].join(" ") + "\n");
     if (options.format === "ed") {
       await renderEd(next, count, group, budget, append);
       return { different: true, trouble };
@@ -463,6 +591,7 @@ async function indexedDiff(budget, options, left, right, nested, append, sources
       for (let index = 0; index < count; index++) {
         const change = await group(index);
         budget.hunk();
+        if (change.ignored) continue;
         await text(`${range(change.oldStart, change.oldCount)}${change.oldCount === 0 ? "a" : change.newCount === 0 ? "d" : "c"}${range(change.newStart, change.newCount)}
 `, 36);
         for (let row = 0; row < change.oldCount; row++) await line(old, change.oldStart + row, "< ", render, 31);
@@ -480,6 +609,13 @@ async function indexedDiff(budget, options, left, right, nested, append, sources
         const oldEnd = change.oldCount ? (await old.line(change.oldStart + change.oldCount - 1)).end : oldStart;
         const newStart = change.newStart < next.length ? (await next.line(change.newStart)).start : next.size;
         const newEnd = change.newCount ? (await next.line(change.newStart + change.newCount - 1)).end : newStart;
+        if (change.ignored) {
+          if (options.format === "ifdef") {
+            for await (const bytes of old.range(position, oldEnd)) await append(bytes);
+            position = oldEnd;
+          }
+          continue;
+        }
         if (options.format === "rcs") {
           if (change.oldCount) await text(`d${change.oldStart + 1} ${change.oldCount}
 `);
@@ -502,7 +638,9 @@ async function indexedDiff(budget, options, left, right, nested, append, sources
         }
       }
       if (options.format === "ifdef") for await (const bytes of old.range(position, old.size)) await append(bytes);
-      return { different: true, trouble };
+      if (!visible && options.reportSame && !trouble) await text(`Files ${options.labels[0] ?? left} and ${options.labels[1] ?? right} are identical
+`);
+      return { different: visible > 0, trouble };
     }
     const unified = options.format === "unified";
     await text(`${unified ? "---" : "***"} ${options.labels[0] ?? quoteDiffName(sources.left === void 0 ? "/dev/null" : left)}
@@ -511,20 +649,49 @@ async function indexedDiff(budget, options, left, right, nested, append, sources
 `, 1);
     for (let index = 0; index < count; ) {
       const first = await group(index);
-      let last = first, end = index + 1;
+      let last = first, end = index + 1, changed = !first.ignored;
       while (end < count) {
         const following = await group(end);
-        if (following.oldStart - last.oldStart - last.oldCount > 2 * options.context) break;
+        const gap = following.oldStart - last.oldStart - last.oldCount;
+        if (gap > 2 * options.context || following.ignored && gap >= options.context) break;
+        changed ||= !following.ignored;
         last = following;
         end++;
       }
+      if (!changed) {
+        index = end;
+        continue;
+      }
       const lead = Math.min(options.context, first.oldStart);
       const trail = Math.min(options.context, old.length - last.oldStart - last.oldCount);
       const oldStart = first.oldStart - lead, newStart = first.newStart - lead;
       const oldEnd = last.oldStart + last.oldCount + trail, newEnd = last.newStart + last.newCount + trail;
       budget.hunk();
+      let heading = "";
+      for (let position = oldStart - 1; options.functions.length && position >= 0; position--) {
+        const bounds = await old.line(position);
+        let matches = false;
+        for (const pattern of options.functions) {
+          if (await matchesPattern(pattern, old, bounds.start, bounds.end, render.utf8, budget)) {
+            matches = true;
+            break;
+          }
+        }
+        if (matches) {
+          const bodyEnd = bounds.end - Number((await old.data.read(8 + bounds.end - 1, 1))[0] === 10);
+          for await (const block of documentText(old, bounds.start, bodyEnd, render.utf8)) {
+            heading += block.slice(0, 40 - heading.length);
+            if (heading.length === 40) break;
+          }
+          break;
+        }
+        budget.step();
+        const pause = budget.checkpoint();
+        if (pause) await pause;
+      }
       if (unified) {
         await text(`@@ -${range(oldStart, oldEnd - oldStart, true)} +${range(newStart, newEnd - newStart, true)} @@`, 36);
+        if (heading) await append(encodeBytes3(` ${heading}`, render.utf8 ? "utf8" : "latin1"));
         await text("\n");
         let position = oldStart;
         for (let at = index; at < end; at++) {
@@ -535,18 +702,20 @@ async function indexedDiff(budget, options, left, right, nested, append, sources
         }
         while (position < oldEnd) await line(old, position++, " ", render);
       } else {
-        await text("***************\n");
+        await text("***************");
+        if (heading) await append(encodeBytes3(` ${heading}`, render.utf8 ? "utf8" : "latin1"));
+        await text("\n");
         await text(`*** ${range(oldStart, oldEnd - oldStart)} ****
 `, 36);
         for (const side of ["old", "new"]) {
           if (side === "new") await text(`--- ${range(newStart, newEnd - newStart)} ----
 `, 36);
-          let changed = false;
+          let changed2 = false;
           for (let at = index; at < end; at++) {
             const change = await group(at);
-            changed ||= (side === "old" ? change.oldCount : change.newCount) > 0;
+            changed2 ||= (side === "old" ? change.oldCount : change.newCount) > 0;
           }
-          if (!changed) continue;
+          if (!changed2) continue;
           const document = side === "old" ? old : next;
           let position = side === "old" ? oldStart : newStart;
           for (let at = index; at < end; at++) {
@@ -564,7 +733,7 @@ async function indexedDiff(budget, options, left, right, nested, append, sources
     }
     return { different: true, trouble };
   } finally {
-    await closeDocumentResources([
+    await closeDocumentResources2([
       ...rawOld === stdin.document ? [] : [rawOld],
       ...rawNext === stdin.document ? [] : [rawNext],
       ...keys,
@@ -638,7 +807,7 @@ import { basename, createCommandArguments, isFsError, writeBytes } from "../../s
 import { publicDiagnosticMessage } from "../../safe-bash-contracts/diagnostics.js";
 import { writeDiagnostic as writeDiagnostic2 } from "../../safe-bash-contracts/escaping.js";
 import { ToolError as ToolError3, definition, host, inspect, sameIdentity } from "../../safe-bash-diff-engine/shared.js";
-import { byteLength, decodeBytes as decodeBytes2, encodeBytes as encodeBytes3 } from "../../safe-bash-io-engine/byte-encoding.js";
+import { byteLength, decodeBytes as decodeBytes2, encodeBytes as encodeBytes4 } from "../../safe-bash-io-engine/byte-encoding.js";
 import { pathOf } from "../../safe-bash-io-engine/internal.js";
 import { Pattern } from "../../safe-bash-regex-engine/text/regex.js";
 async function comparisonLines(lines, options, budget) {
@@ -804,13 +973,13 @@ function childPath(directory, name) {
   return `${directory.slice(0, end)}/${name}`;
 }
 async function run(context, budget) {
-  const storage = new PagedStorage3(context, 32);
+  const storage = new PagedStorage4(context, 32);
   const stdin = {};
   context.registerCleanup?.(() => storage.close());
   try {
     return await runStored(context, budget, storage, stdin);
   } finally {
-    await closeDocumentResources2([storage, ...stdin.document ? [stdin.document] : []]);
+    await closeDocumentResources3([storage, ...stdin.document ? [stdin.document] : []]);
   }
 }
 async function runStored(context, budget, storage, stdinDocument) {
@@ -824,7 +993,7 @@ async function runStored(context, budget, storage, stdinDocument) {
     outputSize += bytes.length;
   };
   const append = async (text) => {
-    await appendBytes(encodeBytes3(text, encoding));
+    await appendBytes(encodeBytes4(text, encoding));
   };
   let different = false;
   let trouble = false;
@@ -943,7 +1112,7 @@ async function runStored(context, budget, storage, stdinDocument) {
           budget.step();
           if (!entry.name || entry.name === "." || entry.name === ".." || /[/\\\0\r\n\t]/u.test(entry.name)) throw new ToolError3("unsafe directory entry name");
           let excluded = false;
-          const byteName = exclusions.length ? decodeBytes2(encodeBytes3(entry.name), "latin1") : entry.name;
+          const byteName = exclusions.length ? decodeBytes2(encodeBytes4(entry.name), "latin1") : entry.name;
           for (const pattern of exclusions) if (await pattern.find(byteName, budget)) {
             excluded = true;
             break;
@@ -1013,7 +1182,14 @@ async function runStored(context, budget, storage, stdinDocument) {
       const capabilities = await host(context, async () => await context.fs.capabilitiesFor?.(pathOf(context, path), { signal: context.signal }) ?? context.fs.capabilities);
       return capabilities.streamingRead !== false;
     };
-    if (!options.ignoreBlank && options.ignorePatterns.length === 0 && !options.functions.length && await canIndex(left, leftStat) && await canIndex(right, rightStat)) {
+    let storedPatterns = true;
+    for (const pattern of [...options.ignorePatterns, ...options.functions]) {
+      if (!await pattern.supportsStoredTest(budget)) {
+        storedPatterns = false;
+        break;
+      }
+    }
+    if (storedPatterns && await canIndex(left, leftStat) && await canIndex(right, rightStat)) {
       const result = await indexedDiff(budget, options, left, right, pair.nested, appendBytes, {
         left: !leftStat ? void 0 : isStdin(left) ? "-" : streamType(leftStat.type) ? { stream: pathOf(context, left) } : pathOf(context, left),
         right: !rightStat ? void 0 : isStdin(right) ? "-" : streamType(rightStat.type) ? { stream: pathOf(context, right) } : pathOf(context, right)
@@ -1030,7 +1206,7 @@ async function runStored(context, budget, storage, stdinDocument) {
     };
     const oldBytes = await read(left, leftStat);
     const newBytes = await read(right, rightStat);
-    const label = (name) => encoding === "latin1" ? decodeBytes2(encodeBytes3(name), "latin1") : name;
+    const label = (name) => encoding === "latin1" ? decodeBytes2(encodeBytes4(name), "latin1") : name;
     let incompleteEdLine = false;
     const reportSame = async () => {
       if (options.reportSame && !incompleteEdLine) await append(`Files ${label(options.labels[0] ?? left)} and ${label(options.labels[1] ?? right)} are identical
@@ -1062,8 +1238,8 @@ async function runStored(context, budget, storage, stdinDocument) {
     {
       const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
       try {
-        const oldDecoded = decoder.decode(encodeBytes3(oldBytes, "latin1"));
-        const newDecoded = decoder.decode(encodeBytes3(newBytes, "latin1"));
+        const oldDecoded = decoder.decode(encodeBytes4(oldBytes, "latin1"));
+        const newDecoded = decoder.decode(encodeBytes4(newBytes, "latin1"));
         oldText = oldDecoded;
         newText = newDecoded;
         encoding = "utf8";
@@ -1141,7 +1317,7 @@ async function runStored(context, budget, storage, stdinDocument) {
   if (options.paginate && outputSize) {
     const title = ["diff", ...context.args].join(" ");
     const argumentValues = createCommandArguments(["-f", "-h", title]);
-    const pages = new PagedStorage3(context, 16);
+    const pages = new PagedStorage4(context, 16);
     context.registerCleanup?.(() => pages.close());
     let pageBytes = 0;
     try {
@@ -1171,7 +1347,7 @@ async function runStored(context, budget, storage, stdinDocument) {
   return trouble ? 2 : different ? 1 : 0;
 }
 function globPattern(source, ignoreCase) {
-  source = decodeBytes2(encodeBytes3(source), "latin1");
+  source = decodeBytes2(encodeBytes4(source), "latin1");
   let result = "^";
   const oppositeCase = (character) => !ignoreCase ? "" : character >= "A" && character <= "Z" ? character.toLowerCase() : character >= "a" && character <= "z" ? character.toUpperCase() : "";
   for (let index = 0; index < source.length; index++) {

package/dist/safe-bash/command-chunks/{chunk-WGG6G2KG.js → chunk-3LJAXFH5.js}

@@ -3,29 +3,29 @@ import {
   readShapePath,
   shapePathXml,
   validateShapePath
-} from "./chunk-FIIAYCWS.js";
+} from "./chunk-KZ5ODST6.js";
 import {
   addShape,
   nodeFor,
   selected,
   validateSelection
-} from "./chunk-TW73OXPR.js";
+} from "./chunk-EJTNVXWF.js";
 import {
   validateShapeOptions
-} from "./chunk-IT7TAC3F.js";
+} from "./chunk-HVW53ARH.js";
 import {
   Length
-} from "./chunk-6QBMND4A.js";
+} from "./chunk-6SRHWVEB.js";
 import {
   loadShared,
   required
-} from "./chunk-56NYSX65.js";
+} from "./chunk-2Z3WRRFT.js";
 import {
   SelectionError
-} from "./chunk-X7FA7ZD5.js";
+} from "./chunk-O675URF4.js";
 import {
   OfficeError
-} from "./chunk-Q73EMLLZ.js";
+} from "./chunk-X6RHJ6YN.js";
 
 // packages/safe-bash-presentation-engine/src/shape-path-operations.ts
 function optionsFor(options, adding = false) {

package/dist/safe-bash/command-chunks/{chunk-AHA6IWAJ.js → chunk-3TYDSGAH.js}

@@ -1,25 +1,25 @@
 import {
   nodeFor
-} from "./chunk-TW73OXPR.js";
+} from "./chunk-EJTNVXWF.js";
 import {
   TextFrame,
   applyFrameFormatting,
   readShape
-} from "./chunk-IT7TAC3F.js";
+} from "./chunk-HVW53ARH.js";
 import {
   Length
-} from "./chunk-6QBMND4A.js";
+} from "./chunk-6SRHWVEB.js";
 import {
   attr,
   child,
   required
-} from "./chunk-56NYSX65.js";
+} from "./chunk-2Z3WRRFT.js";
 import {
   parseXmlPart
-} from "./chunk-554Z6IKP.js";
+} from "./chunk-7PRL6RJ6.js";
 import {
   OfficeError
-} from "./chunk-Q73EMLLZ.js";
+} from "./chunk-X6RHJ6YN.js";
 
 // packages/safe-bash-presentation-engine/src/tables.ts
 import { SaxesParser } from "saxes";

package/dist/safe-bash/command-chunks/{chunk-YSMNXMAO.js → chunk-3Y4XZB24.js}

@@ -1,17 +1,17 @@
 import {
   readXmlCoordinate,
   readXmlInteger
-} from "./chunk-CRV2Q3PB.js";
+} from "./chunk-EZ4NQIPL.js";
 import {
   Length
-} from "./chunk-6QBMND4A.js";
+} from "./chunk-6SRHWVEB.js";
 import {
   attr,
   child
-} from "./chunk-56NYSX65.js";
+} from "./chunk-2Z3WRRFT.js";
 import {
   OfficeError
-} from "./chunk-Q73EMLLZ.js";
+} from "./chunk-X6RHJ6YN.js";
 
 // packages/safe-bash-presentation-engine/src/shape-transforms.ts
 function invalid() {

package/dist/safe-bash/command-chunks/{chunk-ZIIO6GRY.js → chunk-4PBNMKAT.js}

@@ -1,26 +1,26 @@
 import {
   readShape
-} from "./chunk-IT7TAC3F.js";
+} from "./chunk-HVW53ARH.js";
 import {
   projectShapePoint
-} from "./chunk-YSMNXMAO.js";
+} from "./chunk-3Y4XZB24.js";
 import {
   Length
-} from "./chunk-6QBMND4A.js";
+} from "./chunk-6SRHWVEB.js";
 import {
   attr,
   child,
   required
-} from "./chunk-56NYSX65.js";
+} from "./chunk-2Z3WRRFT.js";
 import {
   parseXmlPart
-} from "./chunk-554Z6IKP.js";
+} from "./chunk-7PRL6RJ6.js";
 import {
   ValueError
-} from "./chunk-S6R3IB36.js";
+} from "./chunk-D55REQA3.js";
 import {
   OfficeError
-} from "./chunk-Q73EMLLZ.js";
+} from "./chunk-X6RHJ6YN.js";
 
 // packages/safe-bash-presentation-engine/src/connectors.ts
 var connectorValues = { STRAIGHT: 1, ELBOW: 2, CURVE: 3, MIXED: -2 };

package/dist/safe-bash/command-chunks/{chunk-JFYWVQ4V.js → chunk-4Z6W5EOC.js}

@@ -1,27 +1,27 @@
 import {
   readProperties
-} from "./chunk-6M6TM5Z5.js";
+} from "./chunk-5VQVZPP3.js";
 import {
   nodeFor
-} from "./chunk-TW73OXPR.js";
+} from "./chunk-EJTNVXWF.js";
 import {
   readPresentationText
-} from "./chunk-33YCKZZX.js";
+} from "./chunk-C5KLFZGT.js";
 import {
   readSelectionIndex
-} from "./chunk-X7FA7ZD5.js";
+} from "./chunk-O675URF4.js";
 import {
   readPackage
-} from "./chunk-XPD636C4.js";
+} from "./chunk-PVGZMLC6.js";
 import {
   readBinary
-} from "./chunk-PNGDJA6M.js";
+} from "./chunk-LD7BONZY.js";
 import {
   parseXmlPart
-} from "./chunk-554Z6IKP.js";
+} from "./chunk-7PRL6RJ6.js";
 import {
   OfficeError
-} from "./chunk-Q73EMLLZ.js";
+} from "./chunk-X6RHJ6YN.js";
 
 // packages/safe-bash-presentation-engine/src/diff.ts
 import { sha256 } from "@noble/hashes/sha2.js";