@poe-platform/safe-bash 0.1.811 → 0.1.813

package/dist/safe-bash/command-chunks/{chunk-GEM47B2P.js → chunk-57DDYKE5.js}

@@ -3,27 +3,27 @@ import {
 } from "./chunk-UPXFSGQG.js";
 import {
   readShapeGeometry
-} from "./chunk-YSMNXMAO.js";
+} from "./chunk-3Y4XZB24.js";
 import {
   attr,
   child
-} from "./chunk-56NYSX65.js";
+} from "./chunk-2Z3WRRFT.js";
 import {
   SelectionError,
   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/images.ts
 import { sha1 } from "@noble/hashes/legacy.js";

package/dist/safe-bash/command-chunks/{chunk-HARUYHH7.js → chunk-5HUICAWD.js}

@@ -1,6 +1,6 @@
 import {
   PatchError
-} from "./chunk-DPR5CYQV.js";
+} from "./chunk-XITDDJFT.js";
 
 // packages/safe-bash-command-apply-patch/src/parser.ts
 import { resolvePath } from "../../safe-bash-contracts/index.js";

package/dist/safe-bash/command-chunks/{chunk-4CKFNXRN.js → chunk-5IFRAI7Y.js}

@@ -1,7 +1,7 @@
 import {
   InvalidHandleError,
   ValueError
-} from "./chunk-S6R3IB36.js";
+} from "./chunk-D55REQA3.js";
 
 // packages/safe-bash-presentation-engine/src/xml-view.ts
 var states = /* @__PURE__ */ new WeakMap();

package/dist/safe-bash/command-chunks/{chunk-RHYJVTJO.js → chunk-5KGEZ3RW.js}

@@ -6,10 +6,10 @@ import {
   loadShared,
   required,
   unique
-} from "./chunk-56NYSX65.js";
+} from "./chunk-2Z3WRRFT.js";
 import {
   OfficeError
-} from "./chunk-Q73EMLLZ.js";
+} from "./chunk-X6RHJ6YN.js";
 
 // packages/safe-bash-presentation-engine/src/themes.ts
 var themeColorSlots = [

package/dist/safe-bash/command-chunks/{chunk-A5FZBR7X.js → chunk-5MFDRSGG.js}

@@ -1,16 +1,16 @@
 import {
   readMedia
-} from "./chunk-UYWSIIUX.js";
+} from "./chunk-X53AEG36.js";
 import {
   readPackage
-} from "./chunk-XPD636C4.js";
+} from "./chunk-PVGZMLC6.js";
 import {
   readBinary
-} from "./chunk-PNGDJA6M.js";
+} from "./chunk-LD7BONZY.js";
 import {
   OfficeError,
   resolveOfficeResources
-} from "./chunk-Q73EMLLZ.js";
+} from "./chunk-X6RHJ6YN.js";
 
 // packages/safe-bash-presentation-engine/src/media-extraction.ts
 var extensions = /* @__PURE__ */ new Map([

package/dist/safe-bash/command-chunks/{chunk-7GKKMNL6.js → chunk-5P6I2T63.js}

@@ -1,15 +1,15 @@
 import {
   addImage
-} from "./chunk-KCOJA7EM.js";
+} from "./chunk-GKILM4HZ.js";
 import {
   readMedia
-} from "./chunk-UYWSIIUX.js";
+} from "./chunk-X53AEG36.js";
 import {
   readImages
-} from "./chunk-GEM47B2P.js";
+} from "./chunk-57DDYKE5.js";
 import {
   admitImage
-} from "./chunk-QD7ZRDUN.js";
+} from "./chunk-ET2VPDUA.js";
 import {
   attr,
   child,
@@ -19,17 +19,17 @@ import {
   nextRel,
   relPart,
   required
-} from "./chunk-56NYSX65.js";
+} from "./chunk-2Z3WRRFT.js";
 import {
   SelectionError
-} from "./chunk-X7FA7ZD5.js";
+} from "./chunk-O675URF4.js";
 import {
   packageUri,
   relativePartReference
-} from "./chunk-36XGIPOG.js";
+} from "./chunk-U5TWQFZY.js";
 import {
   OfficeError
-} from "./chunk-Q73EMLLZ.js";
+} from "./chunk-X6RHJ6YN.js";
 
 // packages/safe-bash-presentation-engine/src/media-editing.ts
 var mediaNs = "http://schemas.microsoft.com/office/powerpoint/2010/main";

package/dist/safe-bash/command-chunks/{chunk-6M6TM5Z5.js → chunk-5VQVZPP3.js}

@@ -4,13 +4,13 @@ import {
   invalid,
   loadShared,
   nextRel
-} 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/properties.ts
 import { SaxesParser } from "saxes";

package/dist/safe-bash/command-chunks/{chunk-MIRL7HTF.js → chunk-6244HYJY.js}

@@ -1,6 +1,6 @@
 import {
   parsePredicate
-} from "./chunk-JYUJAF4L.js";
+} from "./chunk-G7NENPYV.js";
 import {
   XmlQueryError,
   XmlQueryLimitError

package/dist/safe-bash/command-chunks/chunk-63EMPQ7Z.js

@@ -0,0 +1,115 @@
+import {
+  targetBytes
+} from "./chunk-73NYFNAS.js";
+
+// packages/safe-bash-command-patch/src/patch-gnu-reject.ts
+function timestamp(header) {
+  if (!header) return "";
+  const separator = header.indexOf("	");
+  return separator < 0 ? "" : header.slice(separator);
+}
+function unifiedRange(start, count, offset) {
+  return `${start + offset}${count === 1 ? "" : `,${count}`}`;
+}
+function contextRange(start, count, offset) {
+  return count === 0 ? "0" : count === 1 ? `${start + offset}` : `${start + offset},${start + offset + count - 1}`;
+}
+async function* rejectBytes(patch, outcomes, oldName, newName, indexName, reverse, budget, format) {
+  const normal = patch.format === "normal";
+  const context = format === void 0 ? patch.format === "context" || normal : format === "context";
+  const names = [normal ? "/dev/null" : oldName ?? "/dev/null", normal ? "/dev/null" : newName ?? "/dev/null"];
+  const times = normal ? ["", ""] : [timestamp(patch.oldHeader), timestamp(patch.newHeader)];
+  if (reverse) {
+    names.reverse();
+    times.reverse();
+  }
+  const add = async function* (text) {
+    budget.output(text);
+    yield* targetBytes(text);
+  };
+  if (indexName !== void 0) yield* add(`Index: ${indexName}
+`);
+  yield* add(`${context ? "***" : "---"} ${names[0]}${times[0]}
+${context ? "---" : "+++"} ${names[1]}${times[1]}
+`);
+  for (const outcome of outcomes) {
+    if (!outcome.failed) continue;
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    const { hunk, outputOffset } = outcome;
+    if (!context) {
+      yield* add(`@@ -${unifiedRange(hunk.oldStart, hunk.oldCount, outputOffset)} +${unifiedRange(hunk.newStart, hunk.newCount, outputOffset)} @@${hunk.section ?? ""}
+`);
+      for (let start = 0; start < hunk.lines.length; ) {
+        budget.step();
+        {
+          const c = budget.checkpoint();
+          if (c) await c;
+        }
+        const line = hunk.lines[start];
+        if (line.kind === " ") {
+          yield* add(" ");
+          yield* add(line.text);
+          start++;
+          continue;
+        }
+        let end = start;
+        while (end < hunk.lines.length && hunk.lines[end].kind !== " ") {
+          end++;
+          budget.step();
+          const c = budget.checkpoint();
+          if (c) await c;
+        }
+        for (const kind of ["-", "+"]) for (let index = start; index < end; index++) {
+          const line2 = hunk.lines[index];
+          if (line2.kind === kind) {
+            yield* add(kind);
+            yield* add(line2.text);
+          }
+        }
+        start = end;
+      }
+    } else {
+      yield* add(`***************${hunk.section ?? ""}
+*** ${contextRange(hunk.oldStart, hunk.oldCount, outputOffset)}${normal ? "" : " ****"}
+`);
+      for (const kind of ["-", "+"]) {
+        if (kind === "+") yield* add(`--- ${contextRange(hunk.newStart, hunk.newCount, outputOffset)}${normal ? " -----" : " ----"}
+`);
+        for (let start = 0; start < hunk.lines.length; ) {
+          budget.step();
+          const c = budget.checkpoint();
+          if (c) await c;
+          const line = hunk.lines[start];
+          if (line.kind === " ") {
+            yield* add("  ");
+            yield* add(line.text);
+            start++;
+            continue;
+          }
+          let end = start, removed = false, added = false;
+          while (end < hunk.lines.length && hunk.lines[end].kind !== " ") {
+            removed ||= hunk.lines[end].kind === "-";
+            added ||= hunk.lines[end].kind === "+";
+            end++;
+            budget.step();
+            const c2 = budget.checkpoint();
+            if (c2) await c2;
+          }
+          for (let index = start; index < end; index++) if (hunk.lines[index].kind === kind) {
+            yield* add(`${!normal && removed && added ? "!" : kind} `);
+            yield* add(hunk.lines[index].text);
+          }
+          start = end;
+        }
+      }
+    }
+  }
+}
+
+export {
+  rejectBytes
+};

package/dist/safe-bash/command-chunks/{chunk-XRVKWGVQ.js → chunk-6CY5BHBS.js}

@@ -4,26 +4,26 @@ import {
   readConnector,
   removeDrawingObjects,
   validateConnectorUpdate
-} from "./chunk-ZIIO6GRY.js";
+} from "./chunk-4PBNMKAT.js";
 import {
   nodeFor,
   selected,
   validateSelection
-} from "./chunk-TW73OXPR.js";
+} from "./chunk-EJTNVXWF.js";
 import {
   ShapeIdAllocator
-} from "./chunk-WXRYDALR.js";
+} from "./chunk-BBAB7LC4.js";
 import {
   child,
   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/connector-operations.ts
 function optionsFor(options, action) {

package/dist/safe-bash/command-chunks/{chunk-XVP6V5K3.js → chunk-6IWE7PTK.js}

@@ -1,22 +1,22 @@
 import {
   readTextBodies,
   validateTextReadingOptions
-} from "./chunk-33YCKZZX.js";
+} from "./chunk-C5KLFZGT.js";
 import {
   loadShared
-} from "./chunk-56NYSX65.js";
+} from "./chunk-2Z3WRRFT.js";
 import {
   SelectionError
-} from "./chunk-X7FA7ZD5.js";
+} from "./chunk-O675URF4.js";
 import {
   protectedEquationNodes
-} from "./chunk-2ZFLMWOX.js";
+} from "./chunk-Z5BIM5B7.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/text-replacement.ts
 function authored(value, maximum) {

package/dist/safe-bash/command-chunks/{chunk-6QBMND4A.js → chunk-6SRHWVEB.js}

@@ -4,7 +4,7 @@ import {
 import {
   TypeError,
   ValueError
-} from "./chunk-S6R3IB36.js";
+} from "./chunk-D55REQA3.js";
 
 // packages/safe-bash-presentation-engine/src/length.ts
 var LengthValue = class {

package/dist/safe-bash/command-chunks/chunk-6ZHQB453.js

@@ -0,0 +1,35 @@
+// packages/safe-bash-command-html-to-markdown/dist/chunk-TRTQSARU.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __toESM
+};

package/dist/safe-bash/command-chunks/chunk-73NYFNAS.js

@@ -0,0 +1,173 @@
+// packages/safe-bash-command-patch/src/stored-target.ts
+import { PagedStorage, PagedStorageCache } from "@poe-platform/safe-fs/storage";
+import { IndexedDocument, closeDocumentResources } from "../../safe-bash-diff-engine/document.js";
+import { ToolError, host } from "../../safe-bash-diff-engine/shared.js";
+async function* targetBytes(line) {
+  if (typeof line !== "string") {
+    const range = await line.document.line(line.index);
+    yield* line.document.range(range.start, range.end);
+    return;
+  }
+  for (let start = 0; start < line.length; ) {
+    let end = Math.min(start + 4096, line.length);
+    const last = line.charCodeAt(end - 1);
+    if (end < line.length && last >= 55296 && last <= 56319) end--;
+    yield new TextEncoder().encode(line.slice(start, end));
+    start = end;
+  }
+}
+async function* normalized(line, whitespace) {
+  if (!whitespace) {
+    yield* targetBytes(line);
+    return;
+  }
+  let pending = false, cr = false;
+  let output = [];
+  for await (const block of targetBytes(line)) {
+    for (const byte of block) {
+      if (cr) {
+        if (byte !== 10 && pending) output.push(32);
+        output.push(13);
+        cr = false;
+        pending = false;
+      }
+      if (byte === 32 || byte === 9) pending = true;
+      else if (byte === 13 && pending) cr = true;
+      else {
+        if (pending && byte !== 10) output.push(32);
+        pending = false;
+        output.push(byte);
+      }
+      if (output.length >= 4096) {
+        yield Uint8Array.from(output);
+        output = [];
+      }
+    }
+  }
+  if (cr) output.push(32, 13);
+  if (output.length) yield Uint8Array.from(output);
+}
+async function equalTargetLines(left, right, budget, whitespace = false) {
+  const a = normalized(left, whitespace)[Symbol.asyncIterator]();
+  const b = normalized(right, whitespace)[Symbol.asyncIterator]();
+  try {
+    let x = await a.next(), y = await b.next(), i = 0, j = 0;
+    while (!x.done && !y.done) {
+      const count = Math.min(x.value.length - i, y.value.length - j);
+      budget.step(count);
+      for (let k = 0; k < count; k++) if (x.value[i + k] !== y.value[j + k]) return false;
+      i += count;
+      j += count;
+      if (i === x.value.length) {
+        x = await a.next();
+        i = 0;
+      }
+      if (j === y.value.length) {
+        y = await b.next();
+        j = 0;
+      }
+      const checkpoint = budget.checkpoint();
+      if (checkpoint) await checkpoint;
+    }
+    return !!x.done && !!y.done;
+  } finally {
+    await a.return?.();
+    await b.return?.();
+  }
+}
+var TargetDocuments = class {
+  constructor(budget) {
+    this.budget = budget;
+    this.documentBudget = {
+      context: budget.context,
+      documentCache: this.cache,
+      step: budget.step.bind(budget),
+      checkpoint: budget.checkpoint.bind(budget)
+    };
+  }
+  budget;
+  cache = new PagedStorageCache(16);
+  documents = /* @__PURE__ */ new Set();
+  documentBudget;
+  async load(source) {
+    const document = new IndexedDocument(this.documentBudget, 2);
+    this.documents.add(document);
+    await document.load(source);
+    if (document.binary) throw new ToolError("binary input is unsupported (NUL byte)");
+    if (!document.validUtf8) throw new ToolError("binary input is unsupported (invalid UTF-8)");
+    return document;
+  }
+  async read(path) {
+    const iterator = this.budget.diffSource(path);
+    const context = this.budget.context;
+    return this.load({ async *[Symbol.asyncIterator]() {
+      try {
+        for (; ; ) {
+          const next = await host(context, () => iterator.next());
+          if (next.done) break;
+          yield next.value;
+        }
+      } finally {
+        const closed = iterator.return(void 0);
+        if (context.signal.aborted) void closed.catch(() => {
+        });
+        else await closed;
+      }
+    } });
+  }
+  async concat(left, right) {
+    return this.load({ async *[Symbol.asyncIterator]() {
+      yield* left.range(0, left.size);
+      yield* right.range(0, right.size);
+    } });
+  }
+  async release(document) {
+    await document.close();
+    this.documents.delete(document);
+  }
+  close() {
+    return closeDocumentResources([...this.documents]);
+  }
+};
+var TargetOutput = class {
+  constructor(documents) {
+    this.documents = documents;
+    this.data = new PagedStorage(documents.budget.context, 2);
+  }
+  documents;
+  data;
+  size = 0;
+  unterminated = false;
+  length = 0;
+  async append(line) {
+    if (this.unterminated) await this.write(new Uint8Array([10]));
+    this.unterminated = false;
+    for await (const bytes of targetBytes(line)) {
+      await this.write(bytes);
+      this.unterminated = bytes.at(-1) !== 10;
+    }
+    this.length++;
+  }
+  async write(bytes) {
+    this.size += bytes.length;
+    if (this.size > this.documents.budget.limits.maxOutputBytes) throw new ToolError("output byte limit exceeded");
+    await this.data.append(bytes);
+  }
+  async finish() {
+    const data = this.data, size = this.size;
+    this.documents.budget.outputLength(size);
+    return this.documents.load({ async *[Symbol.asyncIterator]() {
+      for (let offset = 0; offset < size; offset += 16384) yield await data.read(8 + offset, Math.min(16384, size - offset));
+    } });
+  }
+  close() {
+    return this.data.close();
+  }
+};
+
+export {
+  targetBytes,
+  equalTargetLines,
+  TargetDocuments,
+  TargetOutput
+};