@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,164 @@
+import {
+  attr,
+  child,
+  fields,
+  invalid,
+  loadShared,
+  required,
+  unique
+} from "./chunk-RAXJVM4U.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/themes.ts
+var themeColorSlots = [
+  "dk1",
+  "lt1",
+  "dk2",
+  "lt2",
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "hlink",
+  "folHlink"
+];
+var themeFontSlots = [
+  "majorLatin",
+  "minorLatin",
+  "majorEastAsia",
+  "minorEastAsia",
+  "majorComplex",
+  "minorComplex"
+];
+function validateColor(color) {
+  if (typeof color !== "string" || color.length !== 6 || [...color].some((c) => !"0123456789abcdefABCDEF".includes(c)))
+    invalid("Color must contain six hexadecimal digits.");
+}
+function themeParts(s) {
+  return [
+    .../* @__PURE__ */ new Set([
+      ...s.index.inventory.themes,
+      ...s.index.inventory.relationships.filter((e) => e.type === `${s.r}/themeOverride` && !e.external).map((e) => e.targetPart)
+    ])
+  ];
+}
+function affected(s, part) {
+  const owners = s.index.inventory.relationships.filter((e) => e.targetPart === part && !e.external).map((e) => e.owner);
+  return s.index.inventory.slides.filter(
+    (slide) => slide.theme === part || owners.some((owner) => [slide.part, slide.layout, slide.master].includes(owner))
+  ).map((slide) => slide.position);
+}
+function fontPath(slot) {
+  return [
+    slot.startsWith("major") ? "majorFont" : "minorFont",
+    slot.endsWith("Latin") ? "latin" : slot.endsWith("EastAsia") ? "ea" : "cs"
+  ];
+}
+async function readThemes(input, context) {
+  const s = await loadShared(input, context, false);
+  return themeParts(s).map((part) => {
+    const root = s.doc(part).root, override = root.name.localName === "themeOverride", container = override ? root : required(root, "themeElements");
+    const colors = child(container, "clrScheme"), fonts = child(container, "fontScheme");
+    return {
+      part,
+      name: attr(root, "name") ?? "",
+      override,
+      affectedSlides: affected(s, part),
+      colors: Object.fromEntries(
+        themeColorSlots.map((slot) => {
+          const n = colors && child(colors, slot), v = n?.children.find((c) => c.name.namespace === s.a);
+          return [
+            slot,
+            v ? (v.name.localName === "srgbClr" ? attr(v, "val") : v.name.localName === "sysClr" ? attr(v, "lastClr") : null) ?? null : null
+          ];
+        })
+      ),
+      fonts: Object.fromEntries(
+        themeFontSlots.map((slot) => {
+          const [family, script] = fontPath(slot), n = fonts && child(fonts, family), v = n && child(n, script);
+          return [slot, v ? attr(v, "typeface") ?? null : null];
+        })
+      )
+    };
+  });
+}
+async function mutateTheme(input, options, context) {
+  fields(options, ["scope", "theme", "name", "colorSlot", "color", "fontSlot", "font"], ["shared"]);
+  if (options.colorSlot === void 0 !== (options.color === void 0) || options.fontSlot === void 0 !== (options.font === void 0))
+    invalid("Color and font edits require both slot and value.");
+  if (options.colorSlot !== void 0) {
+    if (!themeColorSlots.includes(options.colorSlot)) invalid("Unknown theme color slot.");
+    validateColor(options.color);
+  }
+  if (options.fontSlot !== void 0 && !themeFontSlots.includes(options.fontSlot))
+    invalid("Unknown theme font slot.");
+  if ([options.name, options.font].some(
+    (v) => v !== void 0 && (typeof v !== "string" || v.length > context.xmlLimits.maxBytes)
+  ))
+    invalid("Invalid theme text.");
+  if (options.name === void 0 && options.colorSlot === void 0 && options.fontSlot === void 0)
+    invalid("A theme change is required.");
+  const s = await loadShared(input, context), part = unique(
+    themeParts(s).filter((p) => p === options.theme),
+    "Select one theme."
+  );
+  let xml = s.doc(part);
+  if (xml.root.name.namespace !== s.a || !["theme", "themeOverride"].includes(xml.root.name.localName))
+    throw new OfficeError("unsupported-edit", "Unsupported theme root.", "validate-intent");
+  if (xml.root.name.localName === "themeOverride" && options.name !== void 0)
+    throw new OfficeError(
+      "unsupported-edit",
+      "Theme overrides do not have names.",
+      "validate-intent"
+    );
+  const container = () => xml.root.name.localName === "themeOverride" ? xml.root : required(xml.root, "themeElements");
+  if (options.name !== void 0)
+    xml = xml.merge(xml.root, {
+      attributes: [{ namespace: "", localName: "name", value: options.name }]
+    });
+  if (options.colorSlot !== void 0) {
+    const scheme = required(container(), "clrScheme"), slot = required(scheme, options.colorSlot), colors = slot.children.filter(
+      (n) => n.name.namespace === s.a && ["srgbClr", "sysClr", "scrgbClr", "hslClr", "prstClr", "schemeClr"].includes(
+        n.name.localName
+      )
+    );
+    const old = unique(colors, "Expected one theme color.");
+    if (old.name.localName === "srgbClr")
+      xml = xml.merge(old, {
+        attributes: [{ namespace: "", localName: "val", value: options.color }]
+      });
+    else {
+      if (old.children.length || old.attributes.some(
+        (a) => a.name.namespace !== "" || !["val", "lastClr"].includes(a.name.localName)
+      ))
+        throw new OfficeError(
+          "unsupported-edit",
+          "Color extensions cannot be discarded by conversion.",
+          "validate-intent"
+        );
+      xml = xml.spliceChildren(slot, slot.children.indexOf(old), 1, [
+        `<a:srgbClr xmlns:a="${s.a}" val="${options.color}"/>`
+      ]);
+    }
+  }
+  if (options.fontSlot !== void 0) {
+    const [family, script] = fontPath(options.fontSlot), node = required(required(required(container(), "fontScheme"), family), script);
+    xml = xml.merge(node, {
+      attributes: [{ namespace: "", localName: "typeface", value: options.font }]
+    });
+  }
+  s.save(part, xml);
+  return s.finish(part, affected(s, part));
+}
+
+export {
+  themeColorSlots,
+  themeFontSlots,
+  validateColor,
+  readThemes,
+  mutateTheme
+};

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

@@ -0,0 +1,153 @@
+import {
+  normalizePartName
+} from "./chunk-WAKYUXVQ.js";
+import {
+  InvalidValueError,
+  ResourceLimitError
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/location-token.ts
+var SelectionError = class extends Error {
+  constructor(code, candidates = []) {
+    super(code === "stale-selection" ? "The document location is stale." : code === "missing-selection" ? "The selection has no valid target." : "The selection has multiple possible targets.");
+    this.code = code;
+    this.candidates = Object.freeze([...candidates]);
+  }
+  code;
+  candidates;
+};
+function closedRecord(value, keys) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || keys.some((key) => key in value && !Object.hasOwn(value, key)) || Reflect.ownKeys(value).some((key) => typeof key !== "string" || !keys.includes(key) || !Object.hasOwn(Object.getOwnPropertyDescriptor(value, key), "value")))
+    throw new InvalidValueError("Expected a closed data object.");
+}
+function safeOrdinal(value) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1)
+    throw new InvalidValueError("Expected a positive one-based position.");
+}
+function nonnegative(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+var LocationCapacityError = class extends InvalidValueError {
+};
+var physicalPaths = /* @__PURE__ */ new WeakSet();
+function createPhysicalLocationPath(length, indexAt) {
+  const path = new Array(length);
+  for (let index = length - 1; index >= 0; index--) {
+    const value = indexAt(index);
+    if (!nonnegative(value)) throw new InvalidValueError("Invalid physical document path.");
+    path[index] = value || 0;
+  }
+  Object.freeze(path);
+  physicalPaths.add(path);
+  return path;
+}
+function checked(value, generated = false) {
+  closedRecord(value, ["version", "sourceSha256", "generation", "part", "story", "path", "range"]);
+  if (Object.keys(value).length !== 7) throw new InvalidValueError("Location payload fields are required.");
+  const { version, sourceSha256, generation, part, story, path, range } = value;
+  if (version !== 1 || typeof sourceSha256 !== "string" || sourceSha256.length !== 64 || [...sourceSha256].some((c) => !"0123456789abcdef".includes(c)) || !nonnegative(generation) || typeof part !== "string" || typeof story !== "string" || !story || !Array.isArray(path)) throw new InvalidValueError("Invalid document location payload.");
+  if (part.length > 4096 || story.length > 8192 || path.length * 2 > 24576)
+    throw new LocationCapacityError("Invalid document location payload.");
+  let ownedPath = path;
+  if (!generated || !physicalPaths.has(path)) {
+    if (Reflect.ownKeys(path).length !== path.length + 1)
+      throw new InvalidValueError("Invalid document location payload.");
+    const copy = [];
+    for (let index = 0; index < path.length; index++) {
+      const descriptor = Object.getOwnPropertyDescriptor(path, String(index));
+      if (!descriptor || !("value" in descriptor) || !nonnegative(descriptor.value))
+        throw new InvalidValueError("Invalid document location payload.");
+      copy.push(descriptor.value || 0);
+    }
+    ownedPath = Object.freeze(copy);
+  }
+  try {
+    if (part !== "/[Content_Types].xml" && normalizePartName(part) !== part) throw new Error();
+  } catch {
+    throw new InvalidValueError("Expected a canonical location part name.");
+  }
+  if (range !== null) {
+    closedRecord(range, ["start", "end"]);
+    if (Object.keys(range).length !== 2) throw new InvalidValueError("Range fields are required.");
+    const pair = range;
+    if (!nonnegative(pair.start) || !nonnegative(pair.end) || pair.end < pair.start)
+      throw new InvalidValueError("Invalid document location range.");
+  }
+  return Object.freeze({
+    version,
+    sourceSha256,
+    generation: generation || 0,
+    part,
+    story,
+    path: Object.freeze(ownedPath),
+    range: range === null ? null : Object.freeze({ start: range.start || 0, end: range.end || 0 })
+  });
+}
+function canonicalEncoding(value) {
+  const json = JSON.stringify(value);
+  let ascii = true;
+  for (const text of [value.part, value.story])
+    for (let index = 0; index < text.length; index++) if (text.charCodeAt(index) > 127) {
+      ascii = false;
+      break;
+    }
+  let binary = json;
+  let length = json.length;
+  if (ascii) {
+    if (json.length > 24576) throw new LocationCapacityError("Document location token is too large.");
+  } else {
+    const bytes = new TextEncoder().encode(json);
+    if (bytes.length > 24576) throw new LocationCapacityError("Document location token is too large.");
+    length = bytes.length;
+    binary = "";
+    for (let index = 0; index < bytes.length; index += 8192)
+      binary += String.fromCharCode(...bytes.subarray(index, index + 8192));
+  }
+  return { token: "docx-loc-v1." + btoa(binary).split("+").join("-").split("/").join("_").split("=")[0], bytes: length };
+}
+function encodeLocation(value) {
+  return canonicalEncoding(checked(value)).token;
+}
+function createGeneratedLocation(value) {
+  try {
+    const payload = checked(value, true);
+    return Object.freeze({ ...canonicalEncoding(payload), value: payload });
+  } catch (error) {
+    if (error instanceof LocationCapacityError) throw new ResourceLimitError("Document location token capacity exceeded.");
+    throw error;
+  }
+}
+function encodeGeneratedLocation(value) {
+  try {
+    return encodeLocation(value);
+  } catch (error) {
+    if (error instanceof LocationCapacityError) throw new ResourceLimitError("Document location token capacity exceeded.");
+    throw error;
+  }
+}
+function decodeLocation(token) {
+  if (typeof token !== "string" || token.length > 32780 || !token.startsWith("docx-loc-v1."))
+    throw new InvalidValueError("Invalid document location token.");
+  const data = token.slice(12);
+  if (!data || [...data].some((c) => !(c >= "A" && c <= "Z") && !(c >= "a" && c <= "z") && !(c >= "0" && c <= "9") && c !== "-" && c !== "_")) throw new InvalidValueError("Invalid document location encoding.");
+  try {
+    const binary = atob(data.split("-").join("+").split("_").join("/"));
+    const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+    const value = checked(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes)));
+    if (encodeLocation(value) !== token) throw new Error();
+    return value;
+  } catch {
+    throw new InvalidValueError("Invalid document location token.");
+  }
+}
+
+export {
+  SelectionError,
+  closedRecord,
+  safeOrdinal,
+  createPhysicalLocationPath,
+  encodeLocation,
+  createGeneratedLocation,
+  encodeGeneratedLocation,
+  decodeLocation
+};

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

@@ -0,0 +1,12 @@
+// packages/safe-bash-command-node/src/integrations/safejs/values.ts
+import { record, onlyKeys, stringValue, booleanValue, abortError, checkSignal, withSignal } from "../../safe-bash-command-safejs/values.js";
+
+export {
+  record,
+  onlyKeys,
+  stringValue,
+  booleanValue,
+  abortError,
+  checkSignal,
+  withSignal
+};

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

@@ -0,0 +1,305 @@
+import {
+  pathContains
+} from "./chunk-IR6ZKAUH.js";
+import {
+  revisionInfo
+} from "./chunk-YPVBU7QF.js";
+import {
+  storedBoolean
+} from "./chunk-VEUQWV2V.js";
+
+// packages/safe-bash-docx-engine/src/text-traversal.ts
+function readTextSegments(index, selected, view, location, budget, ownedLocationBytes) {
+  const segments = [];
+  let segmentCount = 0;
+  const byNode = /* @__PURE__ */ new Map();
+  for (const entry of index.entries) if (entry.node && entry.kind !== "annotation") byNode.set(entry.node, entry);
+  const defaults = {
+    bold: null,
+    italic: null,
+    rtl: null,
+    hidden: null,
+    style: null,
+    language: {},
+    fonts: {},
+    paragraph: { style: null, bidi: null }
+  };
+  const named = (node, name) => node && index.named(node, name)[0];
+  const value = (node, name) => {
+    const property = named(node, name);
+    return property ? index.attr(property, "val") ?? null : null;
+  };
+  const toggle = (node, name) => {
+    const property = named(node, name);
+    return property ? storedBoolean(index.attr(property, "val") ?? "true", "Invalid stored text formatting boolean.") : null;
+  };
+  const attributes = (node) => Object.fromEntries(
+    (node?.attributes ?? []).filter((a) => a.namespace === node.namespace).map((a) => [a.localName, a.value])
+  );
+  const properties = (owner, name, state) => {
+    const current = named(owner, name);
+    const change = named(current, name + "Change");
+    const info = change && revisionInfo(change);
+    const original = info?.support === "supported" ? named(change, name) : current;
+    return {
+      node: view === "original" ? original : current,
+      original,
+      revisions: info ? [...state.revisions, info] : state.revisions
+    };
+  };
+  const visible = (revision) => !(view === "final" && revision === "delete" || view === "original" && revision === "insert");
+  const marked = (node) => named(node, "del") ? "delete" : named(node, "ins") ? "insert" : void 0;
+  const make = (text, state, kind) => {
+    budget.check("matches", ++segmentCount);
+    budget.charge("retainedBytes", 256 + text.length * 2);
+    budget.charge("work", text.length + 1);
+    return { text, kind, location: location(state.entry), revision: state.revision, revisions: state.revisions, formatting: state.formatting, originalFormatting: view === "all" ? state.originalFormatting : null };
+  };
+  const join = (pieces, separator, kind, state) => {
+    if (pieces.length === 1) {
+      budget.charge("work", pieces[0].segments.length);
+      return pieces[0].segments;
+    }
+    const children = [];
+    let length = 0;
+    pieces.forEach((piece, i) => {
+      const previous = pieces[i - 1];
+      if (previous && separator && visible(previous.boundary ?? "unchanged")) {
+        children.push([make(separator, previous.boundary ? { ...previous.state, revision: previous.boundary, revisions: previous.boundaryInfo ? [...previous.state.revisions, previous.boundaryInfo] : previous.state.revisions } : state, kind)]);
+        length++;
+      }
+      budget.charge("work", piece.segments.length);
+      children.push(piece.segments);
+      length += piece.segments.length;
+    });
+    budget.charge("retainedBytes", 64 + children.length * 8);
+    return { length, children };
+  };
+  let storyCount = 0;
+  for (const story of index.entries.filter((e) => e.kind === "story")) {
+    budget.charge("work", selected.length + index.entries.length);
+    const targets = selected.filter((target) => target.value.story === story.story);
+    if (!targets.length) continue;
+    const selection = index.textSelection(targets.map((target) => target.value));
+    const fields = [];
+    const w = story.wordNamespace ?? story.node.namespace;
+    const included = (entry) => {
+      budget.charge("work", targets.length * (selection.length(entry) + 1));
+      return selection.included(entry);
+    };
+    const relevant = (entry) => {
+      budget.charge("work", targets.length * (selection.length(entry) + 1));
+      return included(entry) || selection.relevant(entry);
+    };
+    let revision = "unchanged";
+    const revisions2 = [];
+    let omitted = false;
+    let ancestor = index.entries.find((entry) => entry.kind === "part" && entry.part === story.part).node;
+    for (const child of story.path) {
+      budget.charge("work", 1);
+      ancestor = ancestor.children[child];
+      const info = revisionInfo(ancestor);
+      if (info) revisions2.push(info);
+      if (ancestor.namespace !== w) continue;
+      const rowRevision = ancestor.localName === "tr" ? marked(named(ancestor, "trPr")) : void 0;
+      if (!rowRevision && !["ins", "moveTo", "del", "moveFrom"].includes(ancestor.localName)) continue;
+      revision = rowRevision ?? (ancestor.localName === "ins" || ancestor.localName === "moveTo" ? "insert" : "delete");
+      omitted ||= view === "final" && revision === "delete" || view === "original" && revision === "insert";
+    }
+    if (omitted) continue;
+    const initial = { entry: story, revision, revisions: revisions2, formatting: defaults, originalFormatting: defaults };
+    const visit = (node, inherited) => {
+      budget.charge("retainedBytes", 128);
+      const pending = [{ node, inherited, index: -1, pieces: [] }];
+      let result2 = [];
+      const finish = (pieces2) => {
+        pending.pop();
+        const parent = pending.at(-1);
+        if (parent) {
+          budget.charge("work", pieces2.length);
+          budget.charge("retainedBytes", pieces2.length * 8);
+          for (const piece of pieces2) parent.pieces.push(piece);
+        } else result2 = pieces2;
+      };
+      while (pending.length) {
+        const frame = pending.at(-1);
+        const node2 = frame.node;
+        if (frame.index === -1) {
+          const inherited2 = frame.inherited;
+          budget.charge("work", 1);
+          const entry = byNode.get(node2);
+          let state2 = entry?.story === story.story ? { ...inherited2, entry } : inherited2;
+          if (node2.namespace !== w && node2 !== story.node) {
+            finish([]);
+            continue;
+          }
+          const name2 = node2.localName;
+          const info = revisionInfo(node2);
+          if (info?.support === "opaque") {
+            finish([]);
+            continue;
+          }
+          if (info) state2 = { ...state2, revisions: [...state2.revisions, info] };
+          if (name2 === "txbxContent" && node2 !== story.node) {
+            finish([]);
+            continue;
+          }
+          if (["pPr", "rPr", "tblPr", "tcPr", "trPr", "sectPr", "tblGrid", "drawing", "pict", "object", "instrText", "delInstrText", "lastRenderedPageBreak"].includes(name2)) {
+            finish([]);
+            continue;
+          }
+          if (["ins", "moveTo", "del", "moveFrom"].includes(name2)) {
+            const revision2 = name2 === "ins" || name2 === "moveTo" ? "insert" : "delete";
+            if (!visible(revision2)) {
+              finish([]);
+              continue;
+            }
+            state2 = { ...state2, revision: revision2 };
+          }
+          if (name2 === "tr") {
+            const revision2 = marked(named(node2, "trPr"));
+            if (revision2 && !visible(revision2)) {
+              finish([]);
+              continue;
+            }
+            if (revision2) {
+              const marker = named(named(node2, "trPr"), revision2 === "insert" ? "ins" : "del");
+              const info2 = marker && revisionInfo(marker);
+              state2 = { ...state2, revision: revision2, revisions: info2 ? [...state2.revisions, info2] : state2.revisions };
+            }
+          }
+          if (name2 === "p") {
+            const props = properties(node2, "pPr", state2);
+            state2 = {
+              ...state2,
+              revisions: props.revisions,
+              formatting: { ...defaults, paragraph: { style: value(props.node, "pStyle"), bidi: toggle(props.node, "bidi") } },
+              originalFormatting: { ...defaults, paragraph: { style: value(props.original, "pStyle"), bidi: toggle(props.original, "bidi") } }
+            };
+          }
+          if (name2 === "r") {
+            const props = properties(node2, "rPr", state2);
+            const formatting = (node3, base) => ({
+              ...base,
+              bold: toggle(node3, "b"),
+              italic: toggle(node3, "i"),
+              hidden: toggle(node3, "vanish"),
+              rtl: toggle(node3, "rtl"),
+              style: value(node3, "rStyle"),
+              language: attributes(named(node3, "lang")),
+              fonts: attributes(named(node3, "rFonts"))
+            });
+            state2 = {
+              ...state2,
+              revisions: props.revisions,
+              formatting: formatting(props.node, state2.formatting),
+              originalFormatting: formatting(props.original, state2.originalFormatting)
+            };
+          }
+          if (name2 === "fldChar") {
+            const type = index.attr(node2, "fldCharType");
+            if (type === "begin") fields.push(false);
+            else if (type === "separate" && fields.length) fields[fields.length - 1] = true;
+            else if (type === "end") fields.pop();
+            {
+              finish([]);
+              continue;
+            }
+          }
+          const text = name2 === "t" || name2 === "delText" ? node2.text : name2 === "tab" || name2 === "ptab" ? "	" : name2 === "cr" ? "\n" : name2 === "br" ? index.attr(node2, "type") === "page" ? "\f" : index.attr(node2, "type") === "column" ? "\v" : "\n" : name2 === "noBreakHyphen" ? "\u2011" : name2 === "softHyphen" ? "\xAD" : void 0;
+          if (text !== void 0) {
+            if (!included(state2.entry) || fields.includes(false) || name2 === "delText" && view === "final") {
+              finish([]);
+              continue;
+            }
+            const kind = name2 === "tab" || name2 === "ptab" ? "tab" : name2 === "br" || name2 === "cr" ? text === "\f" ? "page-break" : text === "\v" ? "column-break" : "line-break" : "text";
+            finish(text ? [{ state: state2, segments: [make(text, name2 === "delText" ? { ...state2, revision: "delete" } : state2, kind)] }] : []);
+            continue;
+          }
+          frame.state = state2;
+          frame.children = index.children.get(node2) ?? [];
+          frame.index = 0;
+        }
+        const child = frame.children[frame.index++];
+        if (child) {
+          budget.charge("retainedBytes", 128);
+          pending.push({ node: child, inherited: frame.state, index: -1, pieces: [] });
+          continue;
+        }
+        const children = frame.pieces, state = frame.state, name = node2.localName;
+        if (name === "p" || name === "tc" || name === "tr" || name === "tbl" || node2 === story.node) {
+          if (!relevant(state.entry) || !children.length && (!included(state.entry) || name === "tbl")) {
+            finish([]);
+            continue;
+          }
+          const separator = name === "p" ? "" : name === "tr" ? "	" : "\n";
+          const kind = name === "tr" ? "cell" : name === "tbl" ? "row" : "paragraph";
+          const boundary = name === "p" ? marked(named(named(node2, "pPr"), "rPr")) : void 0;
+          finish([{ state, segments: join(children, separator, kind, state), ...boundary ? { boundary, boundaryInfo: revisionInfo(named(named(named(node2, "pPr"), "rPr"), boundary === "delete" ? "del" : "ins")) } : {} }]);
+          continue;
+        }
+        finish(children);
+      }
+      return result2;
+    };
+    const pieces = visit(story.node, initial);
+    if (!pieces.length) continue;
+    if (storyCount++) segments.push(make("\n\n", initial, "story"));
+    for (const piece of pieces) {
+      const pending = [piece.segments];
+      while (pending.length) {
+        const sequence = pending.pop();
+        if (Array.isArray(sequence)) {
+          for (const segment of sequence) segments.push(segment);
+        } else {
+          for (let child = sequence.children.length - 1; child >= 0; child--)
+            pending.push(sequence.children[child]);
+        }
+      }
+    }
+  }
+  const range = selected.length === 1 ? selected[0].value.range : null;
+  let result = segments;
+  if (range) {
+    let offset = 0;
+    result = segments.flatMap((segment) => {
+      const scalars = [...segment.text];
+      const text = scalars.slice(Math.max(0, range.start - offset), Math.max(0, range.end - offset)).join("");
+      offset += scalars.length;
+      return text ? [{ ...segment, text }] : [];
+    });
+  }
+  budget.check("matches", result.length);
+  const revisions = [];
+  for (const entry of index.entries) {
+    if (entry.kind !== "annotation" || !entry.node) continue;
+    budget.charge("work", selected.length);
+    if (!selected.some((s) => s.value.story === entry.story && (pathContains(s.value.path, entry.path) || pathContains(entry.path, s.value.path)))) continue;
+    const info = revisionInfo(entry.node);
+    if (info) {
+      budget.check("matches", revisions.length + 1);
+      revisions.push(info);
+    }
+  }
+  const warnings = revisions.some((r) => r.support === "opaque") ? [{ code: "opaque-revision", message: "Unsupported revision content is inventoried as opaque; its text and historical properties are not interpreted." }] : [];
+  const data = { revisions, warnings, text: result.map((segment) => segment.text).join(""), view, segments: result, hiddenText: "include" };
+  const encoder = new TextEncoder();
+  const locationBytes = /* @__PURE__ */ new WeakMap();
+  let bytes = encoder.encode(JSON.stringify({ ...data, segments: [] })).length;
+  for (const segment of result) {
+    let size = locationBytes.get(segment.location);
+    if (size === void 0) {
+      size = ownedLocationBytes?.(segment.location) ?? encoder.encode(JSON.stringify(segment.location)).length;
+      locationBytes.set(segment.location, size);
+    }
+    bytes += encoder.encode(JSON.stringify({ ...segment, location: null })).length - 4 + size;
+  }
+  bytes += Math.max(0, result.length - 1);
+  budget.check("serializedOutput", bytes);
+  budget.charge("retainedBytes", bytes);
+  return data;
+}
+
+export {
+  readTextSegments
+};

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

@@ -0,0 +1,27 @@
+// packages/safe-bash-docx-engine/src/style-font-flags.ts
+var styleFontFlags = {
+  bold: "b",
+  italic: "i",
+  allCaps: "caps",
+  complexScriptEnabled: "cs",
+  csBold: "bCs",
+  csItalic: "iCs",
+  doubleStrike: "dstrike",
+  emboss: "emboss",
+  imprint: "imprint",
+  math: "oMath",
+  noProof: "noProof",
+  outline: "outline",
+  shadow: "shadow",
+  smallCaps: "smallCaps",
+  snapToGrid: "snapToGrid",
+  specVanish: "specVanish",
+  webHidden: "webHidden",
+  strike: "strike",
+  fontHidden: "vanish",
+  rtl: "rtl"
+};
+
+export {
+  styleFontFlags
+};