@poe-platform/safe-bash 0.1.799 → 0.1.801

package/dist/safe-bash/command-chunks/chunk-DT7BCTWY.js

@@ -0,0 +1,249 @@
+import {
+  parseUnified,
+  parseUnifiedSection
+} from "./chunk-67QKREJK.js";
+import {
+  decodeHeaderPath
+} from "./chunk-DOKKNRRM.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-patch/src/patch-formats.ts
+init_buffer();
+import { ToolError, integer } from "../../safe-bash-diff-engine/shared.js";
+import { byteLength } from "../../safe-bash-io-engine/byte-encoding.js";
+var Reader = class {
+  constructor(text, budget) {
+    this.budget = budget;
+    this.lines = budget.split(text).map((line) => line.slice(0, -1));
+  }
+  budget;
+  lines;
+  index = 0;
+  peek() {
+    return this.lines[this.index];
+  }
+  async take() {
+    this.budget.step();
+    {
+      const c = this.budget.checkpoint();
+      if (c) await c;
+    }
+    const line = this.lines[this.index++];
+    if (line === void 0) throw new ToolError("truncated patch");
+    return line;
+  }
+  number(value) {
+    const result = integer(value, "patch range");
+    if (result > this.budget.limits.maxLines) throw new ToolError("hunk coordinate exceeds line limit");
+    return result;
+  }
+  async content(prefix) {
+    const line = await this.take();
+    if (line !== prefix && !(prefix === " " && line === "") && !line.startsWith(`${prefix} `) && !line.startsWith(`${prefix}	`)) throw new ToolError("malformed patch body prefix");
+    let text = `${line.slice(2)}
+`;
+    if (this.peek() === "\") {
+      await this.take();
+      if (text === "\n") throw new ToolError("empty incomplete line is not a valid text line");
+      text = text.slice(0, -1);
+    }
+    return text;
+  }
+};
+function encoded(line) {
+  return `${line.kind}${line.text}${line.text.endsWith("\n") ? "" : "\n\\n"}`;
+}
+async function normal(reader, target) {
+  const quoted = JSON.stringify(target ?? "/dev/null");
+  const output = [`--- ${quoted}
++++ ${quoted}
+`];
+  while (reader.peek() !== void 0) {
+    if (reader.peek() === "") {
+      await reader.take();
+      continue;
+    }
+    if (!/^\d/u.test(reader.peek())) break;
+    const command = /^(\d+)(?:,(\d+))?([acd])(\d+)(?:,(\d+))?$/u.exec(await reader.take());
+    if (!command) throw new ToolError("malformed normal patch command");
+    const oldStart = reader.number(command[1]);
+    const oldLast = reader.number(command[2] ?? command[1]);
+    const newStart = reader.number(command[4]);
+    const newLast = reader.number(command[5] ?? command[4]);
+    const operation = command[3];
+    if (oldLast < oldStart || newLast < newStart || operation === "a" && command[2] !== void 0 || operation === "d" && command[5] !== void 0) throw new ToolError("invalid normal patch range");
+    const oldCount = operation === "a" ? 0 : oldLast - oldStart + 1;
+    const newCount = operation === "d" ? 0 : newLast - newStart + 1;
+    output.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@
+`);
+    for (let index = 0; index < oldCount; index++) output.push(encoded({ kind: "-", text: await reader.content("<") }));
+    if (operation === "c" && await reader.take() !== "---") throw new ToolError("missing normal change separator");
+    for (let index = 0; index < newCount; index++) output.push(encoded({ kind: "+", text: await reader.content(">") }));
+  }
+  return output.join("");
+}
+async function contextRange(reader, old) {
+  const line = await reader.take();
+  const match = (old ? /^\*\*\* (\d+)(?:,(\d+))? \*\*\*\*$/u : /^--- (\d+)(?:,(\d+))? ----$/u).exec(line);
+  if (!match) throw new ToolError("malformed context range");
+  const start = reader.number(match[1]);
+  const last = reader.number(match[2] ?? match[1]);
+  if (last < start || match[2] !== void 0 && start === 0) throw new ToolError("invalid context range");
+  return { start, last, multiple: match[2] !== void 0 };
+}
+async function contextSide(reader, old, range) {
+  const lines = [];
+  const count = range.start === 0 ? 0 : range.last - range.start + 1;
+  while (reader.peek() !== void 0 && lines.length < count) {
+    const kind = reader.peek() === "" ? " " : reader.peek()[0];
+    if (kind !== " " && kind !== "!" && kind !== (old ? "-" : "+")) break;
+    if (old && /^--- \d+(?:,\d+)? ----$/u.test(reader.peek())) break;
+    lines.push({ kind, text: await reader.content(kind) });
+    if (lines.length > reader.budget.limits.maxLines) throw new ToolError("context body line limit exceeded");
+  }
+  if (!old && lines.length === count && lines.at(-1)?.text.endsWith("\n") === false) {
+    while (reader.peek() === "\") await reader.take();
+  }
+  return lines;
+}
+function contextCount(range, lines) {
+  if (!lines.length) {
+    if (range.multiple) throw new ToolError("empty context side has a nonempty range");
+    return 0;
+  }
+  if (range.start === 0 || lines.length !== range.last - range.start + 1) throw new ToolError("context body count does not match range");
+  return lines.length;
+}
+async function context(reader) {
+  const output = [];
+  while (reader.peek() !== void 0) {
+    const header = await reader.take();
+    if (header === "") continue;
+    if (/^diff -[^ ]+ /u.test(header)) {
+      output.push(`${header}
+`);
+      continue;
+    }
+    if (!header.startsWith("*** ")) throw new ToolError("expected context file header");
+    const next = await reader.take();
+    if (!next.startsWith("--- ")) throw new ToolError("expected new context file header");
+    output.push(`--- ${header.slice(4)}
++++ ${next.slice(4)}
+`);
+    let hunks = 0;
+    while (reader.peek()?.startsWith("***************")) {
+      const delimiter = await reader.take();
+      if (!/^\*{15}(?: .*)?$/u.test(delimiter)) throw new ToolError("malformed context hunk separator");
+      if (++hunks > reader.budget.limits.maxHunks) throw new ToolError("hunk limit exceeded");
+      const oldRange = await contextRange(reader, true);
+      let oldLines = await contextSide(reader, true, oldRange);
+      const newRange = await contextRange(reader, false);
+      let newLines = await contextSide(reader, false, newRange);
+      if (!oldLines.length) {
+        if (newLines.some((line) => line.kind === "!")) throw new ToolError("missing old changed context body");
+        oldLines = newLines.filter((line) => line.kind === " ");
+      }
+      if (!newLines.length) {
+        if (oldLines.some((line) => line.kind === "!")) throw new ToolError("missing new changed context body");
+        newLines = oldLines.filter((line) => line.kind === " ");
+      }
+      const oldCount = contextCount(oldRange, oldLines);
+      const newCount = contextCount(newRange, newLines);
+      output.push(`@@ -${oldRange.start},${oldCount} +${newRange.start},${newCount} @@${delimiter.slice(15)}
+`);
+      let oldIndex = 0;
+      let newIndex = 0;
+      while (oldIndex < oldLines.length || newIndex < newLines.length) {
+        let oldChanged = false;
+        let newChanged = false;
+        while (oldIndex < oldLines.length && oldLines[oldIndex].kind !== " ") {
+          const line = oldLines[oldIndex++];
+          oldChanged ||= line.kind === "!";
+          output.push(encoded({ kind: "-", text: line.text }));
+          reader.budget.step();
+          {
+            const c = reader.budget.checkpoint();
+            if (c) await c;
+          }
+        }
+        while (newIndex < newLines.length && newLines[newIndex].kind !== " ") {
+          const line = newLines[newIndex++];
+          newChanged ||= line.kind === "!";
+          output.push(encoded({ kind: "+", text: line.text }));
+          reader.budget.step();
+          {
+            const c = reader.budget.checkpoint();
+            if (c) await c;
+          }
+        }
+        if (oldChanged !== newChanged) throw new ToolError("unpaired changed context group");
+        if (oldIndex < oldLines.length || newIndex < newLines.length) {
+          const oldLine = oldLines[oldIndex++];
+          const newLine = newLines[newIndex++];
+          if (!oldLine || !newLine || !reader.budget.equal(oldLine.text, newLine.text)) throw new ToolError("context halves disagree");
+          output.push(encoded({ kind: " ", text: oldLine.text }));
+        }
+      }
+    }
+    if (!hunks) throw new ToolError("context file patch has no hunks");
+    break;
+  }
+  return output.join("");
+}
+async function parsePatch(text, budget, format, target, progress) {
+  if (text && !text.endsWith("\n")) throw new ToolError("patch is truncated: missing final LF");
+  const reader = new Reader(text, budget);
+  const patches = [];
+  let convertedBytes = 0;
+  while (reader.peek() !== void 0) {
+    try {
+      if (reader.peek() === "") {
+        await reader.take();
+        continue;
+      }
+      if (!progress && patches.length && reader.peek().startsWith("-") && !reader.peek().startsWith("---")) {
+        throw new ToolError("unexpected deletion outside a patch hunk");
+      }
+      if (patches.length && !/^(?:Index: |diff |index |---|\*\*\*|@@|[+\\<>]|\d)/u.test(reader.peek())) {
+        await reader.take();
+        continue;
+      }
+      let indexPath;
+      if (reader.peek()?.startsWith("Index: ")) {
+        indexPath = decodeHeaderPath((await reader.take()).slice(7));
+        if (/^=+$/u.test(reader.peek() ?? "")) await reader.take();
+      }
+      const start = reader.index;
+      while (/^diff /u.test(reader.peek() ?? "")) await reader.take();
+      const first = reader.peek() ?? "";
+      const detected = first.startsWith("*** ") ? "context" : /^\d/u.test(first) ? "normal" : "unified";
+      if (format && detected !== format) throw new ToolError(`patch format is ${detected}, not requested ${format}`);
+      if (detected === "unified") {
+        reader.index = start;
+        patches.push(...(await parseUnifiedSection(reader, budget)).map((patch) => ({ ...patch, ...indexPath === void 0 ? {} : { indexPath } })));
+      } else {
+        if (detected === "context") reader.index = start;
+        const converted = detected === "normal" ? await normal(reader, target ?? indexPath) : await context(reader);
+        convertedBytes += byteLength(converted);
+        if (convertedBytes > budget.limits.maxInputBytes * 2 + 16384) throw new ToolError("converted patch byte limit exceeded");
+        patches.push(...(await parseUnified(converted, budget)).map((patch) => ({
+          ...patch,
+          format: detected,
+          ...indexPath === void 0 ? {} : { indexPath },
+          ...detected === "normal" && target === void 0 && indexPath === void 0 ? { unlocated: true } : {}
+        })));
+      }
+    } catch (error) {
+      if (!progress || !(error instanceof ToolError) || /limit|budget|filename|path|escape/u.test(error.message)) throw error;
+      progress.error = error;
+      break;
+    }
+  }
+  return patches;
+}
+
+export {
+  parsePatch
+};

package/dist/safe-bash/command-chunks/{chunk-6BETHLXZ.js → chunk-DZCY63VJ.js}

@@ -1,7 +1,7 @@
 import {
   readGnumericRichText,
   writeGnumericRichText
-} from "./chunk-X6NJC3IC.js";
+} from "./chunk-75OFBY5R.js";
 import {
   createXlsxXml,
   decodeXlsxString,
@@ -10,16 +10,16 @@ import {
   expandIndexSheetAreas,
   metadataNode,
   writeRichString
-} from "./chunk-QDTBMSBE.js";
+} from "./chunk-RO62EWX6.js";
 import {
   recalculateWorkbook,
   rewriteReferences,
   visitFormula
-} from "./chunk-5SHGJ7NO.js";
+} from "./chunk-VA5ZHYYA.js";
 import {
   cellValueFormat,
   converterLocale
-} from "./chunk-4QJOYXVB.js";
+} from "./chunk-JV7LBUTP.js";
 import {
   SsconvertError,
   excelGrammar,
@@ -29,10 +29,10 @@ import {
   parseExpression,
   serializeExpression,
   snapshotWorkbook
-} from "./chunk-DWFLVJC6.js";
+} from "./chunk-CCRHMAU5.js";
 import {
   createZipCodec
-} from "./chunk-MKQVQMXO.js";
+} from "./chunk-5LU4UCBR.js";
 import {
   CodecError
 } from "./chunk-RDV7UCYZ.js";
@@ -3465,7 +3465,7 @@ async function readXlsx(bytes, context) {
               const si = attr(f, "si") ?? "0";
               const existing = shared.get(si);
               if (f.text) {
-                expression = readOpenFormula(f)?.source ?? formula(f.text, id, position.row, position.column, context, semantics.arrayStringLiterals);
+                expression = readOpenFormula(f)?.source ?? formula(decodeXlsxString(f.text), id, position.row, position.column, context, semantics.arrayStringLiterals);
                 groupId = `shared-${si}`;
                 shared.set(si, { expression, ...position, id: groupId, ...semantics });
                 if (attr(f, "ref")) groups.push({ id: groupId, kind: "shared", expression, range: range(attr(f, "ref")), ...semantics });
@@ -3477,14 +3477,14 @@ async function readXlsx(bytes, context) {
                 groupId = existing.id;
               } else invalid("shared formula has no preceding definition");
             } else {
-              expression = readOpenFormula(f)?.source ?? formula(f.text, id, position.row, position.column, context, semantics.arrayStringLiterals);
+              expression = readOpenFormula(f)?.source ?? formula(decodeXlsxString(f.text), id, position.row, position.column, context, semantics.arrayStringLiterals);
               if (kind === "array") {
                 groupId = `array-${position.row}-${position.column}`;
                 groups.push({ id: groupId, kind: "array", expression, range: range(attr(f, "ref")), ...semantics });
               }
             }
           }
-          const hasCache = raw !== void 0 && (raw !== "" || type === "str");
+          const hasCache = type === "inlineStr" ? child4(node, "is") !== void 0 : raw !== void 0 && (raw !== "" || type === "str");
           cells.push({
             ...position,
             value,
@@ -3801,6 +3801,7 @@ function createXlsxWriter(edition) {
     })).join(""));
     const workbookRelations = [];
     const shared = [], sharedIds = /* @__PURE__ */ new Map(), stringCounts = /* @__PURE__ */ new Map();
+    let sharedReferences = 0;
     let totalCells = 0;
     for (const sheet of book.sheets) for (const cell of sheet.cells) {
       charge();
@@ -3907,13 +3908,14 @@ function createXlsxWriter(edition) {
                 ...array ? { t: "array", ref: rangeText(array.range) } : {},
                 ...formulaSemanticsAttributes(array?.arrayStringLiterals ?? cell.arrayStringLiterals, true, cell.formula)
               },
-              escapeXlsx(exportXlsxFormula(book, cell.formula, sheet, cell.row, cell.column, context, array?.arrayStringLiterals ?? cell.arrayStringLiterals))
+              escapeXlsx(encodeXlsxString(exportXlsxFormula(book, cell.formula, sheet, cell.row, cell.column, context, array?.arrayStringLiterals ?? cell.arrayStringLiterals)))
             );
           if (value.kind === "string") {
             if (cell.formula) {
               type = "str";
               body += xml("v", {}, escapeXlsx(encodeXlsxString(value.value)));
             } else if ((stringCounts.get(stringKey) ?? 0) > 1) {
+              sharedReferences++;
               type = "s";
               let id2 = sharedIds.get(stringKey);
               if (id2 === void 0) {
@@ -4009,7 +4011,7 @@ function createXlsxWriter(edition) {
       sheetNodes.push(xml("sheet", { name: sheet.name, sheetId: index + 1, "r:id": id }));
     }
     if (shared.length) {
-      await add("xl/sharedStrings.xml", xml("sst", { xmlns: namespace3, uniqueCount: shared.length, count: shared.length }, shared.map((cell) => xml("si", {}, writeRichString(cell.value.kind === "string" ? cell.value.value : "", cell.richText, xml, charge))).join("")), "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml");
+      await add("xl/sharedStrings.xml", xml("sst", { xmlns: namespace3, uniqueCount: shared.length, count: sharedReferences }, shared.map((cell) => xml("si", {}, writeRichString(cell.value.kind === "string" ? cell.value.value : "", cell.richText, xml, charge))).join("")), "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml");
       workbookRelations.push({ id: `rId${workbookRelations.length + 1}`, type: relationships + "/sharedStrings", target: "sharedStrings.xml" });
     }
     await add("xl/styles.xml", styles.serialize(), "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml");

package/dist/safe-bash/command-chunks/{chunk-QUENU6GM.js → chunk-E55UKBIE.js}

@@ -79,7 +79,7 @@ var Scanner = class {
     while (BigInt(this.absolute) < start) if (await this.nextByte() === void 0) break;
     this.endByte = end;
   }
-  async *raw() {
+  async *raw(output = true) {
     const bytes = new Bytes(this.budget);
     try {
       while (true) {
@@ -90,13 +90,13 @@ var Scanner = class {
           if (p) await p;
         }
         if (bytes.length === 4096) {
-          this.budget.add("maxOutputBytes", bytes.length);
+          if (output) this.budget.add("maxOutputBytes", bytes.length);
           yield bytes.view();
           bytes.free();
         }
       }
       if (bytes.length) {
-        this.budget.add("maxOutputBytes", bytes.length);
+        if (output) this.budget.add("maxOutputBytes", bytes.length);
         yield bytes.view();
       }
     } finally {