@poe-platform/safe-bash 0.1.813 → 0.1.814

package/dist/safe-bash/command-chunks/{chunk-B3NLITWP.js → chunk-MKK6FM5H.js}

@@ -1,30 +1,30 @@
 import {
   chartDefinitionParts,
   decodeChartContent
-} from "./chunk-F3GP3EXE.js";
+} from "./chunk-RGDOYWOD.js";
 import {
   collectDiagramObservations,
   diagramPartRoles
-} from "./chunk-3ZDANXIC.js";
+} from "./chunk-HELAVGZH.js";
 import {
   DocumentLocations,
   docxLocationBudgets
-} from "./chunk-UZL7G57V.js";
+} from "./chunk-CKEMZUE3.js";
 import {
   embeddedFontContentTypes,
   fontResourceRole,
   readFontResources
-} from "./chunk-6NATRKUJ.js";
+} from "./chunk-JW6WVNTM.js";
 import {
   LocationIndex
-} from "./chunk-MTWZEPAR.js";
+} from "./chunk-47IAU25U.js";
 import {
   activeControlLocks,
   activeSettingsProtection
 } from "./chunk-TBAH4XGI.js";
 import {
   validateDocumentArchive
-} from "./chunk-JQPNA77Y.js";
+} from "./chunk-NHNZYWPW.js";
 import {
   documentPartRole,
   signatureContentTypes,
@@ -35,7 +35,7 @@ import {
 } from "./chunk-5BUL25DF.js";
 import {
   revisionInfo
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   readPropertyParts,
   storedBooleanValue

package/dist/safe-bash/command-chunks/{chunk-BK7ISUJL.js → chunk-MKOIPOXX.js}

@@ -3,13 +3,13 @@ import {
   child,
   invalid,
   loadShared
-} from "./chunk-2Z3WRRFT.js";
+} from "./chunk-ADHFF2IM.js";
 import {
   SelectionError
-} from "./chunk-O675URF4.js";
+} from "./chunk-W3ZSWK76.js";
 import {
   OfficeError
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/transitions.ts
 import { SaxesParser } from "saxes";

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

@@ -0,0 +1,244 @@
+import {
+  htmlSpace
+} from "./chunk-DFI7QF3M.js";
+
+// packages/safe-bash-command-html-to-markdown/dist/chunk-GRPJ3TNF.js
+var empty = { left: 0, right: 0, data: 0, bytes: 0, length: 0, height: 0, points: 0 };
+var TextStore = class {
+  constructor(storage, cooperate) {
+    this.storage = storage;
+    this.cooperate = cooperate;
+  }
+  storage;
+  cooperate;
+  encoder = new TextEncoder();
+  decoder = new TextDecoder("utf-8", { ignoreBOM: true });
+  async info(root) {
+    if (!root) return empty;
+    const bytes = await this.storage.read(root, 56);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return {
+      left: view.getFloat64(0, true),
+      right: view.getFloat64(8, true),
+      data: view.getFloat64(16, true),
+      bytes: view.getFloat64(24, true),
+      length: view.getFloat64(32, true),
+      height: view.getFloat64(40, true),
+      points: view.getFloat64(48, true)
+    };
+  }
+  node(node) {
+    if (!Number.isSafeInteger(node.length) || !Number.isSafeInteger(node.bytes)) throw new RangeError("HTML text size overflow");
+    const bytes = new Uint8Array(56), view = new DataView(bytes.buffer);
+    for (const [index, value] of [node.left, node.right, node.data, node.bytes, node.length, node.height, node.points].entries()) view.setFloat64(index * 8, value, true);
+    return this.storage.append(bytes);
+  }
+  async branch(left, right) {
+    if (!left || !right) return left || right;
+    const a = await this.info(left), b = await this.info(right);
+    return this.node({ left, right, data: 0, bytes: a.bytes + b.bytes, length: a.length + b.length, height: Math.max(a.height, b.height) + 1, points: a.points + b.points });
+  }
+  /** Persistent AVL join shares operands rather than copying their text. */
+  async concat(left, right) {
+    if (!left || !right) return left || right;
+    const a = await this.info(left), b = await this.info(right);
+    if (a.height > b.height + 1) return this.balance(a.left, await this.concat(a.right, right));
+    if (b.height > a.height + 1) return this.balance(await this.concat(left, b.left), b.right);
+    return this.branch(left, right);
+  }
+  async balance(left, right) {
+    const a = await this.info(left), b = await this.info(right);
+    if (a.height > b.height + 1) {
+      const outer = await this.info(a.left), inner = await this.info(a.right);
+      if (outer.height >= inner.height) return this.branch(a.left, await this.branch(a.right, right));
+      return this.branch(await this.branch(a.left, inner.left), await this.branch(inner.right, right));
+    }
+    if (b.height > a.height + 1) {
+      const inner = await this.info(b.left), outer = await this.info(b.right);
+      if (outer.height >= inner.height) return this.branch(await this.branch(left, b.left), b.right);
+      return this.branch(await this.branch(left, inner.left), await this.branch(inner.right, b.right));
+    }
+    return this.branch(left, right);
+  }
+  async from(text) {
+    let root = 0;
+    for (let offset = 0; offset < text.length; ) {
+      let end = Math.min(offset + 2048, text.length);
+      const last = text.charCodeAt(end - 1);
+      if (end < text.length && last >= 55296 && last <= 56319) end--;
+      const chunk = text.slice(offset, end), bytes = this.encoder.encode(chunk);
+      await this.cooperate?.(chunk.length);
+      const data = await this.storage.append(bytes);
+      root = await this.concat(root, await this.node({ left: 0, right: 0, data, bytes: bytes.length, length: chunk.length, height: 1, points: Array.from(chunk).length }));
+      offset = end;
+    }
+    return root;
+  }
+  async *chunks(root, reverse = false) {
+    const pending = root ? [root] : [];
+    while (pending.length) {
+      const node = await this.info(pending.pop());
+      if (node.data) {
+        await this.cooperate?.(node.length);
+        yield this.decoder.decode(await this.storage.read(node.data, node.bytes));
+      } else if (reverse) pending.push(node.left, node.right);
+      else pending.push(node.right, node.left);
+    }
+  }
+  async *characters(root) {
+    for await (const chunk of this.chunks(root)) yield* chunk;
+  }
+  async at(root, index) {
+    const original = await this.info(root);
+    if (index < 0) index += original.length;
+    if (index < 0 || index >= original.length) return void 0;
+    while (root) {
+      const node = await this.info(root);
+      if (node.data) return this.decoder.decode(await this.storage.read(node.data, node.bytes))[index];
+      const left = await this.info(node.left);
+      if (index < left.length) root = node.left;
+      else {
+        index -= left.length;
+        root = node.right;
+      }
+    }
+    return void 0;
+  }
+  /** Locate a Unicode scalar by rank without materializing preceding text. */
+  async pointOffset(root, index) {
+    const original = await this.info(root);
+    if (!Number.isSafeInteger(index) || index < 0 || index > original.points) throw new RangeError("Invalid scalar offset");
+    let offset = 0;
+    while (root) {
+      const node = await this.info(root);
+      if (index === node.points) return offset + node.length;
+      if (node.data) {
+        for (const character of this.decoder.decode(await this.storage.read(node.data, node.bytes))) {
+          if (index-- === 0) break;
+          offset += character.length;
+        }
+        return offset;
+      }
+      const left = await this.info(node.left);
+      if (index < left.points) root = node.left;
+      else {
+        offset += left.length;
+        index -= left.points;
+        root = node.right;
+      }
+    }
+    return offset;
+  }
+  async slice(root, start, end = Number.MAX_SAFE_INTEGER) {
+    const node = await this.info(root);
+    start = Math.max(0, Math.min(start, node.length));
+    end = Math.max(start, Math.min(end, node.length));
+    if (start === end) return 0;
+    if (start === 0 && end === node.length) return root;
+    if (node.data) return this.from(this.decoder.decode(await this.storage.read(node.data, node.bytes)).slice(start, end));
+    const left = await this.info(node.left);
+    return this.concat(await this.slice(node.left, start, end), await this.slice(node.right, Math.max(0, start - left.length), Math.max(0, end - left.length)));
+  }
+  async repeat(root, count) {
+    if (!Number.isSafeInteger(count) || count < 0) throw new RangeError("Invalid HTML text repetition");
+    let result = 0;
+    while (count > 0) {
+      if (count % 2) result = await this.concat(result, root);
+      count = Math.floor(count / 2);
+      if (count) root = await this.concat(root, root);
+    }
+    return result;
+  }
+  async trim(root) {
+    let first = 0, last = (await this.info(root)).length;
+    outer: for await (const chunk of this.chunks(root)) for (const character of chunk) {
+      if (!htmlSpace(character)) break outer;
+      first++;
+    }
+    if (first === last) return 0;
+    outer: for await (const chunk of this.chunks(root, true)) for (let index = chunk.length - 1; index >= 0; index--) {
+      if (!htmlSpace(chunk[index])) break outer;
+      last--;
+    }
+    return this.slice(root, first, last);
+  }
+  async normalize(root, mode) {
+    const result = this.builder();
+    let space = false, carriage = false;
+    for await (const chunk of this.chunks(root)) {
+      let output = "";
+      for (const character of chunk) {
+        if (mode === "lines" && carriage && character === "\n") {
+          carriage = false;
+          continue;
+        }
+        carriage = false;
+        if (mode === "space" && htmlSpace(character)) {
+          if (!space) output += " ";
+          space = true;
+        } else {
+          space = false;
+          if (mode === "lines" && character === "\r") {
+            output += "\n";
+            carriage = true;
+          } else output += mode === "inline" && character === "\n" ? " " : character;
+        }
+      }
+      await result.write(output);
+    }
+    return result.finish();
+  }
+  async includes(root, needle) {
+    if (!needle) return true;
+    let tail = "";
+    for await (const chunk of this.chunks(root)) {
+      const text = tail + chunk;
+      if (text.includes(needle)) return true;
+      tail = text.slice(-Math.max(0, needle.length - 1));
+      if (needle.length === 1) tail = "";
+    }
+    return false;
+  }
+  async write(root, sink) {
+    for await (const chunk of this.chunks(root)) await sink.write(this.encoder.encode(chunk));
+  }
+  builder() {
+    return new TextBuilder(this);
+  }
+};
+var TextBuilder = class {
+  constructor(text) {
+    this.text = text;
+  }
+  text;
+  root = 0;
+  pending = "";
+  async write(value) {
+    for (let offset = 0; offset < value.length; ) {
+      const count = Math.min(2048 - this.pending.length, value.length - offset);
+      this.pending += value.slice(offset, offset + count);
+      offset += count;
+      if (this.pending.length === 2048) {
+        const last = this.pending.charCodeAt(2047), keep = last >= 55296 && last <= 56319;
+        this.root = await this.text.concat(this.root, await this.text.from(keep ? this.pending.slice(0, -1) : this.pending));
+        this.pending = keep ? this.pending.at(-1) : "";
+      }
+    }
+  }
+  async append(root) {
+    if (!root) return;
+    this.root = await this.text.concat(await this.finish(), root);
+  }
+  async finish() {
+    if (this.pending) {
+      this.root = await this.text.concat(this.root, await this.text.from(this.pending));
+      this.pending = "";
+    }
+    return this.root;
+  }
+};
+
+export {
+  TextStore,
+  TextBuilder
+};

package/dist/safe-bash/command-chunks/{chunk-CBNKHBLD.js → chunk-MNK3DDH6.js}

@@ -4,10 +4,10 @@ import {
 import {
   SourceError,
   validateDocxInvocation
-} from "./chunk-GXLXWZWH.js";
+} from "./chunk-DZH54L3F.js";
 import {
   publishDocumentArchive
-} from "./chunk-PZMU3Z4L.js";
+} from "./chunk-EVYKV3QI.js";
 import {
   PublicationError,
   asPermissionError

package/dist/safe-bash/command-chunks/{chunk-JVGUVHWI.js → chunk-MPXMRTMY.js}

@@ -1,38 +1,38 @@
 import {
   noteAttribute,
   openNotes
-} from "./chunk-7ZE3VIAN.js";
+} from "./chunk-IB5QP4LF.js";
 import {
   assertOutsideFields,
   parseFields
-} from "./chunk-ATI464W3.js";
+} from "./chunk-AG2SNMP5.js";
 import {
   resolveDocxSelection
-} from "./chunk-UZL7G57V.js";
-import {
-  validateDocxInvocation
-} from "./chunk-GXLXWZWH.js";
+} from "./chunk-CKEMZUE3.js";
 import {
   paragraphTextRun,
   replaceParagraphContent
-} from "./chunk-CU4DLVME.js";
+} from "./chunk-BLIFGBIO.js";
 import {
   findRelationshipPart
 } from "./chunk-UIX3CASN.js";
 import {
   LocationIndex
-} from "./chunk-MTWZEPAR.js";
+} from "./chunk-47IAU25U.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DZH54L3F.js";
 import {
   assertDocumentEditable,
   publishDocumentArchive
-} from "./chunk-PZMU3Z4L.js";
+} from "./chunk-EVYKV3QI.js";
 import {
   DocumentXmlEditor,
   UnsupportedEditError,
   activeXmlChildren,
   removeNoteBodyXml,
   xmlValue
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   compatibilityContainers
 } from "./chunk-JWO7BP4K.js";

package/dist/safe-bash/command-chunks/{chunk-EJTNVXWF.js → chunk-MVLVIMJ6.js}

@@ -3,25 +3,25 @@ import {
   createShapeXml,
   readShape,
   validateShapeOptions
-} from "./chunk-HVW53ARH.js";
+} from "./chunk-TKCUGMRZ.js";
 import {
   ShapeIdAllocator
-} from "./chunk-BBAB7LC4.js";
+} from "./chunk-XMTR7QGL.js";
 import {
   readShapeGeometry
-} from "./chunk-3Y4XZB24.js";
+} from "./chunk-RTNI47C5.js";
 import {
   attr,
   child,
   loadShared,
   required
-} from "./chunk-2Z3WRRFT.js";
+} from "./chunk-ADHFF2IM.js";
 import {
   SelectionError
-} from "./chunk-O675URF4.js";
+} from "./chunk-W3ZSWK76.js";
 import {
   OfficeError
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/shape-operations.ts
 function validateSelection(options, action) {

package/dist/safe-bash/command-chunks/{chunk-TY4WDAHM.js → chunk-MYZ46FQL.js}

@@ -1,6 +1,6 @@
 import {
   xmlValue
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   documentDialects
 } from "./chunk-WLANDWNW.js";

package/dist/safe-bash/command-chunks/{chunk-TBAIMDGL.js → chunk-N4MUBJCT.js}

@@ -1,7 +1,7 @@
 import {
   DocumentXmlEditor,
   UnsupportedEditError
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   commentExtensionParts,
   dialectForNamespace,

package/dist/safe-bash/command-chunks/{chunk-NPLVFAD6.js → chunk-N6G3345Q.js}

@@ -1,27 +1,27 @@
 import {
   openDocumentLocations,
   resolveDocxSelection
-} from "./chunk-UZL7G57V.js";
-import {
-  validateDocxInvocation
-} from "./chunk-GXLXWZWH.js";
+} from "./chunk-CKEMZUE3.js";
 import {
   hyperlinkHistory
 } from "./chunk-DGBQ7QDE.js";
 import {
   paragraphTextRun
-} from "./chunk-CU4DLVME.js";
+} from "./chunk-BLIFGBIO.js";
 import {
   findRelationshipPart
 } from "./chunk-UIX3CASN.js";
 import {
   LocationIndex,
   addressKey
-} from "./chunk-MTWZEPAR.js";
+} from "./chunk-47IAU25U.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DZH54L3F.js";
 import {
   assertDocumentEditable,
   publishDocumentArchive
-} from "./chunk-PZMU3Z4L.js";
+} from "./chunk-EVYKV3QI.js";
 import {
   DocumentPackage
 } from "./chunk-5BUL25DF.js";
@@ -32,7 +32,7 @@ import {
   editActiveRelationshipXml,
   runElementOpen,
   xmlValue
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   relationshipXmlIds,
   relationshipXmlRows

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

@@ -1,26 +1,26 @@
 import {
   readShape
-} from "./chunk-HVW53ARH.js";
+} from "./chunk-TKCUGMRZ.js";
 import {
   projectShapePoint
-} from "./chunk-3Y4XZB24.js";
+} from "./chunk-RTNI47C5.js";
 import {
   Length
-} from "./chunk-6SRHWVEB.js";
+} from "./chunk-2VVJRVYM.js";
 import {
   attr,
   child,
   required
-} from "./chunk-2Z3WRRFT.js";
+} from "./chunk-ADHFF2IM.js";
 import {
   parseXmlPart
-} from "./chunk-7PRL6RJ6.js";
+} from "./chunk-DBLQUZGN.js";
 import {
   ValueError
-} from "./chunk-D55REQA3.js";
+} from "./chunk-JUHOL5KB.js";
 import {
   OfficeError
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.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-MUUWBZIC.js → chunk-NEVQWOU6.js}

@@ -2,39 +2,39 @@ import {
   nodeFor,
   selected,
   validateSelection
-} from "./chunk-EJTNVXWF.js";
+} from "./chunk-MVLVIMJ6.js";
 import {
   readShape
-} from "./chunk-HVW53ARH.js";
+} from "./chunk-TKCUGMRZ.js";
 import {
   applyDrawingUpdate,
   readDrawingFormat,
   validateDrawingUpdate
-} from "./chunk-BEHUSUOY.js";
+} from "./chunk-PLMF35XK.js";
 import {
   readShapeGeometry
-} from "./chunk-3Y4XZB24.js";
+} from "./chunk-RTNI47C5.js";
 import {
   escape,
   loadShared,
   nextRel,
   relPart
-} from "./chunk-2Z3WRRFT.js";
+} from "./chunk-ADHFF2IM.js";
 import {
   SelectionError
-} from "./chunk-O675URF4.js";
+} from "./chunk-W3ZSWK76.js";
 import {
   readBinary
-} from "./chunk-LD7BONZY.js";
+} from "./chunk-NFII726L.js";
 import {
   parseXmlPart
-} from "./chunk-7PRL6RJ6.js";
+} from "./chunk-DBLQUZGN.js";
 import {
   relativePartReference
-} from "./chunk-U5TWQFZY.js";
+} from "./chunk-WTVJLHMG.js";
 import {
   OfficeError
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.js";
 import {
   crc32
 } from "./chunk-IOEUZ4EA.js";

package/dist/safe-bash/command-chunks/{chunk-KZ5ODST6.js → chunk-NFGCBQN3.js}

@@ -1,10 +1,10 @@
 import {
   attr,
   child
-} from "./chunk-2Z3WRRFT.js";
+} from "./chunk-ADHFF2IM.js";
 import {
   OfficeError
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/shape-paths.ts
 import { SaxesParser } from "saxes";

package/dist/safe-bash/command-chunks/{chunk-LD7BONZY.js → chunk-NFII726L.js}

@@ -1,10 +1,10 @@
 import {
   PackageNotFoundError
-} from "./chunk-D55REQA3.js";
+} from "./chunk-JUHOL5KB.js";
 import {
   OfficeError,
   resolveOfficeResources
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/bytes.ts
 function admitLimits(context, options, output) {

package/dist/safe-bash/command-chunks/{chunk-JQPNA77Y.js → chunk-NHNZYWPW.js}

@@ -1,13 +1,13 @@
 import {
   tableRows
-} from "./chunk-ML5R5JML.js";
+} from "./chunk-KY4LCHUF.js";
 import {
   DocumentPackage,
   macroTypes
 } from "./chunk-5BUL25DF.js";
 import {
   UnsupportedEditError
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   storedBooleanValue,
   storedIntegerIdentity,

package/dist/safe-bash/command-chunks/{chunk-ZYLGNIGA.js → chunk-NQINS4XY.js}

@@ -1,6 +1,6 @@
 import {
   OfficeError
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/retained-order.ts
 async function* sortKey(source) {

package/dist/safe-bash/command-chunks/{chunk-UAF4IX5H.js → chunk-NRFTYZ2R.js}

@@ -1,6 +1,6 @@
 import {
   validateColor
-} from "./chunk-5KGEZ3RW.js";
+} from "./chunk-CCMAHM3I.js";
 import {
   attr,
   child,
@@ -12,19 +12,19 @@ import {
   relPart,
   required,
   unique
-} from "./chunk-2Z3WRRFT.js";
+} from "./chunk-ADHFF2IM.js";
 import {
   readBinary
-} from "./chunk-LD7BONZY.js";
+} from "./chunk-NFII726L.js";
 import {
   parseXmlPart
-} from "./chunk-7PRL6RJ6.js";
+} from "./chunk-DBLQUZGN.js";
 import {
   relativePartReference
-} from "./chunk-U5TWQFZY.js";
+} from "./chunk-WTVJLHMG.js";
 import {
   OfficeError
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/backgrounds.ts
 var fills = ["solidFill", "gradFill", "blipFill", "noFill", "pattFill", "grpFill"];