@poe-platform/safe-bash 0.1.815 → 0.1.816

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

@@ -0,0 +1,502 @@
+import {
+  fieldTypeKinds
+} from "./chunk-YXR4JE4U.js";
+import {
+  openRetainedPresentationIndex,
+  stageRetainedOutput,
+  streamJson
+} from "./chunk-FB2WPI3M.js";
+import {
+  readFramePropertyValues,
+  textVerticalModes
+} from "./chunk-3K5CVXUV.js";
+import {
+  validateTextReadingOptions
+} from "./chunk-YKODRSGT.js";
+import {
+  SelectionError
+} from "./chunk-NCNHJRIY.js";
+import {
+  dialects,
+  openRetainedCompatibility
+} from "./chunk-6KJDTKE4.js";
+import {
+  equationOpaqueElements
+} from "./chunk-GTOMW4VV.js";
+import {
+  OfficeError,
+  RetainedValues,
+  characters,
+  equal,
+  folded,
+  literal,
+  openRetainedXmlDocument,
+  resolveOfficeResources
+} from "./chunk-KM2SMMXZ.js";
+
+// packages/safe-bash-presentation-engine/src/retained-frame-formatting.ts
+async function readRetainedFrameFormatting(document, body) {
+  const malformed = () => {
+    throw new OfficeError("invalid-xml", "Invalid text frame properties.", "parse");
+  };
+  let properties;
+  for await (const node of document.children(body)) {
+    if (node.kind !== "element" || !await equal(document.raw(node.localName), literal("bodyPr"))) continue;
+    let drawing = false;
+    for (const dialect of dialects) if (await equal(document.namespace(node), literal(dialect.a))) drawing = true;
+    if (drawing) {
+      if (properties) malformed();
+      properties = node;
+    }
+  }
+  const attributes = {};
+  const enums = { wrap: ["square", "none"], anchor: ["t", "ctr", "b", "just", "dist"], vert: textVerticalModes };
+  const numbers = ["lIns", "rIns", "tIns", "bIns", "numCol", "rot"];
+  if (properties) for await (const attribute of document.attributes(properties)) {
+    if (!await equal(document.namespace(attribute), literal(""))) continue;
+    for (const key of [...numbers, ...Object.keys(enums)]) {
+      if (!await equal(document.raw(attribute.localName), literal(key))) continue;
+      if (enums[key]) {
+        let value;
+        for (const token of enums[key]) if (await equal(document.text(attribute), literal(token))) value = token;
+        if (value === void 0) malformed();
+        attributes[key] = value;
+      } else {
+        let phase = "leading", negative = false, digits = false, value = 0;
+        for await (const character of characters(document.text(attribute))) {
+          if (character.trim() === "") {
+            if (phase === "sign") malformed();
+            if (phase === "digits") phase = "trailing";
+          } else if (phase === "leading" && (character === "+" || character === "-")) {
+            negative = character === "-";
+            phase = "sign";
+          } else if (phase !== "trailing" && character >= "0" && character <= "9") {
+            phase = "digits";
+            digits = true;
+            value = value * 10 + Number(character);
+            if (!Number.isSafeInteger(value)) malformed();
+          } else malformed();
+        }
+        if (!digits) malformed();
+        attributes[key] = `${negative ? "-" : ""}${value}`;
+      }
+      break;
+    }
+  }
+  const fits = [];
+  if (properties) for await (const child of document.children(properties)) {
+    if (child.kind !== "element" || !await equal(document.namespace(child), document.namespace(properties))) continue;
+    for (const name of ["noAutofit", "normAutofit", "spAutoFit"]) if (await equal(document.raw(child.localName), literal(name))) {
+      if (fits.length) malformed();
+      fits.push(name);
+    }
+  }
+  return readFramePropertyValues((key) => attributes[key] ?? null, fits);
+}
+
+// packages/safe-bash-presentation-engine/src/retained-text.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+async function openRetainedText(archive, fingerprint, options, settings, readingMode = "text") {
+  validateTextReadingOptions(options);
+  const selection = options.select === void 0 ? void 0 : { ...options.select, ...options.select.position ? { position: { ...options.select.position } } : {} };
+  const scope = options.scope ?? "slides", shape = options.shape;
+  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);
+  const traversal = new PagedStorage({ fs: working.fs, cwd: working.directory, env: {}, signal }, (working.cacheBytes ?? 1024 * 1024) / 16384);
+  let closed = false, closing, firstBody = 0, lastBody = 0, firstOwner = 0, lastOwner = 0, fieldCount = 0, frameCount = 0;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Text is closed.", "select");
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "select");
+  };
+  const failure = (error) => error instanceof OfficeError ? error : new OfficeError(signal.aborted ? "cancelled" : "io-failure", "Text storage operation failed.", "select");
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const outcomes = await Promise.allSettled([index.close(), traversal.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, field) => ({ start: row2[field], length: row2[field + 1] });
+  async function row(pointer, count, storage = pages) {
+    check();
+    const bytes = await storage.read(pointer, count * 8), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return Array.from({ length: count }, (_, n) => view.getFloat64(n * 8, true));
+  }
+  async function write(pointer, numbers, storage = pages) {
+    check();
+    const bytes = new Uint8Array(numbers.length * 8), view = new DataView(bytes.buffer);
+    numbers.forEach((number, n) => view.setFloat64(n * 8, number, true));
+    await storage.write(pointer, bytes);
+  }
+  async function* rows(first, count) {
+    for (let pointer = first; pointer; ) {
+      const data = await row(pointer, count);
+      yield data;
+      pointer = data[0];
+    }
+    check();
+  }
+  async function name(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();
+  }
+  async function part(value) {
+    return await values.find("parts", () => folded(literal(value)));
+  }
+  const absent = /* @__PURE__ */ Symbol("absent-part");
+  async function owner(value) {
+    if (!value) return;
+    if (value === absent) throw new OfficeError("missing-binding", "Package member is absent.", "index");
+    const key = await values.store(literal(value));
+    if (!await values.insert("owners", key, key)) return;
+    const pointer = pages.allocate(24);
+    await write(pointer, [0, key.start, key.length]);
+    if (lastOwner) await write(lastOwner, [pointer]);
+    else firstOwner = pointer;
+    lastOwner = pointer;
+  }
+  async function target(owner2, type) {
+    if (owner2 === absent) return void 0;
+    let count = 0, found, missing = false;
+    for await (const edge of index.graph.outgoing(owner2)) for (const dialect of dialects) if (await equal(edge.type(), literal(`${dialect.r}/${type}`))) {
+      if (++count > 1) throw new OfficeError("invalid-opc", "Ambiguous text scope relationship.", "select");
+      if (edge.targetPart) {
+        found = await values.find("parts", () => folded(edge.targetPart()));
+        missing = !found;
+      }
+    }
+    return found ? name(found) : missing ? absent : void 0;
+  }
+  try {
+    for await (const entry of archive.parts()) {
+      const value = await values.store(literal(entry)), key = await values.store(folded(literal(entry)));
+      await values.insert("parts", key, value);
+    }
+    let selectedCount = 0, selectedSlides = false;
+    if (selection) for await (const item of index.records.select(selection)) {
+      selectedCount++;
+      if (item.kind === "slide") {
+        selectedSlides = true;
+        if (["notes-master", "handout-master"].includes(scope)) throw new SelectionError("invalid-selection");
+      } else if (item.scope !== scope) throw new SelectionError("invalid-selection");
+      const key = await values.store(literal(item.kind === "part" ? item.part : `${item.part}\0${item.id}`));
+      await values.insert("selected", key, key);
+    }
+    if (shape !== void 0 && selectedCount !== 1) throw new SelectionError("invalid-selection");
+    for await (const slide of selection ? index.records.select(selection) : index.records.records("slide")) if (slide.kind === "slide") {
+      const layout = await target(slide.part, "slideLayout");
+      await owner(scope === "slides" ? slide.part : scope === "notes" ? await target(slide.part, "notesSlide") : scope === "layouts" ? layout : scope === "masters" && layout ? await target(layout, "slideMaster") : void 0);
+    }
+    if (!selection && scope !== "slides" && scope !== "notes") {
+      for await (const item of index.records.records("part")) if (item.scope === scope) await owner(item.part);
+    }
+    if (selection) {
+      for await (const item of index.records.select(selection)) if (item.kind !== "slide") await owner(item.part);
+    }
+    let named, namedCount = 0;
+    const candidates = [];
+    for await (const object of index.records.records("object")) {
+      const ownerPart = await part(object.part), key = await values.store(literal(object.id));
+      await values.insert(`objects:${ownerPart.start}`, key, key);
+      if (shape !== void 0 && object.scope === scope && await values.find("owners", () => literal(object.part)) && await equal(object.name(), literal(shape))) {
+        named = object.location;
+        namedCount++;
+        if (candidates.length < 20) candidates.push(object.location);
+      }
+    }
+    if (shape !== void 0 && namedCount !== 1) throw new SelectionError(namedCount ? "ambiguous-selection" : "missing-selection", candidates);
+    for await (const ownerRow of rows(firstOwner, 3)) {
+      const ownerName = await name(range(ownerRow, 1)), ownerPart = await part(ownerName);
+      const document = await openRetainedXmlDocument(archive.read(ownerName), { ...context, workingStorage: working });
+      let view, failed = false;
+      try {
+        async function is(node, local, namespaces = dialects.map((d) => d.p)) {
+          if (node.kind !== "element" && node.kind !== "attribute" || !await equal(document.raw(node.localName), literal(local))) return false;
+          for (const uri of namespaces) if (await equal(document.namespace(node), literal(uri))) return true;
+          return false;
+        }
+        const drawing = dialects.map((d) => d.a);
+        async function attribute(node, local) {
+          for await (const attr of document.attributes(node)) if (await is(attr, local, [""])) return attr;
+          return void 0;
+        }
+        async function tableData(node) {
+          if (!await is(node, "graphicData", drawing)) return false;
+          const uri = await attribute(node, "uri");
+          if (uri) {
+            for (const ns of drawing) if (await equal(document.text(uri), literal(`${ns}/table`))) return true;
+          }
+          for await (const child of document.children(node)) if (await is(child, "tbl", drawing)) return true;
+          return false;
+        }
+        view = await openRetainedCompatibility(document, dialects.flatMap((d) => [d.p, d.a, d.r]), { ...context, workingStorage: working }, [
+          ...equationOpaqueElements,
+          ...dialects.flatMap((d) => [{ namespace: d.p, localName: "ext" }, { namespace: d.a, localName: "ext" }, { namespace: d.a, localName: "graphicData" }])
+        ], tableData);
+        async function* children(node, local, namespaces = dialects.map((d) => d.p)) {
+          for await (const child of view.children(node)) if (await is(child, local, namespaces)) yield child;
+        }
+        async function push(source, inherited, previous) {
+          let first = 0, last = 0;
+          for await (const node of source) {
+            const pointer = traversal.allocate(24);
+            await write(pointer, [0, document.reference(node), inherited], traversal);
+            if (last) await write(last, [pointer], traversal);
+            else first = pointer;
+            last = pointer;
+          }
+          if (last) await write(last, [previous], traversal);
+          return first || previous;
+        }
+        async function* rawCharacters(node) {
+          let top = await push(document.children(node), 0, 0);
+          while (top) {
+            const entry = await row(top, 3, traversal);
+            top = entry[0];
+            const child = await document.node(entry[1]);
+            if (child.kind === "text" || child.kind === "cdata") yield* document.text(child);
+            else if (child.kind === "element") top = await push(document.children(child), 0, top);
+          }
+        }
+        async function body(node, id, cellRow = -1, cellColumn = -1) {
+          if (readingMode === "frames" && cellRow >= 0) return;
+          const formatting = readingMode === "frames" ? await values.store(literal(JSON.stringify(await readRetainedFrameFormatting(document, node), (_key, value) => Object.is(value, -0) ? "-0" : value))) : { start: 0, length: 0 };
+          if (readingMode === "frames") frameCount++;
+          const bodyPointer = pages.allocate(10 /* Count */ * 8), bodyRow = [0, ownerPart.start, ownerPart.length, id, 0, 0, cellRow, cellColumn, formatting.start, formatting.length];
+          let paragraphIndex = 0;
+          for await (const paragraph of children(node, "p", drawing)) {
+            if (readingMode === "frames") break;
+            const paragraphPointer = pages.allocate(4 /* Count */ * 8), paragraphRow = [0, 0, 0, paragraphIndex++];
+            let fieldInline = 0;
+            for await (const inline of view.children(paragraph)) {
+              const kind = await is(inline, "br", drawing) ? 1 : await is(inline, "r", drawing) ? 0 : await is(inline, "fld", drawing) ? 2 : -1;
+              if (kind < 0) continue;
+              async function* text() {
+                if (kind === 1) yield* literal("\v");
+                else for await (const node2 of children(inline, "t", drawing)) yield* rawCharacters(node2);
+              }
+              const value = await values.store(text()), fieldId = kind === 2 ? await attribute(inline, "id") : void 0, fieldType = kind === 2 ? await attribute(inline, "type") : void 0;
+              const identifier = fieldId ? await values.store(document.text(fieldId)) : { start: -1, length: 0 }, type = fieldType ? await values.store(document.text(fieldType)) : { start: -1, length: 0 };
+              const matchingNamespace = await equal(document.namespace(inline), document.namespace(paragraph));
+              const fieldIndex = matchingNamespace ? fieldInline++ : -1;
+              async function* fieldText() {
+                for await (const node2 of document.children(inline)) if (await is(node2, "t", drawing) && await equal(document.namespace(node2), document.namespace(inline))) yield* rawCharacters(node2);
+              }
+              const cached = kind === 2 && fieldIndex >= 0 ? await values.store(fieldText()) : { start: 0, length: 0 };
+              if (kind === 2 && fieldIndex >= 0) fieldCount++;
+              const pointer = pages.allocate(11 /* Count */ * 8);
+              await write(pointer, [0, kind, value.start, value.length, identifier.start, identifier.length, type.start, type.length, fieldIndex, cached.start, cached.length]);
+              if (paragraphRow[2 /* LastInline */]) await write(paragraphRow[2 /* LastInline */], [pointer]);
+              else paragraphRow[1 /* Inlines */] = pointer;
+              paragraphRow[2 /* LastInline */] = pointer;
+            }
+            await write(paragraphPointer, paragraphRow);
+            if (bodyRow[5 /* LastParagraph */]) await write(bodyRow[5 /* LastParagraph */], [paragraphPointer]);
+            else bodyRow[4 /* Paragraphs */] = paragraphPointer;
+            bodyRow[5 /* LastParagraph */] = paragraphPointer;
+          }
+          await write(bodyPointer, bodyRow);
+          if (lastBody) await write(lastBody, [bodyPointer]);
+          else firstBody = bodyPointer;
+          lastBody = bodyPointer;
+        }
+        for await (const common of children(document.root, "cSld")) for await (const tree of children(common, "spTree")) {
+          let top = await push(view.children(tree), 0, 0);
+          while (top) {
+            const entry = await row(top, 3, traversal);
+            top = entry[0];
+            const node = await document.node(entry[1]);
+            let shapeNode = false;
+            for (const local of ["sp", "cxnSp", "graphicFrame", "grpSp", "pic"]) if (await is(node, local)) shapeNode = true;
+            if (!shapeNode) continue;
+            let identity;
+            for await (const nv of view.children(node)) {
+              let nonVisual = false;
+              for (const local of ["nvSpPr", "nvCxnSpPr", "nvGraphicFramePr", "nvGrpSpPr", "nvPicPr"]) if (await is(nv, local)) nonVisual = true;
+              if (nonVisual) {
+                for await (const child of children(nv, "cNvPr")) {
+                  identity = await attribute(child, "id");
+                  break;
+                }
+                break;
+              }
+            }
+            let id = 0;
+            if (identity) for await (const character of characters(document.text(identity))) {
+              if (character >= "0" && character <= "9") id = id * 10 + Number(character);
+            }
+            if (!identity || !await values.find(`objects:${ownerPart.start}`, () => literal(String(id)))) throw new OfficeError("invalid-opc", "Missing text object identity.", "select");
+            const included = Boolean(entry[2]) || (named ? named.owner === ownerName && named.objectId === String(id) : !selection || selectedSlides || Boolean(await values.find("selected", () => literal(ownerName))) || Boolean(await values.find("selected", () => literal(`${ownerName}\0${id}`))));
+            if (await is(node, "grpSp")) {
+              top = await push(view.children(node), Number(included), top);
+              continue;
+            }
+            if (!included) continue;
+            for await (const textBody of children(node, "txBody")) await body(textBody, id);
+            for await (const graphic of children(node, "graphic", drawing)) for await (const data of children(graphic, "graphicData", drawing)) if (await tableData(data)) {
+              for await (const table of children(data, "tbl", drawing)) {
+                let rowIndex = 0;
+                for await (const rowNode of children(table, "tr", drawing)) {
+                  let column = 0;
+                  for await (const cell of children(rowNode, "tc", drawing)) {
+                    for await (const textBody of children(cell, "txBody", drawing)) await body(textBody, id, rowIndex, column);
+                    column++;
+                  }
+                  rowIndex++;
+                }
+              }
+            }
+          }
+        }
+      } catch (error) {
+        failed = true;
+        throw error;
+      } finally {
+        const outcomes = await Promise.allSettled([view?.close(), document.close()]);
+        if (!failed) {
+          for (const outcome of outcomes) if (outcome.status === "rejected") await Promise.reject(outcome.reason);
+        }
+      }
+    }
+    await index.close();
+    await traversal.close();
+    check();
+    async function* inlineText(first) {
+      for await (const inline of rows(first, 11 /* Count */)) yield* values.read(range(inline, 2 /* Text */));
+    }
+    async function* bodyText(first) {
+      let separator = false;
+      for await (const paragraph of rows(first, 4 /* Count */)) {
+        if (separator) yield* literal("\n");
+        separator = true;
+        yield* inlineText(paragraph[1 /* Inlines */]);
+      }
+    }
+    async function* inlines(first) {
+      for await (const inline of rows(first, 11 /* Count */)) {
+        if (inline[1 /* Kind */] === 1) yield { kind: "break", text: "\v" };
+        else if (inline[1 /* Kind */] === 0) yield { kind: "run", text: () => values.read(range(inline, 2 /* Text */)) };
+        else yield { kind: "field", cachedText: () => values.read(range(inline, 2 /* Text */)), fieldId: inline[4 /* FieldId */] === -1 ? null : () => values.read(range(inline, 4 /* FieldId */)), fieldType: inline[6 /* FieldType */] === -1 ? null : () => values.read(range(inline, 6 /* FieldType */)) };
+      }
+    }
+    async function* paragraphs(first) {
+      for await (const paragraph of rows(first, 4 /* Count */)) yield { index: paragraph[3 /* Index */], coordinateSystem: "zero-based", text: () => inlineText(paragraph[1 /* Inlines */]), inlines: inlines(paragraph[1 /* Inlines */]) };
+    }
+    async function* segments() {
+      try {
+        for await (const body of rows(firstBody, 10 /* Count */)) yield { location: { fingerprint, scope, owner: await name(range(body, 1 /* Owner */)), objectId: String(body[3 /* Id */]), coordinateSystem: "identity" }, text: () => bodyText(body[4 /* Paragraphs */]), paragraphs: paragraphs(body[4 /* Paragraphs */]), ...body[6 /* Row */] < 0 ? {} : { cell: { coordinateSystem: "zero-based", row: body[6 /* Row */], column: body[7 /* Column */] } } };
+      } catch (error) {
+        throw failure(error);
+      }
+    }
+    async function* frames() {
+      try {
+        for await (const body of rows(firstBody, 10 /* Count */)) if (body[8 /* Format */]) yield {
+          location: { fingerprint, scope, owner: await name(range(body, 1 /* Owner */)), objectId: String(body[3 /* Id */]), coordinateSystem: "identity" },
+          // Fixed-schema scalars; the numeric -0 marker cannot collide with valid enums.
+          formatting: JSON.parse(await name(range(body, 8 /* Format */)), (_key, value) => value === "-0" ? -0 : value)
+        };
+      } catch (error) {
+        throw failure(error);
+      }
+    }
+    async function* fields() {
+      try {
+        for await (const body of rows(firstBody, 10 /* Count */)) {
+          const location = { fingerprint, scope, owner: await name(range(body, 1 /* Owner */)), objectId: String(body[3 /* Id */]), coordinateSystem: "identity" };
+          for await (const paragraph of rows(body[4 /* Paragraphs */], 4 /* Count */)) for await (const inline of rows(paragraph[1 /* Inlines */], 11 /* Count */)) if (inline[1 /* Kind */] === 2 && inline[8 /* FieldIndex */] >= 0) {
+            const fieldType = inline[6 /* FieldType */] === -1 ? null : () => values.read(range(inline, 6 /* FieldType */));
+            let kind = null;
+            if (fieldType) {
+              for (const [type, candidate] of Object.entries(fieldTypeKinds)) if (await equal(fieldType(), literal(type))) {
+                kind = candidate;
+                break;
+              }
+            }
+            yield {
+              location,
+              paragraph: paragraph[3 /* Index */],
+              inline: inline[8 /* FieldIndex */],
+              coordinateSystem: "zero-based",
+              kind,
+              fieldId: inline[4 /* FieldId */] === -1 ? null : () => values.read(range(inline, 4 /* FieldId */)),
+              fieldType,
+              cachedText: () => values.read(range(inline, 9 /* FieldText */))
+            };
+          }
+        }
+      } catch (error) {
+        throw failure(error);
+      }
+    }
+    return Object.freeze({ close, segments, fields, fieldCount, frames, frameCount, async *text() {
+      let separator = false;
+      for await (const segment of segments()) {
+        if (separator) yield* literal("\n");
+        separator = true;
+        yield* segment.text();
+      }
+    } });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw failure(error);
+  }
+}
+async function stageRetainedText(archive, fingerprint, options, settings, output) {
+  const format = { ...output }, operation = format.operation ?? "text.get";
+  if (!["text.get", "fields.list", "fields.get", "text.frames.list", "text.frames.get"].includes(operation)) throw new OfficeError("invalid-value", "Invalid retained text operation.", "usage");
+  const frames = operation.startsWith("text.frames."), fields = operation.startsWith("fields.");
+  const text = await openRetainedText(archive, fingerprint, options, settings, frames ? "frames" : "text").catch((error) => {
+    if (frames && error instanceof SelectionError && error.code === "missing-selection") return void 0;
+    throw error;
+  });
+  async function* frameRecords() {
+    if (text) yield* text.frames();
+  }
+  let staged;
+  async function* locations() {
+    for await (const item of frames ? frameRecords() : fields ? text.fields() : text.segments()) yield item.location;
+  }
+  async function* items() {
+    for await (const field of text.fields()) yield {
+      location: field.location,
+      kind: field.kind ?? "unknown",
+      name: field.fieldId,
+      fields: [
+        { name: "fieldType", value: field.fieldType === null ? { type: "null", value: null } : { type: "string", value: field.fieldType } },
+        { name: "cachedText", value: { type: "string", value: field.cachedText } },
+        { name: "paragraph", value: { type: "number", value: field.paragraph } },
+        { name: "inline", value: { type: "number", value: field.inline } },
+        { name: "coordinateSystem", value: { type: "string", value: "zero-based" } }
+      ]
+    };
+  }
+  async function* render() {
+    if (format.json) {
+      yield* streamJson({ version: 1, operation, ok: true, data: frames ? { frames: frameRecords() } : fields ? { items: items() } : { text: text.text, order: "structural", segments: text.segments() }, warnings: [], errors: [], affected: 0, locations: locations() });
+      yield* literal("\n");
+    } else if (frames) yield* streamJson(frameRecords());
+    else if (fields) yield* streamJson(text.fields());
+    else yield* text.text();
+  }
+  try {
+    if (operation === "fields.get" && text.fieldCount !== 1) throw new SelectionError(text.fieldCount ? "ambiguous-selection" : "missing-selection");
+    if (operation === "text.frames.get" && text?.frameCount !== 1) throw new SelectionError(text?.frameCount ? "ambiguous-selection" : "missing-selection");
+    staged = await stageRetainedOutput(render(), settings, format.maxOutputBytes);
+    await text?.close();
+    return staged;
+  } catch (error) {
+    await Promise.allSettled([text?.close(), staged?.close()]);
+    throw error;
+  }
+}
+
+export {
+  openRetainedText,
+  stageRetainedText
+};

package/dist/safe-bash/command-chunks/{chunk-KCLJGRU7.js → chunk-VZTVR3JI.js}

@@ -1,40 +1,40 @@
 import {
   openPackageArchive
-} from "./chunk-3ZRCL756.js";
+} from "./chunk-FJLSYX5P.js";
 import {
   boundedOutput,
   openRetainedPresentationIndex,
   rawJson,
   streamJson
-} from "./chunk-4EHY6J2Z.js";
+} from "./chunk-FB2WPI3M.js";
 import {
   RetainedOrder
-} from "./chunk-NQINS4XY.js";
+} from "./chunk-XVEI4HZL.js";
 import {
   loadShared
-} from "./chunk-ADHFF2IM.js";
+} from "./chunk-A5SPMSKD.js";
 import {
   writePackageArchive
-} from "./chunk-KBAQHE5Y.js";
+} from "./chunk-TG2RVQLP.js";
 import {
   readBinary
-} from "./chunk-NFII726L.js";
+} from "./chunk-FAU2KL6I.js";
 import {
   openRetainedPresentationValidation
-} from "./chunk-3GRMU7TM.js";
+} from "./chunk-6W4RMBFH.js";
 import {
   openRetainedContentTypes
-} from "./chunk-AWPI4DZR.js";
+} from "./chunk-6KJDTKE4.js";
 import {
   parseContentTypes
-} from "./chunk-ZQM37BGE.js";
+} from "./chunk-XFIDOCYH.js";
 import {
   asciiKey,
   partName
-} from "./chunk-WTVJLHMG.js";
+} from "./chunk-MOUCMZZP.js";
 import {
   PackageNotFoundError
-} from "./chunk-JUHOL5KB.js";
+} from "./chunk-G3FK5VVG.js";
 import {
   OfficeError,
   RetainedValues,
@@ -45,7 +45,7 @@ import {
   literal,
   openRetainedXmlDocument,
   resolveOfficeResources
-} from "./chunk-CXME4YHU.js";
+} from "./chunk-KM2SMMXZ.js";
 import {
   createZipCodec
 } from "./chunk-IOEUZ4EA.js";

package/dist/safe-bash/command-chunks/{chunk-PLR5IULU.js → chunk-WDVPHDBH.js}

@@ -12,19 +12,19 @@ import {
   relPart,
   required,
   unique
-} from "./chunk-ADHFF2IM.js";
+} from "./chunk-A5SPMSKD.js";
 import {
   SelectionError
-} from "./chunk-W3ZSWK76.js";
+} from "./chunk-NCNHJRIY.js";
 import {
   parseXmlPart
-} from "./chunk-DBLQUZGN.js";
+} from "./chunk-7PYDVQPB.js";
 import {
   relativePartReference
-} from "./chunk-WTVJLHMG.js";
+} from "./chunk-MOUCMZZP.js";
 import {
   OfficeError
-} from "./chunk-CXME4YHU.js";
+} from "./chunk-KM2SMMXZ.js";
 
 // packages/safe-bash-presentation-engine/src/layouts.ts
 var relationships = "http://schemas.openxmlformats.org/package/2006/relationships";

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

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

package/dist/safe-bash/command-chunks/{chunk-TJLXSENN.js → chunk-WHZ6XK7Y.js}

@@ -1,7 +1,7 @@
 import {
   InvalidXmlError,
   TypeError
-} from "./chunk-JUHOL5KB.js";
+} from "./chunk-G3FK5VVG.js";
 
 // packages/safe-bash-presentation-engine/src/xml-scalars.ts
 function numericToken(value) {

package/dist/safe-bash/command-chunks/{chunk-DN6MSXY7.js → chunk-WIW3KDBS.js}

@@ -1,10 +1,10 @@
 import {
   resolveDocumentModelContext
-} from "./chunk-IBYMPAUW.js";
+} from "./chunk-XPQUUFQD.js";
 import {
   Image,
   acquireImageModelInput
-} from "./chunk-ZXELXF2H.js";
+} from "./chunk-IZ3SD5S2.js";
 import {
   DocxUsageError
 } from "./chunk-WXMYTNWS.js";