@poe-platform/safe-bash 0.1.816 → 0.1.818

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

@@ -0,0 +1,398 @@
+import {
+  openRetainedPresentationIndex,
+  stageRetainedOutput,
+  streamJson
+} from "./chunk-3ZGO24WG.js";
+import {
+  attr,
+  child,
+  escape,
+  invalid,
+  loadShared,
+  nextRel,
+  relPart
+} from "./chunk-A32PUWYE.js";
+import {
+  SelectionError,
+  decodeSelectionToken
+} from "./chunk-3W3HLPCX.js";
+import {
+  openRetainedPresentationValidation
+} from "./chunk-N6VNHC3B.js";
+import {
+  dialects
+} from "./chunk-6KJDTKE4.js";
+import {
+  parseXmlPart
+} from "./chunk-7PYDVQPB.js";
+import {
+  relativePartReference
+} from "./chunk-MOUCMZZP.js";
+import {
+  OfficeError,
+  RetainedValues,
+  equal,
+  folded,
+  literal,
+  openRetainedXmlDocument,
+  resolveOfficeResources
+} from "./chunk-KM2SMMXZ.js";
+
+// packages/safe-bash-presentation-engine/src/retained-tags.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+async function openRetainedTags(archive, fingerprint, options, settings) {
+  validateTagOptions(options);
+  const query = { ...options, ...options.selection ? { selection: { ...options.selection, ...options.selection.position ? { position: { ...options.selection.position } } : {} } } : {} };
+  const context = resolveOfficeResources(settings), working = { ...settings.workingStorage }, signal = context.signal ?? new AbortController().signal;
+  const index = await openRetainedPresentationIndex(archive, fingerprint, { ...context, workingStorage: working });
+  const pages = new PagedStorage({ fs: working.fs, cwd: working.directory, env: {}, signal }, (working.cacheBytes ?? 1024 * 1024) / 16384);
+  let closed = false, closing, head = 0, tail = 0;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Tags are closed.", "index");
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "index");
+  };
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const outcomes = await Promise.allSettled([index.close(), pages.close()]);
+      for (const outcome of outcomes) if (outcome.status === "rejected") throw outcome.reason;
+    })();
+  };
+  const values = new RetainedValues(pages, check, signal);
+  const range = (row2, offset) => ({ start: row2[offset], length: row2[offset + 1] });
+  async function row(pointer) {
+    check();
+    const bytes = await pages.read(pointer, 7 /* Count */ * 8), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return Array.from({ length: 7 /* Count */ }, (_, n) => view.getFloat64(n * 8, true));
+  }
+  async function write(pointer, numbers) {
+    check();
+    const bytes = new Uint8Array(numbers.length * 8), view = new DataView(bytes.buffer);
+    numbers.forEach((number, n) => view.setFloat64(n * 8, number, true));
+    await pages.write(pointer, bytes);
+  }
+  async function bounded(value) {
+    const decoder = new TextDecoder();
+    let result = "";
+    for await (const bytes of values.read(value)) result += decoder.decode(bytes, { stream: true });
+    return result + decoder.decode();
+  }
+  const invalid2 = (message) => {
+    throw new OfficeError("invalid-value", message, "usage");
+  };
+  async function is(document, node, local, namespace) {
+    return await equal(document.raw(node.localName), literal(local)) && await equal(document.namespace(node), namespace);
+  }
+  async function child2(document, parent, local) {
+    let found;
+    for await (const node of document.children(parent)) if (node.kind === "element" && await is(document, node, local, document.namespace(parent))) {
+      if (found) invalid2("Ambiguous shared structure.");
+      found = node;
+    }
+    return found;
+  }
+  async function attribute(document, node, local, namespace = "") {
+    for await (const attr2 of document.attributes(node)) if (await is(document, attr2, local, literal(namespace))) return attr2;
+    return void 0;
+  }
+  try {
+    const validation = await openRetainedPresentationValidation(archive, { ...context, workingStorage: working }, { ...context.xmlLimits, ...context.relationshipLimits, maxBytes: Math.min(context.xmlLimits.maxBytes, context.relationshipLimits.maxBytes), maxEntries: context.archiveLimits.maxMembers });
+    const valid = validation.valid;
+    try {
+      await validation.close();
+    } catch (error) {
+      if (valid) await Promise.reject(error);
+    }
+    if (!valid) throw new OfficeError("invalid-opc", "Invalid presentation graph.", "validate-intent");
+    for await (const part of archive.parts()) {
+      const key = await values.store(folded(literal(part))), value = await values.store(literal(part));
+      await values.insert("parts", key, value);
+    }
+    const main = await openRetainedXmlDocument(archive.read(index.records.main), { ...context, workingStorage: working });
+    let dialect = dialects[0], failed = false;
+    try {
+      for (const candidate of dialects) if (await equal(main.namespace(main.root), literal(candidate.p))) dialect = candidate;
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      try {
+        await main.close();
+      } catch (error) {
+        if (!failed) await Promise.reject(error);
+      }
+    }
+    let token;
+    if (query.selection?.token) {
+      if (Object.keys(query.selection).some((key) => key !== "token")) throw new SelectionError("invalid-selection");
+      token = decodeSelectionToken(query.selection.token);
+      if (token.fingerprint !== fingerprint) throw new SelectionError("stale-selection");
+      if (token.scope !== "slides" && token.scope !== "presentation" || query.scope !== void 0 && query.scope !== token.scope) throw new SelectionError("invalid-selection");
+    }
+    async function* owners2() {
+      if ((token?.scope ?? query.scope) === "presentation") {
+        yield { part: index.records.main, slide: null };
+        return;
+      }
+      const selected = token ? void 0 : query.selection;
+      for await (const record of selected ? index.records.select({ kind: "slide", ...selected }) : index.records.records("slide")) {
+        if (record.kind !== "slide") throw new SelectionError("invalid-selection");
+        yield { part: record.part, slide: record.position };
+      }
+    }
+    for await (const ignoredOwner of owners2()) check();
+    for await (const owner of owners2()) {
+      const document = await openRetainedXmlDocument(archive.read(owner.part), { ...context, workingStorage: working });
+      let failed2 = false, reference;
+      try {
+        const base = owner.part === index.records.main ? document.root : await child2(document, document.root, "cSld");
+        if (!base) invalid2("Tag owner lacks common slide data.");
+        const list = await child2(document, base, "custDataLst"), tags2 = list ? await child2(document, list, "tags") : void 0;
+        if (tags2) {
+          const id = await attribute(document, tags2, "id", dialect.r);
+          let count = 0;
+          if (id) {
+            for await (const edge of index.graph.outgoing(owner.part)) if (edge.owner === owner.part && !edge.external && await equal(edge.type(), literal(`${dialect.r}/tags`)) && await equal(edge.id(), document.text(id))) {
+              count++;
+              if (edge.targetPart) reference = await values.store(edge.targetPart());
+            }
+          }
+          if (count !== 1 || !reference) invalid2("Invalid tag association.");
+        }
+      } catch (error) {
+        failed2 = true;
+        throw error;
+      } finally {
+        try {
+          await document.close();
+        } catch (error) {
+          if (!failed2) await Promise.reject(error);
+        }
+      }
+      if (!reference) continue;
+      const original = await values.find("parts", () => folded(values.read(reference)));
+      if (!original) throw new OfficeError("missing-binding", "Package member is absent.", "index");
+      const part = await bounded(reference), tags = await openRetainedXmlDocument(archive.read(await bounded(original)), { ...context, workingStorage: working });
+      let failedTags = false;
+      try {
+        if (!await is(tags, tags.root, "tagLst", literal(dialect.p))) invalid2("Invalid tag list.");
+        let childIndex = 0;
+        for await (const node of tags.children(tags.root)) {
+          if (node.kind !== "element") continue;
+          const position = childIndex++;
+          if (!await is(tags, node, "tag", literal(dialect.p))) continue;
+          const name = await attribute(tags, node, "name"), value = await attribute(tags, node, "val");
+          if (!name || !value) invalid2("Tag requires name and value attributes.");
+          const location = { fingerprint, scope: owner.slide === null ? "presentation" : "slides", owner: owner.part, objectId: `tag:${part}:${position}`, coordinateSystem: "identity" };
+          const metadata = await values.store(literal(JSON.stringify({ part, owner: owner.part, slide: owner.slide, selector: JSON.stringify(location), location })));
+          const key = await values.store(tags.text(name)), text = await values.store(tags.text(value));
+          const pointer = pages.allocate(7 /* Count */ * 8);
+          await write(pointer, [0, metadata.start, metadata.length, key.start, key.length, text.start, text.length]);
+          if (tail) await write(tail, [pointer]);
+          else head = pointer;
+          tail = pointer;
+        }
+      } catch (error) {
+        failedTags = true;
+        throw error;
+      } finally {
+        try {
+          await tags.close();
+        } catch (error) {
+          if (!failedTags) await Promise.reject(error);
+        }
+      }
+    }
+    await index.close();
+    return Object.freeze({ close, async *records() {
+      check();
+      for (let pointer = head; pointer; ) {
+        const data = await row(pointer);
+        pointer = data[0 /* Next */];
+        const metadata = JSON.parse(await bounded(range(data, 1 /* Metadata */)));
+        if (token && metadata.selector !== query.selection.token) continue;
+        yield { name: () => values.read(range(data, 3 /* Name */)), value: () => values.read(range(data, 5 /* Value */)), ...metadata };
+      }
+      check();
+    } });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw error instanceof OfficeError ? error : new OfficeError(signal.aborted ? "cancelled" : "io-failure", "Tag storage operation failed.", "index");
+  }
+}
+async function stageRetainedTags(archive, fingerprint, query, settings, output) {
+  const format = { ...output };
+  if (!["tags.list", "tags.get"].includes(format.operation)) throw new OfficeError("invalid-value", "Invalid tag read operation.", "usage");
+  const tags = await openRetainedTags(archive, fingerprint, query, settings);
+  let staged;
+  try {
+    if (format.operation === "tags.get") {
+      let count = 0;
+      for await (const ignoredRecord of tags.records()) count++;
+      if (count !== 1) throw new SelectionError(count ? "ambiguous-selection" : "missing-selection");
+    }
+    async function* locations() {
+      for await (const tag of tags.records()) yield tag.location;
+    }
+    async function* render() {
+      if (format.json) {
+        yield* streamJson({ version: 1, operation: format.operation, ok: true, data: { tags: tags.records() }, affected: 0, warnings: [], errors: [], locations: locations() });
+        yield* literal("\n");
+      } else for await (const tag of tags.records()) {
+        yield* streamJson(tag.name);
+        yield* literal(": ");
+        yield* streamJson(tag.value);
+        yield* literal("\n");
+      }
+    }
+    staged = await stageRetainedOutput(render(), settings, format.maxOutputBytes);
+    await tags.close();
+    return staged;
+  } catch (error) {
+    await Promise.allSettled([tags.close(), staged?.close()]);
+    throw error;
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/tags.ts
+var relns = "http://schemas.openxmlformats.org/package/2006/relationships";
+function validateTagOptions(options, action) {
+  if (!options || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Object.keys(options).some((key) => !["scope", "selection", "name", "value", "allowEmpty"].includes(key)) || options.scope !== void 0 && !["presentation", "slides"].includes(options.scope) || options.allowEmpty !== void 0 && typeof options.allowEmpty !== "boolean") invalid("Invalid tag options.");
+  if (options.scope === "presentation" && options.selection && Object.keys(options.selection).some((key) => key !== "all" && key !== "token")) invalid("Presentation tags do not accept slide selectors.");
+  if (action === "add" && (options.name === void 0 || options.value === void 0)) invalid("New tags require name and value.");
+  if (action === "set" && options.name === void 0 && options.value === void 0) invalid("A tag edit requires name or value.");
+  for (const value of [options.name, options.value]) {
+    if (value === void 0) continue;
+    if (typeof value !== "string") invalid("Tag fields require strings.");
+    for (const c of value) {
+      const n = c.codePointAt(0);
+      if (n < 32 && ![9, 10, 13].includes(n) || n >= 55296 && n <= 57343 || n === 65534 || n === 65535) invalid("Tag fields require XML characters.");
+    }
+  }
+  if (options.name === "") invalid("Tag names cannot be empty.");
+  if (!action && (options.name !== void 0 || options.value !== void 0 || options.allowEmpty !== void 0)) invalid("Tag reads accept selection and scope only.");
+  if (action === "remove" && (options.name !== void 0 || options.value !== void 0)) invalid("Tag removal does not accept edit fields.");
+}
+function owners(s, options) {
+  if (options.scope === "presentation") return [{ part: s.main, slide: null }];
+  const selection = options.selection;
+  return (selection ? s.index.select({ kind: "slide", ...selection }) : s.index.slides).map((record) => {
+    if (record.kind !== "slide") throw new SelectionError("invalid-selection");
+    return { part: record.part, slide: record.position };
+  });
+}
+function association(s, owner) {
+  const doc = s.doc(owner);
+  const base = owner === s.main ? doc.root : child(doc.root, "cSld");
+  if (!base) invalid("Tag owner lacks common slide data.");
+  const list = child(base, "custDataLst");
+  const tags = list ? child(list, "tags") : void 0;
+  if (!tags) return void 0;
+  const id = tags.attributes.find((a) => a.name.namespace === s.r && a.name.localName === "id")?.value;
+  const edges = s.index.inventory.relationships.filter((e) => e.owner === owner && e.id === id && e.type === `${s.r}/tags` && !e.external);
+  if (edges.length !== 1 || !edges[0].targetPart) invalid("Invalid tag association.");
+  return edges[0].targetPart;
+}
+function records(s, options) {
+  let token;
+  if (options.selection?.token) {
+    if (Object.keys(options.selection).some((key) => key !== "token")) throw new SelectionError("invalid-selection");
+    token = decodeSelectionToken(options.selection.token);
+    if (token.fingerprint !== s.index.fingerprint) throw new SelectionError("stale-selection");
+    if (token.scope !== "slides" && token.scope !== "presentation") throw new SelectionError("invalid-selection");
+    if (options.scope !== void 0 && options.scope !== token.scope) throw new SelectionError("invalid-selection");
+  }
+  const selected = owners(s, token ? { scope: token.scope } : options);
+  const result = selected.flatMap((owner) => {
+    const part = association(s, owner.part);
+    if (!part) return [];
+    const doc = s.doc(part);
+    if (doc.root.name.namespace !== s.p || doc.root.name.localName !== "tagLst") invalid("Invalid tag list.");
+    return doc.root.children.flatMap((node, index) => {
+      if (node.name.namespace !== s.p || node.name.localName !== "tag") return [];
+      const name = attr(node, "name"), value = attr(node, "val");
+      if (name === void 0 || value === void 0) invalid("Tag requires name and value attributes.");
+      const location = { fingerprint: s.index.fingerprint, scope: owner.slide === null ? "presentation" : "slides", owner: owner.part, objectId: `tag:${part}:${index}`, coordinateSystem: "identity" };
+      return [{ name, value, part, owner: owner.part, slide: owner.slide, selector: JSON.stringify(location), location }];
+    });
+  });
+  return token ? result.filter((r) => r.selector === options.selection.token) : result;
+}
+async function readTags(input, options, context) {
+  validateTagOptions(options);
+  return records(await loadShared(input, context, false), options);
+}
+function createAssociation(s, owner, context) {
+  let n = 1;
+  while (s.reader.has(`/ppt/tags/tag${n}.xml`) || s.changes.has(`/ppt/tags/tag${n}.xml`)) n++;
+  const part = `/ppt/tags/tag${n}.xml`;
+  s.save(part, parseXmlPart(new TextEncoder().encode(`<p:tagLst xmlns:p="${s.p}"/>`), context.xmlLimits));
+  const types = s.doc("/[Content_Types].xml");
+  s.save("/[Content_Types].xml", types.spliceChildren(types.root, types.root.children.length, 0, [`<Override xmlns="${types.root.name.namespace}" PartName="${part}" ContentType="application/vnd.openxmlformats-officedocument.presentationml.tags+xml"/>`]));
+  const relName = relPart(owner);
+  const rels = s.reader.has(relName) ? s.doc(relName) : parseXmlPart(new TextEncoder().encode(`<Relationships xmlns="${relns}"/>`), context.xmlLimits);
+  const id = nextRel(rels);
+  s.save(relName, rels.spliceChildren(rels.root, rels.root.children.length, 0, [`<Relationship xmlns="${relns}" Id="${id}" Type="${s.r}/tags" Target="${escape(relativePartReference(part, owner.slice(0, owner.lastIndexOf("/"))))}"/>`]));
+  let doc = s.doc(owner);
+  let base = owner === s.main ? doc.root : child(doc.root, "cSld");
+  let list = child(base, "custDataLst");
+  if (!list) {
+    const order = owner === s.main ? ["sldMasterIdLst", "notesMasterIdLst", "handoutMasterIdLst", "sldIdLst", "sldSz", "notesSz", "smartTags", "embeddedFontLst", "custShowLst", "photoAlbum", "custDataLst", "kinsoku", "defaultTextStyle", "modifyVerifier", "extLst"] : ["bg", "spTree", "custDataLst", "controls", "extLst"];
+    doc = doc.merge(base, { children: { sequence: order.map((localName) => ({ namespace: s.p, localName })), upsert: [{ name: { namespace: s.p, localName: "custDataLst" }, merge: {} }] } });
+    base = owner === s.main ? doc.root : child(doc.root, "cSld");
+    list = child(base, "custDataLst");
+  }
+  s.save(owner, doc.spliceChildren(list, list.children.length, 0, [`<p:tags xmlns:p="${s.p}" xmlns:r="${s.r}" r:id="${id}"/>`]));
+  return part;
+}
+async function mutateTags(input, action, options, context) {
+  if (!["add", "set", "remove"].includes(action)) invalid("Invalid tag action.");
+  validateTagOptions(options, action);
+  if ((options.name?.length ?? 0) + (options.value?.length ?? 0) > context.xmlLimits.maxBytes) throw new OfficeError("resource-limit", "Tag exceeds XML limits.", "usage");
+  if (!options.selection && options.scope !== "presentation") throw new SelectionError("missing-selection");
+  const s = await loadShared(input, context);
+  const existing = records(s, options);
+  const locations = [];
+  if (action === "add") {
+    if (options.selection?.token) throw new SelectionError("invalid-selection");
+    const selected = owners(s, options);
+    if (!selected.length && !options.allowEmpty) throw new SelectionError("missing-selection");
+    for (const owner of selected) {
+      if (existing.some((r) => r.owner === owner.part && r.name === options.name)) invalid("Duplicate tag name.");
+      const part = association(s, owner.part) ?? createAssociation(s, owner.part, context);
+      if (s.index.inventory.relationships.filter((e) => e.targetPart === part).length > 1) throw new OfficeError("unsupported-edit", "Shared tag lists cannot be edited.", "validate-intent");
+      const doc = s.doc(part);
+      const location = { fingerprint: s.index.fingerprint, scope: owner.slide === null ? "presentation" : "slides", owner: owner.part, objectId: `tag:${part}:${doc.root.children.length}`, coordinateSystem: "identity" };
+      s.save(part, doc.spliceChildren(doc.root, doc.root.children.length, 0, [`<p:tag xmlns:p="${s.p}" name="${escape(options.name)}" val="${escape(options.value)}"/>`]));
+      locations.push(location);
+    }
+  } else {
+    if (!existing.length && !options.allowEmpty) throw new SelectionError("missing-selection");
+    if (existing.length > 1 && !options.selection?.all) throw new SelectionError("ambiguous-selection");
+    if (options.name !== void 0) {
+      const all = records(s, { scope: existing[0]?.location.scope });
+      for (const record of existing) if (all.some((r) => r.owner === record.owner && r.name === options.name && r.selector !== record.selector)) invalid("Duplicate tag name.");
+      if (existing.some((r, i) => existing.slice(0, i).some((v) => v.owner === r.owner))) invalid("Duplicate tag name.");
+    }
+    for (const record of [...existing].reverse()) {
+      if (s.index.inventory.relationships.filter((e) => e.targetPart === record.part).length > 1) throw new OfficeError("unsupported-edit", "Shared tag lists cannot be edited.", "validate-intent");
+      const doc = s.doc(record.part);
+      const index = Number(record.location.objectId.slice(record.location.objectId.lastIndexOf(":") + 1));
+      const node = doc.root.children[index];
+      if (action === "remove" && (node.children.length || node.attributes.some((a) => a.name.namespace !== "" || !["name", "val"].includes(a.name.localName)))) throw new OfficeError("unsupported-edit", "Decorated tags are preserved on removal.", "validate-intent");
+      s.save(record.part, action === "remove" ? doc.spliceChildren(doc.root, index, 1, []) : doc.merge(doc.root.children[index], { attributes: [...options.name === void 0 ? [] : [{ namespace: "", localName: "name", value: options.name }], ...options.value === void 0 ? [] : [{ namespace: "", localName: "val", value: options.value }]] }));
+      locations.push(record.location);
+    }
+  }
+  const result = await s.finish(s.main, []);
+  return { bytes: result.bytes, affected: locations.length, locations };
+}
+
+export {
+  openRetainedTags,
+  stageRetainedTags,
+  validateTagOptions,
+  readTags,
+  mutateTags
+};

package/dist/safe-bash/command-chunks/{chunk-4QEJPP3K.js → chunk-S5X7PBO4.js}

@@ -3503,7 +3503,7 @@ function readCommentGeometry(roots, charge) {
       else if (name === "z-index" && value && Number.isSafeInteger(Number(value))) style[name] = value;
     }
     const flags = [];
-    for (const name of ["MoveWithCells", "SizeWithCells", "Visible", "AutoFill"]) {
+    for (const name of ["MoveWithCells", "SizeWithCells", "Visible", "AutoFill", "Locked", "LockText"]) {
       const field = fields3.get(name);
       if (!field) continue;
       const text = field.text.trim();

package/dist/safe-bash/command-chunks/{chunk-IHLZ6HNQ.js → chunk-TSKJNCKD.js}

@@ -202,6 +202,7 @@ async function stageZip(scope, prepared, consume) {
   const capabilities = await scope.operation(() => fs.capabilitiesFor?.(prepared.parent, { signal }) ?? fs.capabilities);
   if (capabilities.atomicFileStaging !== true && capabilities.trustedOwnedStaging !== true || !fs.createStagedFile || !fs.removeStagedFile) fail("ZIP temporary path requires atomic owned file staging");
   if (prepared.source && (capabilities.atomicFileMutation !== true && capabilities.trustedOwnedStaging !== true || !fs.writeFileConditional)) fail("ZIP temporary path requires atomic conditional writes");
+  const buffered = prepared.source && capabilities.retainedStagingWrite !== true ? await collectBytes(prepared.source, { signal, maxBytes: scope.limits.maxArchiveBytes }) : void 0;
   let staging;
   let failure;
   const close = retainFileSystemCleanup(fs, async (cleanup) => {
@@ -219,7 +220,7 @@ async function stageZip(scope, prepared, consume) {
       if (path === prepared.reservedPath) continue;
       try {
         await scope.operation(async () => {
-          staging = await fs.createStagedFile(path, "archive.zip", { type: "file", data: prepared.bytes ?? new Uint8Array() }, {
+          staging = await fs.createStagedFile(path, "archive.zip", { type: "file", data: buffered ?? prepared.bytes ?? new Uint8Array() }, {
             signal,
             parent: prepared.parentStat,
             ...capabilities.retainedStagingCleanup ? { retainCleanup: true } : {},
@@ -234,7 +235,7 @@ async function stageZip(scope, prepared, consume) {
       }
     }
     if (!staging) fail("ZIP temporary directory attempt limit exceeded");
-    if (prepared.source) {
+    if (prepared.source && buffered === void 0) {
       for await (const chunk of readBytes(prepared.source, signal)) {
         try {
           await writeFileOutput(scope.context, chunk, (bytes) => scope.operation(async () => {

package/dist/safe-bash/command-chunks/{chunk-U42WHQRH.js → chunk-TTTNFKT6.js}

@@ -1,21 +1,21 @@
 import {
   drawingColorSchema,
   drawingUpdateSchema
-} from "./chunk-T2FRXSQT.js";
+} from "./chunk-ZBXUAM34.js";
 import {
   MSO_LANGUAGE_ID
-} from "./chunk-UKAGRRLZ.js";
+} from "./chunk-5VY5O37W.js";
 import {
   MSO_TEXT_UNDERLINE_TYPE,
   validateTextRunOptions
-} from "./chunk-GR4ONCQ5.js";
+} from "./chunk-424NYO35.js";
 import {
   validateDrawingUpdate
-} from "./chunk-PPN53PX3.js";
+} from "./chunk-BB7HBO56.js";
 import {
   defineEnum,
   defineXmlEnum
-} from "./chunk-UFLMOU3B.js";
+} from "./chunk-VUJCVXD4.js";
 import {
   Length
 } from "./chunk-B6XTAKKQ.js";

package/dist/safe-bash/command-chunks/{chunk-EWC56JNI.js → chunk-TTVJJZOM.js}

@@ -1,16 +1,16 @@
 import {
   openDocumentLocations,
   resolveDocxSelection
-} from "./chunk-KDBU5Q2N.js";
+} from "./chunk-MWVELMXZ.js";
 import {
   measurePackageResourceSerialization
-} from "./chunk-RTHYAGKI.js";
+} from "./chunk-ETN25WCR.js";
 import {
   validateDocxInvocation
-} from "./chunk-ZM7HMBAJ.js";
+} from "./chunk-BDGNKRY4.js";
 import {
   publishDocumentFiles
-} from "./chunk-N3ZH4YYH.js";
+} from "./chunk-LTWX23FS.js";
 import {
   PublicationError
 } from "./chunk-JGGRMERW.js";
@@ -22,7 +22,7 @@ import {
 } from "./chunk-WLANDWNW.js";
 import {
   docxOperationSchemas
-} from "./chunk-FEKECRJP.js";
+} from "./chunk-EBTKM7KX.js";
 import {
   MarkupCompatibility,
   compatibilityProfileForPart

package/dist/safe-bash/command-chunks/{chunk-TY7JXEWI.js → chunk-UBX5I5HY.js}

@@ -1,42 +1,42 @@
 import {
   UnsupportedEquationMutationError,
   collectEquationUnits
-} from "./chunk-62RG3GHF.js";
+} from "./chunk-K6E56LND.js";
 import {
   UnsupportedDiagramMutationError,
   collectDiagramObservations
-} from "./chunk-T4SEQU66.js";
+} from "./chunk-X4TWJNW7.js";
 import {
   openDocumentLocations,
   resolveDocxSelection
-} from "./chunk-KDBU5Q2N.js";
+} from "./chunk-MWVELMXZ.js";
 import {
   DocumentArchiveEditor
-} from "./chunk-N4HWOLGZ.js";
+} from "./chunk-GY2C555A.js";
 import {
   sectionAttribute,
   sectionChild
-} from "./chunk-DM5WURQL.js";
+} from "./chunk-JY2T3KV2.js";
 import {
   addDocumentStylesPart,
   styleAllocationIds
-} from "./chunk-5GDF5FAS.js";
+} from "./chunk-EEJ3YXVO.js";
 import {
   paragraphTextRun,
   replaceParagraphContent,
   splitParagraphContent
-} from "./chunk-HOKPYTHQ.js";
+} from "./chunk-MPRUGL4W.js";
 import {
   LocationIndex,
   addressKey
-} from "./chunk-OCV5ZU35.js";
+} from "./chunk-VSTAHYCV.js";
 import {
   validateDocxInvocation
-} from "./chunk-ZM7HMBAJ.js";
+} from "./chunk-BDGNKRY4.js";
 import {
   assertDocumentEditable,
   publishDocumentArchive
-} from "./chunk-N3ZH4YYH.js";
+} from "./chunk-LTWX23FS.js";
 import {
   DocumentPackage
 } from "./chunk-5BUL25DF.js";
@@ -58,7 +58,7 @@ import {
   runElementOpen,
   selectNamedStyles,
   xmlValue
-} from "./chunk-LZY46GYY.js";
+} from "./chunk-QMWBKR4C.js";
 import {
   dialectForNamespace,
   documentDialects

package/dist/safe-bash/command-chunks/{chunk-QOKFSYD5.js → chunk-UE34SQET.js}

@@ -4,27 +4,27 @@ import {
   openControlInventory,
   prepareControlPlaceholder,
   prepareControlValue
-} from "./chunk-LQDANF2B.js";
+} from "./chunk-CCNOZKAK.js";
 import {
   assertOutsideFields,
   parseFields
-} from "./chunk-2ALHVXEM.js";
+} from "./chunk-6EK76ERE.js";
 import {
   characterizeRasterHeader
-} from "./chunk-JA36YOZI.js";
+} from "./chunk-LUJUYUOG.js";
 import {
   pathContains
-} from "./chunk-OCV5ZU35.js";
+} from "./chunk-VSTAHYCV.js";
 import {
   validateDocxInvocation
-} from "./chunk-ZM7HMBAJ.js";
+} from "./chunk-BDGNKRY4.js";
 import {
   assertDocumentEditable,
   publishDocumentArchive
-} from "./chunk-N3ZH4YYH.js";
+} from "./chunk-LTWX23FS.js";
 import {
   tableRows
-} from "./chunk-5O45KGW5.js";
+} from "./chunk-C5VUJOUQ.js";
 import {
   DocumentPackage
 } from "./chunk-5BUL25DF.js";
@@ -35,11 +35,11 @@ import {
   assertOutsideRevisionRanges,
   containsRevision,
   xmlValue
-} from "./chunk-LZY46GYY.js";
+} from "./chunk-QMWBKR4C.js";
 import {
   storedIntegerIdentity,
   trimXmlWhitespace
-} from "./chunk-QDV2NIFR.js";
+} from "./chunk-2TMTGVJR.js";
 import {
   commentExtensionParts
 } from "./chunk-WLANDWNW.js";

package/dist/safe-bash/command-chunks/{chunk-DXOXUKQB.js → chunk-UH4CQIU3.js}

@@ -2,7 +2,7 @@ import {
   openRetainedPresentationIndex,
   stageRetainedOutput,
   streamJson
-} from "./chunk-FB2WPI3M.js";
+} from "./chunk-3ZGO24WG.js";
 import {
   attr,
   child,
@@ -12,13 +12,13 @@ import {
   nextRel,
   relPart,
   required
-} from "./chunk-A5SPMSKD.js";
+} from "./chunk-A32PUWYE.js";
 import {
   SelectionError
-} from "./chunk-NCNHJRIY.js";
+} from "./chunk-3W3HLPCX.js";
 import {
   openRetainedPresentationValidation
-} from "./chunk-6W4RMBFH.js";
+} from "./chunk-N6VNHC3B.js";
 import {
   dialects
 } from "./chunk-6KJDTKE4.js";

package/dist/safe-bash/command-chunks/{chunk-VNNNVT4C.js → chunk-UZZ2WJQV.js}

@@ -2,20 +2,20 @@ import {
   nodeFor,
   selected,
   validateSelection
-} from "./chunk-LMLBQSAM.js";
+} from "./chunk-YW7WU7W2.js";
 import {
   validateShapeOptions
-} from "./chunk-3K5CVXUV.js";
+} from "./chunk-NZF56C25.js";
 import {
   attr,
   child,
   loadShared,
   required
-} from "./chunk-A5SPMSKD.js";
+} from "./chunk-A32PUWYE.js";
 import {
   SelectionError,
   readSelectionIndex
-} from "./chunk-NCNHJRIY.js";
+} from "./chunk-3W3HLPCX.js";
 import {
   OfficeError
 } from "./chunk-KM2SMMXZ.js";