@poe-platform/safe-bash 0.1.812 → 0.1.814

package/dist/safe-bash/command-chunks/{chunk-EVU7FLDA.js → chunk-S2QNBAN6.js}

@@ -6,29 +6,29 @@ import {
   packageAdmitImages,
   packageBindStyles,
   packageStyleAllocationIds
-} from "./chunk-FTLDRH47.js";
+} from "./chunk-CZ5K2YPU.js";
 import {
   editLatentStyles,
   readLatentStyles,
   styleLinkPatches
-} from "./chunk-DYLNU57U.js";
+} from "./chunk-FSVJ67G5.js";
 import {
   modelVfsResolver
-} from "./chunk-YXKNJ6EM.js";
+} from "./chunk-ZXELXF2H.js";
 import {
   contextData
 } from "./chunk-DMAOMHJQ.js";
 import {
   addDocumentStylesPart
-} from "./chunk-SOFM3GPG.js";
+} from "./chunk-42MEXZBJ.js";
 import {
   assertDocumentEditable,
   publicationGenerationGuard,
   publishDocumentArchive
-} from "./chunk-PZMU3Z4L.js";
+} from "./chunk-EVYKV3QI.js";
 import {
   SemanticValidationError
-} from "./chunk-JQPNA77Y.js";
+} from "./chunk-NHNZYWPW.js";
 import {
   PublicationError
 } from "./chunk-JGGRMERW.js";
@@ -60,7 +60,7 @@ import {
   themes,
   underline,
   xmlValue
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   storedBoolean
 } from "./chunk-ET5SFGRH.js";

package/dist/safe-bash/command-chunks/{chunk-YE6OAKK7.js → chunk-S43QRKDC.js}

@@ -1,24 +1,24 @@
 import {
   assertSettingsXmlReplacement
-} from "./chunk-3O2YEI47.js";
+} from "./chunk-JVKE7YZN.js";
 import {
   assertEquationXmlReplacement
-} from "./chunk-LABOWPFB.js";
+} from "./chunk-IHXZMAMY.js";
 import {
   assertDiagramGraphReplacement,
   assertDiagramXmlReplacement
-} from "./chunk-3ZDANXIC.js";
+} from "./chunk-HELAVGZH.js";
 import {
   readDocumentBindingOwnership
-} from "./chunk-RASQPOSV.js";
+} from "./chunk-3SPLP2DB.js";
 import {
   UnsupportedEmbeddedFontMutationError,
   embeddedFontState
-} from "./chunk-6NATRKUJ.js";
+} from "./chunk-JW6WVNTM.js";
 import {
   assertDocumentEditable,
   publishDocumentArchive
-} from "./chunk-PZMU3Z4L.js";
+} from "./chunk-EVYKV3QI.js";
 import {
   DocumentPackage,
   readDocumentArchive
@@ -27,7 +27,7 @@ import {
   UnsupportedEditError,
   displayXml,
   opaqueXmlContent
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   documentDialects
 } from "./chunk-WLANDWNW.js";

package/dist/safe-bash/command-chunks/{chunk-774GLJAO.js → chunk-S7HIOT7Z.js}

@@ -4,12 +4,12 @@ import {
 import {
   docxValueSchema
 } from "./chunk-RFMHNTTF.js";
-import {
-  structureModelBatchActions
-} from "./chunk-ZM2Y4Z3C.js";
 import {
   styleModelBatchOperations
-} from "./chunk-3OETVNJA.js";
+} from "./chunk-G2COZLXX.js";
+import {
+  structureModelBatchActions
+} from "./chunk-A45UG4KT.js";
 import {
   docxOperationSchemas,
   splitDocxType

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

@@ -0,0 +1,63 @@
+import {
+  OfficeError
+} from "./chunk-CXME4YHU.js";
+
+// packages/safe-bash-presentation-engine/src/retained-archive-staging.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+import { sha256 } from "@noble/hashes/sha2.js";
+async function stageRetainedArchive(input, originalFingerprint, archive, mutation, settings) {
+  const signal = settings.signal ?? new AbortController().signal;
+  let pages, closed = false, closing;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Archive output is closed.", "publish");
+    signal.throwIfAborted();
+  };
+  const close = () => {
+    closed = true;
+    return closing ??= pages?.close() ?? Promise.resolve();
+  };
+  const hex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  try {
+    let size = input.size, fingerprint = originalFingerprint, start = 0;
+    if (mutation.changed) {
+      const working = settings.workingStorage;
+      pages = new PagedStorage({ fs: working.fs, cwd: working.directory, env: {}, signal }, (working.cacheBytes ?? 1024 * 1024) / 16384);
+      start = pages.allocate(0);
+      size = 0;
+      const digest = sha256.create();
+      await archive.rewrite({ async write(bytes2) {
+        check();
+        for (let offset = 0; offset < bytes2.length; offset += 16384) {
+          check();
+          const owned = new Uint8Array(bytes2.subarray(offset, offset + 16384));
+          await pages.append(owned);
+          digest.update(owned);
+          size += owned.length;
+        }
+      } }, { replace: mutation.replacement, sourceOrder: "name" });
+      fingerprint = hex(digest.digest());
+    }
+    async function* bytes() {
+      check();
+      if (!pages) {
+        yield* input.stream();
+        check();
+        return;
+      }
+      for (let offset = 0; offset < size; offset += 16384) {
+        check();
+        yield await pages.read(start + offset, Math.min(16384, size - offset));
+      }
+      check();
+    }
+    return Object.freeze({ bytes, size, fingerprint, close });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw error;
+  }
+}
+
+export {
+  stageRetainedArchive
+};

package/dist/safe-bash/command-chunks/{chunk-JPMYPOYZ.js → chunk-SUTHGUD3.js}

@@ -1,99 +1,99 @@
 import {
   inspectDocumentSignatures,
   stripDocumentSignatures
-} from "./chunk-UOBW5K3M.js";
+} from "./chunk-4RRYWHED.js";
 import {
   editDocumentStyles,
   inspectDocumentStyles
-} from "./chunk-35IPOBWL.js";
+} from "./chunk-HI6ZYH3W.js";
 import {
   editDocumentTables
-} from "./chunk-K7CV55K5.js";
+} from "./chunk-3YEQI5B7.js";
 import {
   editDocumentRevisions
-} from "./chunk-SMSGLRIH.js";
+} from "./chunk-OTF2AJ5M.js";
 import {
   formatDocumentRuns
-} from "./chunk-WGH3RLJY.js";
+} from "./chunk-T5S4SJGO.js";
 import {
   editDocumentRevisionDecisions
-} from "./chunk-GQ2ZSPZ3.js";
+} from "./chunk-46AMTJPE.js";
 import {
   inspectDocumentSettings
-} from "./chunk-3O2YEI47.js";
+} from "./chunk-JVKE7YZN.js";
 import {
   extractDocumentText
-} from "./chunk-RIV6XN7K.js";
+} from "./chunk-7DOLY7IV.js";
 import {
   editDocumentParagraphs
-} from "./chunk-YV72XQKL.js";
+} from "./chunk-ETXPMVR6.js";
 import {
   editDocumentProperties,
   inspectDocumentProperties
-} from "./chunk-WFVSUXJL.js";
+} from "./chunk-BS5JEUEW.js";
 import {
   inspectDocumentRevisions
-} from "./chunk-MPORWUTU.js";
+} from "./chunk-V5XC43BX.js";
 import {
   inspectDocumentTable,
   inspectDocumentTables
-} from "./chunk-GZ3VIWNN.js";
+} from "./chunk-LKGTH2Q7.js";
 import {
   inspectDocumentParagraph,
   inspectDocumentParagraphs,
   inspectDocumentRun,
   inspectDocumentRuns
-} from "./chunk-P3WU3PSL.js";
+} from "./chunk-5L4YGRQU.js";
 import {
   inspectDocumentFonts
-} from "./chunk-6N5GHM72.js";
+} from "./chunk-6WNVGCXD.js";
 import {
   editDocumentFields,
   inspectDocumentFields
-} from "./chunk-D6UMSC45.js";
+} from "./chunk-F4YFTO2K.js";
 import {
   replaceDocumentText,
   setDocumentDummyText
-} from "./chunk-VB2TUPO2.js";
+} from "./chunk-3EW7GYHM.js";
 import {
   insertDocumentImage
-} from "./chunk-FYMNHG7R.js";
+} from "./chunk-AXXZNB7U.js";
 import {
   setDocumentImageLayout
-} from "./chunk-PINR7QET.js";
+} from "./chunk-4UPKVQWH.js";
 import {
   replaceDocumentImage
-} from "./chunk-S6ZTBXYO.js";
+} from "./chunk-XKAUKLF7.js";
 import {
   inspectDocumentImages
-} from "./chunk-43TRBJ2N.js";
+} from "./chunk-KPHLESD4.js";
 import {
   editDocumentLists
-} from "./chunk-JPA2PUYI.js";
+} from "./chunk-WBKB7HBZ.js";
 import {
   editDocumentComments,
   inspectDocumentComments
-} from "./chunk-SSKMPDN4.js";
+} from "./chunk-4GQKCUS5.js";
 import {
   applyDocumentTemplate
-} from "./chunk-U3SBHEKH.js";
+} from "./chunk-3EB2FSAN.js";
 import {
   editDocumentControlBindings
-} from "./chunk-4DLIUTQV.js";
+} from "./chunk-XU6S3XUZ.js";
 import {
   editDocumentControlRepeats
-} from "./chunk-DVGXLBUW.js";
+} from "./chunk-LZ2JFMKT.js";
 import {
   editDocumentControls,
   inspectDocumentControls
-} from "./chunk-SLQWQKXP.js";
+} from "./chunk-WWHMI4S3.js";
 import {
   editDocumentBookmarks
-} from "./chunk-6GI3NTCW.js";
+} from "./chunk-4B2ZUGLT.js";
 import {
   inspectDocumentPackageResources,
   packageResourceWarnings
-} from "./chunk-LLU2IQEJ.js";
+} from "./chunk-2BNGPR6Z.js";
 import {
   docxOperationSchemas
 } from "./chunk-RIKNMBLZ.js";

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

@@ -0,0 +1,286 @@
+import {
+  parseUnified,
+  parseUnifiedSection
+} from "./chunk-VT7UBPAE.js";
+import {
+  decodeHeaderPath
+} from "./chunk-AJEQUVDN.js";
+
+// packages/safe-bash-command-patch/src/patch-formats.ts
+import { ToolError, integer } from "../../safe-bash-diff-engine/shared.js";
+import { byteLength } from "../../safe-bash-io-engine/byte-encoding.js";
+var Reader = class {
+  constructor(input, budget, admit = true) {
+    this.budget = budget;
+    if (typeof input === "string") {
+      const lines = budget.split(input).map((line) => line.slice(0, -1));
+      this.input = { length: lines.length, async read(index) {
+        return lines[index];
+      } };
+    } else {
+      if (admit) budget.countLines(input.length);
+      this.input = input;
+    }
+  }
+  budget;
+  input;
+  index = 0;
+  peek() {
+    return this.input.read(this.index);
+  }
+  async take() {
+    this.budget.step();
+    {
+      const c = this.budget.checkpoint();
+      if (c) await c;
+    }
+    const line = await this.input.read(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 (await 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");
+  yield `--- ${quoted}
++++ ${quoted}
+`;
+  while (await reader.peek() !== void 0) {
+    if (await reader.peek() === "") {
+      await reader.take();
+      continue;
+    }
+    if (!/^\d/u.test(await 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;
+    yield `@@ -${oldStart},${oldCount} +${newStart},${newCount} @@
+`;
+    for (let index = 0; index < oldCount; index++) yield 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++) yield encoded({ kind: "+", text: await reader.content(">") });
+  }
+}
+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 start = reader.index;
+  let length = 0, common = 0, changed = false, incomplete = false;
+  const count = range.start === 0 ? 0 : range.last - range.start + 1;
+  while (await reader.peek() !== void 0 && length < count) {
+    const kind = await reader.peek() === "" ? " " : (await reader.peek())[0];
+    if (kind !== " " && kind !== "!" && kind !== (old ? "-" : "+")) break;
+    if (old && /^--- \d+(?:,\d+)? ----$/u.test(await reader.peek())) break;
+    const text = await reader.content(kind);
+    incomplete = !text.endsWith("\n");
+    length++;
+    if (kind === " ") common++;
+    changed ||= kind === "!";
+    if (length > reader.budget.limits.maxLines) throw new ToolError("context body line limit exceeded");
+  }
+  if (!old && length === count && incomplete) {
+    while (await reader.peek() === "\") await reader.take();
+  }
+  return { start, records: length, length, common, changed };
+}
+async function* contextLines(reader, side) {
+  const replay = new Reader(reader.input, reader.budget, false);
+  replay.index = side.start;
+  for (let index = 0; index < side.records; index++) {
+    const prefix = await replay.peek();
+    const kind = prefix === "" ? " " : prefix[0];
+    const text = await replay.content(kind);
+    if (!side.commonOnly || kind === " ") yield { kind, text };
+  }
+}
+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) {
+  while (await reader.peek() !== void 0) {
+    const header = await reader.take();
+    if (header === "") continue;
+    if (/^diff -[^ ]+ /u.test(header)) {
+      yield `${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");
+    yield `--- ${header.slice(4)}
++++ ${next.slice(4)}
+`;
+    let hunks = 0;
+    while ((await 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.changed) throw new ToolError("missing old changed context body");
+        oldLines = { ...newLines, length: newLines.common, commonOnly: true };
+      }
+      if (!newLines.length) {
+        if (oldLines.changed) throw new ToolError("missing new changed context body");
+        newLines = { ...oldLines, length: oldLines.common, commonOnly: true };
+      }
+      const oldCount = contextCount(oldRange, oldLines);
+      const newCount = contextCount(newRange, newLines);
+      yield `@@ -${oldRange.start},${oldCount} +${newRange.start},${newCount} @@${delimiter.slice(15)}
+`;
+      const oldIterator = contextLines(reader, oldLines), newIterator = contextLines(reader, newLines);
+      try {
+        let oldLine = await oldIterator.next(), newLine = await newIterator.next();
+        while (!oldLine.done || !newLine.done) {
+          let oldChanged = false, newChanged = false;
+          while (!oldLine.done && oldLine.value.kind !== " ") {
+            oldChanged ||= oldLine.value.kind === "!";
+            yield encoded({ kind: "-", text: oldLine.value.text });
+            reader.budget.step();
+            {
+              const c = reader.budget.checkpoint();
+              if (c) await c;
+            }
+            oldLine = await oldIterator.next();
+          }
+          while (!newLine.done && newLine.value.kind !== " ") {
+            newChanged ||= newLine.value.kind === "!";
+            yield encoded({ kind: "+", text: newLine.value.text });
+            reader.budget.step();
+            {
+              const c = reader.budget.checkpoint();
+              if (c) await c;
+            }
+            newLine = await newIterator.next();
+          }
+          if (oldChanged !== newChanged) throw new ToolError("unpaired changed context group");
+          if (!oldLine.done || !newLine.done) {
+            if (oldLine.done || newLine.done || !reader.budget.equal(oldLine.value.text, newLine.value.text)) throw new ToolError("context halves disagree");
+            yield encoded({ kind: " ", text: oldLine.value.text });
+            oldLine = await oldIterator.next();
+            newLine = await newIterator.next();
+          }
+        }
+      } finally {
+        await oldIterator.return(void 0);
+        await newIterator.return(void 0);
+      }
+    }
+    if (!hunks) throw new ToolError("context file patch has no hunks");
+    break;
+  }
+}
+async function parsePatch(text, budget, format, target, progress, convert) {
+  return parsePatchWith(text, budget, format, target, {
+    unified: (cursor) => parseUnifiedSection(cursor, budget),
+    converted: convert ?? (async (source) => {
+      const chunks = [];
+      for await (const chunk of source) chunks.push(chunk);
+      return parseUnified(chunks.join(""), budget);
+    })
+  }, progress);
+}
+async function parsePatchWith(text, budget, format, target, parsers, progress) {
+  if (typeof text === "string" && 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 (await reader.peek() !== void 0) {
+    try {
+      if (await reader.peek() === "") {
+        await reader.take();
+        continue;
+      }
+      if (!progress && patches.length && (await reader.peek()).startsWith("-") && !(await reader.peek()).startsWith("---")) {
+        throw new ToolError("unexpected deletion outside a patch hunk");
+      }
+      if (patches.length && !/^(?:Index: |diff |index |---|\*\*\*|@@|[+\\<>]|\d)/u.test(await reader.peek())) {
+        await reader.take();
+        continue;
+      }
+      let indexPath;
+      if ((await reader.peek())?.startsWith("Index: ")) {
+        indexPath = decodeHeaderPath((await reader.take()).slice(7));
+        if (/^=+$/u.test(await reader.peek() ?? "")) await reader.take();
+      }
+      const start = reader.index;
+      while (/^diff /u.test(await reader.peek() ?? "")) await reader.take();
+      const first = await 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 parsers.unified(reader)).map((patch) => ({ ...patch, ...indexPath === void 0 ? {} : { indexPath } })));
+      } else {
+        if (detected === "context") reader.index = start;
+        const source = detected === "normal" ? normal(reader, target ?? indexPath) : context(reader);
+        const converted = { async *[Symbol.asyncIterator]() {
+          for await (const chunk of source) {
+            convertedBytes += byteLength(chunk);
+            yield chunk;
+          }
+          if (convertedBytes > budget.limits.maxInputBytes * 2 + 16384) throw new ToolError("converted patch byte limit exceeded");
+        } };
+        const parsed = await parsers.converted(converted);
+        patches.push(...parsed.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,
+  parsePatchWith
+};

package/dist/safe-bash/command-chunks/{chunk-Y4EYCZFT.js → chunk-SWAKALDJ.js}

@@ -1,34 +1,34 @@
 import {
   escape
-} from "./chunk-56NYSX65.js";
+} from "./chunk-ADHFF2IM.js";
 import {
   writePackageArchive
-} from "./chunk-DM2CPMB4.js";
+} from "./chunk-KBAQHE5Y.js";
 import {
   buildSelectionIndex,
   readSelectionIndex
-} from "./chunk-X7FA7ZD5.js";
+} from "./chunk-W3ZSWK76.js";
 import {
   readPackage
-} from "./chunk-XPD636C4.js";
+} from "./chunk-IWHNRYER.js";
 import {
   readBinary
-} from "./chunk-PNGDJA6M.js";
+} from "./chunk-NFII726L.js";
 import {
   parseXmlPart
-} from "./chunk-554Z6IKP.js";
+} from "./chunk-DBLQUZGN.js";
 import {
   parseContentTypes
-} from "./chunk-WJCN2IXI.js";
+} from "./chunk-ZQM37BGE.js";
 import {
   readRelationshipGraph
-} from "./chunk-ZMHEGDU2.js";
+} from "./chunk-LNTEV56A.js";
 import {
   relativePartReference
-} from "./chunk-36XGIPOG.js";
+} from "./chunk-WTVJLHMG.js";
 import {
   OfficeError
-} from "./chunk-Q73EMLLZ.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/links.ts
 var dialects = [

package/dist/safe-bash/command-chunks/{chunk-QUM3SYAJ.js → chunk-SYSX46IV.js}

@@ -1,11 +1,11 @@
 import {
   htmlSpace
-} from "./chunk-SPW4GW4Z.js";
+} from "./chunk-DFI7QF3M.js";
 import {
   Builder
-} from "./chunk-AGLK7OJR.js";
+} from "./chunk-HDSIIQBS.js";
 
-// packages/safe-bash-command-html-to-markdown/src/entities.ts
+// packages/safe-bash-command-html-to-markdown/dist/chunk-SZCXH5X5.js
 var named = Object.freeze({
   amp: "&",
   lt: "<",

package/dist/safe-bash/command-chunks/{chunk-WGH3RLJY.js → chunk-T5S4SJGO.js}

@@ -1,23 +1,23 @@
 import {
   openDocumentLocations,
   resolveDocxSelection
-} from "./chunk-UZL7G57V.js";
+} from "./chunk-CKEMZUE3.js";
 import {
   DocumentArchiveEditor
-} from "./chunk-QDVI2YB6.js";
-import {
-  validateDocxInvocation
-} from "./chunk-GXLXWZWH.js";
+} from "./chunk-VUWXLH3E.js";
 import {
   replaceRunContent
-} from "./chunk-CU4DLVME.js";
+} from "./chunk-BLIFGBIO.js";
 import {
   pathContains
-} 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 {
   runElementOpen,
   splitNativeTextRunXml,
   xmlValue
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   SelectionError,
   closedRecord,