@poe-platform/safe-bash 0.1.816 → 0.1.818

package/dist/safe-bash/command-chunks/{chunk-VVWHFNHD.js → chunk-WPEIOUJN.js}

@@ -1,21 +1,29 @@
 import {
   fieldTypeKinds
-} from "./chunk-YXR4JE4U.js";
+} from "./chunk-Z33YS3DW.js";
 import {
-  openRetainedPresentationIndex,
-  stageRetainedOutput,
-  streamJson
-} from "./chunk-FB2WPI3M.js";
+  readRetainedPropertyValue
+} from "./chunk-MTWFSBNG.js";
 import {
+  paragraphAlignments,
   readFramePropertyValues,
   textVerticalModes
-} from "./chunk-3K5CVXUV.js";
+} from "./chunk-NZF56C25.js";
+import {
+  validateTextRunOptions
+} from "./chunk-424NYO35.js";
 import {
   validateTextReadingOptions
-} from "./chunk-YKODRSGT.js";
+} from "./chunk-WRCYZJNO.js";
+import {
+  openRetainedPresentationIndex,
+  rawJson,
+  stageRetainedOutput,
+  streamJson
+} from "./chunk-3ZGO24WG.js";
 import {
   SelectionError
-} from "./chunk-NCNHJRIY.js";
+} from "./chunk-3W3HLPCX.js";
 import {
   dialects,
   openRetainedCompatibility
@@ -23,6 +31,9 @@ import {
 import {
   equationOpaqueElements
 } from "./chunk-GTOMW4VV.js";
+import {
+  InvalidXmlError
+} from "./chunk-G3FK5VVG.js";
 import {
   OfficeError,
   RetainedValues,
@@ -34,6 +45,301 @@ import {
   resolveOfficeResources
 } from "./chunk-KM2SMMXZ.js";
 
+// packages/safe-bash-presentation-engine/src/retained-paragraph-formatting.ts
+async function readRetainedParagraphFormatting(document, paragraph) {
+  async function local(node, keys) {
+    for (const key of keys) if (await equal(document.raw(node.localName), literal(key))) return key;
+    return void 0;
+  }
+  async function* children(parent, keys) {
+    if (parent) {
+      for await (const node of document.children(parent)) if (node.kind === "element" && await equal(document.namespace(node), document.namespace(parent)) && await local(node, keys)) yield node;
+    }
+  }
+  async function first(parent, keys) {
+    for await (const node of children(parent, keys)) return node;
+    return void 0;
+  }
+  async function attr(parent, key) {
+    if (parent) {
+      for await (const node of document.attributes(parent)) if (await equal(document.namespace(node), literal("")) && await local(node, [key])) return () => document.text(node);
+    }
+    return null;
+  }
+  let properties;
+  for await (const node of children(paragraph, ["pPr"])) {
+    if (properties) throw new OfficeError("invalid-xml", "Ambiguous paragraph properties.", "parse");
+    properties = node;
+  }
+  async function numeric(source, scale) {
+    if (!source) return null;
+    const value = await readRetainedPropertyValue("number", source(), () => {
+    });
+    if (typeof value !== "number") throw new OfficeError("invalid-xml", "Invalid paragraph number.", "parse");
+    return value / scale;
+  }
+  async function spacing(key) {
+    const parent = await first(properties, [key]), node = await first(parent, ["spcPts", "spcPct"]);
+    if (!node) return null;
+    const source = await attr(node, "val");
+    if (!source) return null;
+    if (await local(node, ["spcPts"])) return { unit: "pt", value: await numeric(source, 100) };
+    let last = -1;
+    for await (const bytes of source()) if (bytes.length) last = bytes[bytes.length - 1];
+    async function* withoutPercent() {
+      let pending;
+      for await (const bytes of source()) if (bytes.length) {
+        if (pending) yield pending;
+        pending = new Uint8Array(bytes);
+      }
+      if (pending) yield pending.subarray(0, pending.length - 1);
+    }
+    return { unit: "multiple", value: await numeric(last === 37 ? withoutPercent : source, last === 37 ? 100 : 1e5) };
+  }
+  const bulletNode = await first(properties, ["buNone", "buChar", "buAutoNum", "buBlip"]);
+  async function bullet() {
+    if (!bulletNode) return null;
+    const kind = await local(bulletNode, ["buNone", "buChar", "buAutoNum", "buBlip"]);
+    if (kind === "buNone") return { kind: "none" };
+    if (kind === "buChar") return { kind: "character", character: await attr(bulletNode, "char") };
+    if (kind !== "buAutoNum") return { kind: "picture" };
+    const start = await attr(bulletNode, "startAt");
+    let startAt = null;
+    if (start) {
+      let whitespace = true;
+      for await (const character of characters(start())) if (character.trim() !== "") {
+        whitespace = false;
+        break;
+      }
+      startAt = whitespace ? 0 : await readRetainedPropertyValue("number", start(), () => {
+      });
+    }
+    return { kind: "numbered", scheme: await attr(bulletNode, "type"), ...start ? { startAt } : {} };
+  }
+  const bulletValue = await bullet(), before = await spacing("spcBef"), after = await spacing("spcAft");
+  const align = await attr(properties, "algn"), rtl = await attr(properties, "rtl");
+  let direction = null;
+  if (rtl) {
+    let valid = false;
+    for (const value of ["0", "1", "false", "true"]) if (await equal(rtl(), literal(value))) {
+      direction = value === "1" || value === "true";
+      valid = true;
+      break;
+    }
+    if (!valid) throw new OfficeError("invalid-xml", "Invalid paragraph direction.", "parse");
+  }
+  let alignment = align;
+  if (align) {
+    for (const [index, key] of ["l", "ctr", "r", "just", "dist", "thaiDist", "justLow"].entries()) if (await equal(align(), literal(key))) {
+      alignment = paragraphAlignments[index];
+      break;
+    }
+  }
+  const marginLeft = await numeric(await attr(properties, "marL"), 12700), marginRight = await numeric(await attr(properties, "marR"), 12700), indent = await numeric(await attr(properties, "indent"), 12700), defaultTabSize = await numeric(await attr(properties, "defTabSz"), 12700), level = await numeric(await attr(properties, "lvl"), 1), lineSpacing = await spacing("lnSpc");
+  const tabList = await first(properties, ["tabLst"]);
+  async function* tabs() {
+    for await (const node of children(tabList, ["tab"])) {
+      const position = await numeric(await attr(node, "pos"), 12700), source = await attr(node, "algn");
+      let alignment2 = source ?? "left";
+      const mappings = { l: "left", ctr: "center", r: "right", dec: "decimal" };
+      if (source) {
+        for (const key of [...Object.keys(mappings), ...Object.getOwnPropertyNames(Object.prototype)]) if (await equal(source(), literal(key))) {
+          const value = mappings[key];
+          alignment2 = typeof value === "function" ? void 0 : value;
+          break;
+        }
+      }
+      yield { position, alignment: alignment2 };
+    }
+  }
+  return { alignment, marginLeft, marginRight, indent, defaultTabSize, level, rtl: direction, lineSpacing, spaceBefore: before?.unit === "pt" ? before.value : null, spaceAfter: after?.unit === "pt" ? after.value : null, bullet: bulletValue, tabs: tabList ? tabs() : null };
+}
+
+// packages/safe-bash-presentation-engine/src/retained-run-formatting.ts
+async function readRetainedRunFormatting(document, run) {
+  const fail = (message) => {
+    throw new OfficeError("invalid-xml", message, "parse");
+  };
+  async function* children(parent, local) {
+    if (parent) {
+      for await (const node of document.children(parent)) if (node.kind === "element" && await equal(document.namespace(node), document.namespace(parent)) && await equal(document.raw(node.localName), literal(local))) yield node;
+    }
+  }
+  async function first(parent, local) {
+    for await (const node of children(parent, local)) return node;
+    return void 0;
+  }
+  async function attribute(parent, local) {
+    if (parent) {
+      for await (const node of document.attributes(parent)) if (await equal(document.namespace(node), literal("")) && await equal(document.raw(node.localName), literal(local))) return () => document.text(node);
+    }
+    return null;
+  }
+  async function token(source, tokens) {
+    if (source) {
+      for (const value of tokens) if (await equal(source(), literal(value))) return value;
+    }
+    return void 0;
+  }
+  let properties;
+  for await (const node of children(run, "rPr")) {
+    if (properties) fail("Ambiguous run properties.");
+    properties = node;
+  }
+  const attr = (key) => attribute(properties, key);
+  const child = (key) => first(properties, key);
+  async function boolean(key) {
+    const source = await attr(key);
+    if (!source) return null;
+    const value = await token(source, ["0", "1", "false", "true"]);
+    if (value === void 0) fail("Invalid run boolean.");
+    return value === "1" || value === "true";
+  }
+  async function numeric(key, scale) {
+    const source = await attr(key);
+    if (!source) return null;
+    let nonempty = false, whitespace = true;
+    for await (const character of characters(source())) {
+      nonempty = true;
+      if (character.trim() !== "") {
+        whitespace = false;
+        break;
+      }
+    }
+    const value = nonempty && whitespace ? 0 : await readRetainedPropertyValue("number", source(), () => {
+    });
+    if (typeof value !== "number") return fail("Invalid run number.");
+    return value / scale;
+  }
+  const cs = await child("cs");
+  async function fontNumber(key) {
+    const source = await attribute(cs, key);
+    if (!source) return null;
+    let phase = "leading", digits = false;
+    for await (const character of characters(source())) {
+      if (character.trim() === "") {
+        if (phase === "sign") fail("Invalid complex-script font classification.");
+        if (phase === "digits") phase = "trailing";
+      } else if (phase === "leading" && (character === "+" || character === "-")) phase = "sign";
+      else if (phase !== "trailing" && character >= "0" && character <= "9") {
+        digits = true;
+        phase = "digits";
+      } else fail("Invalid complex-script font classification.");
+    }
+    const value = await readRetainedPropertyValue("number", source(), () => {
+    });
+    if (!digits || typeof value !== "number" || !Number.isInteger(value)) return fail("Invalid complex-script font classification.");
+    return value;
+  }
+  const charset = await fontNumber("charset"), pitch = await fontNumber("pitchFamily"), panoseSource = await attribute(cs, "panose");
+  let panose = null;
+  if (panoseSource) {
+    panose = "";
+    let trailing = false;
+    for await (const character of characters(panoseSource())) {
+      if (character.trim() === "") {
+        if (panose) trailing = true;
+        continue;
+      }
+      if (trailing || panose.length >= 20) fail("Invalid complex-script font classification.");
+      panose += character.toUpperCase();
+    }
+  }
+  const classification = { complexScriptCharset: charset, complexScriptPitchFamily: pitch, complexScriptPanose: panose };
+  try {
+    validateTextRunOptions(classification);
+  } catch {
+    fail("Invalid complex-script font classification.");
+  }
+  const rtl = await child("rtl"), rtlSource = await attribute(rtl, "val");
+  const transitional = await equal(document.namespace(run), literal("http://schemas.openxmlformats.org/drawingml/2006/main"));
+  const direction = await token(rtlSource, transitional ? ["0", "1", "false", "true", "on", "off"] : ["0", "1", "false", "true"]);
+  if (rtlSource && direction === void 0) fail("Invalid run direction.");
+  async function strike() {
+    const source = await attr("strike");
+    const mappings = { noStrike: "none", sngStrike: "single", dblStrike: "double" };
+    const key = await token(source, [...Object.keys(mappings), ...Object.getOwnPropertyNames(Object.prototype)]);
+    if (key === void 0) return source;
+    const value = mappings[key];
+    return typeof value === "function" ? void 0 : value;
+  }
+  async function percentage(source) {
+    if (!source) throw new InvalidXmlError("Missing percentage value.");
+    let phase = "leading", digits = 0, dot = false, percent = false, invalid = false, count = 0;
+    async function* numericSource() {
+      for await (const character of characters(source())) {
+        if (" 	\r\n".includes(character)) {
+          if (phase === "body") phase = "trailing";
+          continue;
+        }
+        if (phase === "trailing" || percent) invalid = true;
+        phase = "body";
+        if (character === "%") {
+          percent = true;
+          continue;
+        }
+        if (count++ === 0 && (character === "+" || character === "-")) {
+          yield* literal(character);
+          continue;
+        }
+        if (character === "." && !dot) dot = true;
+        else if (character >= "0" && character <= "9") digits++;
+        else invalid = true;
+        yield* literal(character);
+      }
+    }
+    const value = await readRetainedPropertyValue("number", numericSource(), () => {
+    });
+    if (invalid || !digits || !percent && dot || typeof value !== "number") throw new InvalidXmlError("Invalid numeric XML token.");
+    if (!percent && !Number.isSafeInteger(value)) throw new InvalidXmlError("XML integer exceeds the safe range.");
+    return value / (percent ? 100 : 1e5);
+  }
+  async function color(parent) {
+    if (!parent) return null;
+    const kinds = { hslClr: "HSL", prstClr: "PRESET", schemeClr: "SCHEME", scrgbClr: "SCRGB", srgbClr: "RGB", sysClr: "SYSTEM" };
+    let node, kind;
+    for await (const candidate of document.children(parent)) {
+      if (candidate.kind !== "element" || !await equal(document.namespace(candidate), document.namespace(parent))) continue;
+      for (const key of Object.keys(kinds)) if (await equal(document.raw(candidate.localName), literal(key))) {
+        if (node) throw new OfficeError("invalid-xml", "Multiple color choices.", "index");
+        node = candidate;
+        kind = key;
+      }
+    }
+    if (!node || !kind) return null;
+    async function transform(local) {
+      let found;
+      for await (const value of children(node, local)) {
+        if (found) throw new OfficeError("invalid-xml", "Multiple brightness transforms.", "index");
+        found = value;
+      }
+      return found ? percentage(await attribute(found, "val")) : void 0;
+    }
+    const off = await transform("lumOff"), mod = await transform("lumMod");
+    return { type: kinds[kind], rgb: kind === "srgbClr" ? await attribute(node, "val") : null, theme: kind === "schemeClr" ? await attribute(node, "val") : null, brightness: off ?? (mod === void 0 ? 0 : mod - 1) };
+  }
+  return {
+    eastAsiaFont: await attribute(await child("ea"), "typeface"),
+    complexScriptFont: await attribute(cs, "typeface"),
+    symbolFont: await attribute(await child("sym"), "typeface"),
+    ...classification,
+    alternateLanguage: await attr("altLang"),
+    rtl: rtl ? ["1", "true", "on"].includes(direction ?? "0") : null,
+    font: await attribute(await child("latin"), "typeface"),
+    size: await numeric("sz", 100),
+    language: await attr("lang"),
+    bold: await boolean("b"),
+    italic: await boolean("i"),
+    underline: await attr("u"),
+    strike: await strike(),
+    baseline: await numeric("baseline", 1e3),
+    capitalization: await attr("cap"),
+    spacing: await numeric("spc", 100),
+    color: await color(await child("solidFill")),
+    highlight: await color(await child("highlight"))
+  };
+}
+
 // packages/safe-bash-presentation-engine/src/retained-frame-formatting.ts
 async function readRetainedFrameFormatting(document, body) {
   const malformed = () => {
@@ -97,14 +403,22 @@ async function readRetainedFrameFormatting(document, body) {
 // 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);
+  if (readingMode !== "runs" && readingMode !== "paragraphs") validateTextReadingOptions(options);
+  const { paragraph: selectedParagraph, ...paragraphReading } = options;
+  const { run: selectedRun, ...readingOptions } = paragraphReading;
+  if (readingMode === "runs") {
+    for (const value of [selectedParagraph, selectedRun]) if (value !== void 0 && (!Number.isSafeInteger(value) || value < 0)) throw new OfficeError("invalid-value", "Invalid run formatting options.", "usage");
+  }
+  if (readingMode === "paragraphs" && selectedParagraph !== void 0 && (!Number.isSafeInteger(selectedParagraph) || selectedParagraph < 0)) throw new OfficeError("invalid-value", "Invalid paragraph formatting options.", "usage");
+  if (readingMode === "runs" || readingMode === "paragraphs") validateTextReadingOptions(readingMode === "runs" ? readingOptions : paragraphReading);
   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;
+  let closed = false, closing, firstBody = 0, lastBody = 0, firstOwner = 0, lastOwner = 0, fieldCount = 0, frameCount = 0, runCount = 0, paragraphCount = 0;
+  let formattingError;
   const check = () => {
     if (closed) throw new OfficeError("invalid-handle", "Text is closed.", "select");
     if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "select");
@@ -270,10 +584,50 @@ async function openRetainedText(archive, fingerprint, options, settings, reading
           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;
+            const paragraphPointer = pages.allocate(6 /* Count */ * 8), paragraphRow = [0, 0, 0, paragraphIndex++, 0, 0];
+            let fieldInline = 0, runIndex = 0;
+            if (readingMode === "paragraphs" && (selectedParagraph === void 0 || selectedParagraph === paragraphRow[3 /* Index */]) && !formattingError) {
+              try {
+                const formatted = await readRetainedParagraphFormatting(document, paragraph), format = await values.store(streamJson(formatted));
+                paragraphRow[4 /* Format */] = format.start;
+                paragraphRow[5 /* FormatLength */] = format.length;
+                paragraphCount++;
+              } catch (error) {
+                if (error instanceof OfficeError && error.code === "invalid-xml") formattingError = error;
+                else throw error;
+              }
+            }
             for await (const inline of view.children(paragraph)) {
+              if (readingMode === "paragraphs") continue;
               const kind = await is(inline, "br", drawing) ? 1 : await is(inline, "r", drawing) ? 0 : await is(inline, "fld", drawing) ? 2 : -1;
+              if (readingMode === "runs") {
+                let runNode = false;
+                for (const local of ["r", "fld", "br"]) if (inline.kind === "element" && await equal(document.raw(inline.localName), literal(local))) runNode = true;
+                if (!runNode) continue;
+                const position = runIndex++;
+                if (selectedParagraph !== void 0 && selectedParagraph !== paragraphRow[3 /* Index */] || selectedRun !== void 0 && selectedRun !== position || formattingError) continue;
+                let formatted;
+                try {
+                  formatted = await readRetainedRunFormatting(document, inline);
+                } catch (error) {
+                  if (error instanceof OfficeError && error.code === "invalid-xml") {
+                    formattingError = error;
+                    continue;
+                  }
+                  throw error;
+                }
+                const format = await values.store(streamJson(formatted)), pointer2 = pages.allocate(14 /* Count */ * 8);
+                const data = Array(14 /* Count */).fill(0);
+                data[11 /* Format */] = format.start;
+                data[12 /* FormatLength */] = format.length;
+                data[13 /* Run */] = position;
+                await write(pointer2, data);
+                runCount++;
+                if (paragraphRow[2 /* LastInline */]) await write(paragraphRow[2 /* LastInline */], [pointer2]);
+                else paragraphRow[1 /* Inlines */] = pointer2;
+                paragraphRow[2 /* LastInline */] = pointer2;
+                continue;
+              }
               if (kind < 0) continue;
               async function* text() {
                 if (kind === 1) yield* literal("\v");
@@ -288,8 +642,8 @@ async function openRetainedText(archive, fingerprint, options, settings, reading
               }
               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]);
+              const pointer = pages.allocate(14 /* Count */ * 8);
+              await write(pointer, [0, kind, value.start, value.length, identifier.start, identifier.length, type.start, type.length, fieldIndex, cached.start, cached.length, 0, 0, 0]);
               if (paragraphRow[2 /* LastInline */]) await write(paragraphRow[2 /* LastInline */], [pointer]);
               else paragraphRow[1 /* Inlines */] = pointer;
               paragraphRow[2 /* LastInline */] = pointer;
@@ -365,26 +719,58 @@ async function openRetainedText(archive, fingerprint, options, settings, reading
     await index.close();
     await traversal.close();
     check();
+    if (formattingError) throw formattingError;
+    async function* paragraphFormats() {
+      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 */], 6 /* Count */)) if (paragraph[4 /* Format */]) yield {
+            location,
+            paragraph: paragraph[3 /* Index */],
+            coordinateSystem: "zero-based",
+            formatting: { [rawJson]: () => values.read(range(paragraph, 4 /* Format */)) }
+          };
+        }
+      } catch (error) {
+        throw failure(error);
+      }
+    }
+    async function* runs() {
+      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 */], 6 /* Count */)) for await (const inline of rows(paragraph[1 /* Inlines */], 14 /* Count */)) if (inline[11 /* Format */]) yield {
+            location,
+            paragraph: paragraph[3 /* Index */],
+            run: inline[13 /* Run */],
+            coordinateSystem: "zero-based",
+            formatting: { [rawJson]: () => values.read(range(inline, 11 /* Format */)) }
+          };
+        }
+      } catch (error) {
+        throw failure(error);
+      }
+    }
     async function* inlineText(first) {
-      for await (const inline of rows(first, 11 /* Count */)) yield* values.read(range(inline, 2 /* Text */));
+      for await (const inline of rows(first, 14 /* Count */)) yield* values.read(range(inline, 2 /* Text */));
     }
     async function* bodyText(first) {
       let separator = false;
-      for await (const paragraph of rows(first, 4 /* Count */)) {
+      for await (const paragraph of rows(first, 6 /* 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 */)) {
+      for await (const inline of rows(first, 14 /* 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 */]) };
+      for await (const paragraph of rows(first, 6 /* Count */)) yield { index: paragraph[3 /* Index */], coordinateSystem: "zero-based", text: () => inlineText(paragraph[1 /* Inlines */]), inlines: inlines(paragraph[1 /* Inlines */]) };
     }
     async function* segments() {
       try {
@@ -408,7 +794,7 @@ async function openRetainedText(archive, fingerprint, options, settings, reading
       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) {
+          for await (const paragraph of rows(body[4 /* Paragraphs */], 6 /* Count */)) for await (const inline of rows(paragraph[1 /* Inlines */], 14 /* 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) {
@@ -433,7 +819,7 @@ async function openRetainedText(archive, fingerprint, options, settings, reading
         throw failure(error);
       }
     }
-    return Object.freeze({ close, segments, fields, fieldCount, frames, frameCount, async *text() {
+    return Object.freeze({ close, segments, paragraphFormats, paragraphCount, runs, runCount, fields, fieldCount, frames, frameCount, async *text() {
       let separator = false;
       for await (const segment of segments()) {
         if (separator) yield* literal("\n");
@@ -449,9 +835,9 @@ async function openRetainedText(archive, fingerprint, options, settings, reading
 }
 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 (!["text.get", "fields.list", "fields.get", "text.frames.list", "text.frames.get", "text.runs.list", "text.runs.get", "text.paragraphs.list", "text.paragraphs.get"].includes(operation)) throw new OfficeError("invalid-value", "Invalid retained text operation.", "usage");
+  const paragraphs = operation.startsWith("text.paragraphs."), runs = operation.startsWith("text.runs."), frames = operation.startsWith("text.frames."), fields = operation.startsWith("fields.");
+  const text = await openRetainedText(archive, fingerprint, options, settings, frames ? "frames" : runs ? "runs" : paragraphs ? "paragraphs" : "text").catch((error) => {
     if (frames && error instanceof SelectionError && error.code === "missing-selection") return void 0;
     throw error;
   });
@@ -460,7 +846,7 @@ async function stageRetainedText(archive, fingerprint, options, settings, output
   }
   let staged;
   async function* locations() {
-    for await (const item of frames ? frameRecords() : fields ? text.fields() : text.segments()) yield item.location;
+    for await (const item of frames ? frameRecords() : runs ? text.runs() : paragraphs ? text.paragraphFormats() : fields ? text.fields() : text.segments()) yield item.location;
   }
   async function* items() {
     for await (const field of text.fields()) yield {
@@ -478,13 +864,17 @@ async function stageRetainedText(archive, fingerprint, options, settings, output
   }
   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* streamJson({ version: 1, operation, ok: true, data: frames ? { frames: frameRecords() } : runs ? { runs: text.runs() } : paragraphs ? { paragraphs: text.paragraphFormats() } : 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 (runs) yield* streamJson(text.runs());
+    else if (paragraphs) yield* streamJson(text.paragraphFormats());
     else if (fields) yield* streamJson(text.fields());
     else yield* text.text();
   }
   try {
+    if (operation === "text.paragraphs.get" && text.paragraphCount !== 1) throw new SelectionError(text.paragraphCount ? "ambiguous-selection" : "missing-selection");
+    if (operation === "text.runs.get" && text.runCount !== 1) throw new SelectionError(text.runCount ? "ambiguous-selection" : "missing-selection");
     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);

package/dist/safe-bash/command-chunks/{chunk-YKODRSGT.js → chunk-WRCYZJNO.js}

@@ -1,7 +1,7 @@
 import {
   SelectionError,
   readSelectionIndex
-} from "./chunk-NCNHJRIY.js";
+} from "./chunk-3W3HLPCX.js";
 import {
   readPackage
 } from "./chunk-Q65GWGQR.js";

package/dist/safe-bash/command-chunks/{chunk-TID5TSQW.js → chunk-WRJV7OVO.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-G7PVC6TG.js";
 import {
   playwrightStorageAbilities
-} from "./chunk-YPG55QTP.js";
+} from "./chunk-HCJWEB6P.js";
 import {
   playwrightRecordingAbilities
 } from "./chunk-XPUHDPMZ.js";

package/dist/safe-bash/command-chunks/{chunk-T4SEQU66.js → chunk-X4TWJNW7.js}

@@ -1,15 +1,15 @@
 import {
   measurePackageResourceSerialization
-} from "./chunk-RTHYAGKI.js";
+} from "./chunk-ETN25WCR.js";
 import {
   validateDocxInvocation
-} from "./chunk-ZM7HMBAJ.js";
+} from "./chunk-BDGNKRY4.js";
 import {
   readDocumentArchive
 } from "./chunk-5BUL25DF.js";
 import {
   UnsupportedEditError
-} from "./chunk-LZY46GYY.js";
+} from "./chunk-QMWBKR4C.js";
 import {
   documentDialects
 } from "./chunk-WLANDWNW.js";

package/dist/safe-bash/command-chunks/{chunk-CKA7ZROU.js → chunk-X6KFCAWZ.js}

@@ -1,27 +1,27 @@
 import {
   sectionState
-} from "./chunk-MUTARE5I.js";
+} from "./chunk-LSKA4IR4.js";
 import {
   openDocumentLocations
-} from "./chunk-KDBU5Q2N.js";
+} from "./chunk-MWVELMXZ.js";
 import {
   sectionAttribute
-} from "./chunk-DM5WURQL.js";
+} from "./chunk-JY2T3KV2.js";
 import {
   paragraphTextRun,
   replaceParagraphContent
-} from "./chunk-HOKPYTHQ.js";
+} from "./chunk-MPRUGL4W.js";
 import {
   findRelationshipPart,
   retainedRelationshipTargets
 } from "./chunk-UIX3CASN.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";
@@ -31,7 +31,7 @@ import {
   activeXmlChildren,
   editActiveRelationshipXml,
   xmlValue
-} from "./chunk-LZY46GYY.js";
+} from "./chunk-QMWBKR4C.js";
 import {
   relationshipXmlRows
 } from "./chunk-WI4522BH.js";