@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,289 @@
+import {
+  DocumentArchiveEditor
+} from "./chunk-MAHX3IW3.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  editLatentStyles,
+  readLatentStyles,
+  styleLinkPatches
+} from "./chunk-SDTC2BLK.js";
+import {
+  createDocumentArchive
+} from "./chunk-XH6DXJHX.js";
+import {
+  addDocumentStylesPart
+} from "./chunk-MQFXMBGD.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  SemanticValidationError,
+  validateDocumentArchive
+} from "./chunk-3SEQG5JH.js";
+import {
+  readDocumentArchive
+} from "./chunk-GLPIFP7N.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  activeXmlChildren,
+  formattedRunProperties,
+  inheritStyleProperties,
+  mergeStyleChildren,
+  newTabStopXml,
+  paragraphProperties,
+  paragraphUnits,
+  readStyleProperties,
+  replaceActiveStyleXml,
+  replaceNativeTabCollectionXml,
+  selectNamedStyles,
+  styleAttribute,
+  styleChild,
+  styleDisplayName,
+  styleInteger,
+  styleToggle,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  storedBoolean
+} from "./chunk-VEUQWV2V.js";
+import {
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  SelectionError,
+  closedRecord
+} from "./chunk-LQOKYG3O.js";
+import {
+  InvalidValueError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/styles.ts
+function stylePart(archive) {
+  const edges = archive.package.relationships("/" + archive.mainPart).filter((e) => e.reltype === `${documentDialects[archive.dialect].r}/styles`);
+  if (edges.length > 1 || edges[0]?.is_external) throw new UnsupportedEditError("Expected one internal styles part.");
+  return edges[0]?.target_part.name;
+}
+async function inspectDocumentStyles(input, options, context) {
+  closedRecord(options, ["name", "json", "limit", "latent"]);
+  const { latent, ...args } = options;
+  const settings = archiveSettings(context);
+  const invocation = validateDocxInvocation({ operation: latent ? options.name === void 0 ? "styles.latent.list" : "styles.latent.get" : options.name === void 0 ? "styles.list" : "styles.get", inputs: ["document"], options: args }, settings.budget);
+  const budget = settings.budget.lower(Object.fromEntries((invocation.options.limit ?? []).map((v) => [v.name, v.value])));
+  const archive = await readDocumentArchive(input, { ...settings, budget });
+  const part = stylePart(archive);
+  const xml = part ? new DocumentXmlEditor(archive.members.find((m) => m.name === part).bytes, {}, void 0, budget) : void 0;
+  const children = xml ? activeXmlChildren(xml, budget) : (node) => node.children;
+  const child = (node, name2) => node && children(node).find((n) => n.namespace === node.namespace && n.localName === name2);
+  const nodes = xml ? children(xml.root).filter((n) => n.namespace === xml.root.namespace && n.localName === "style") : [];
+  const defaults = child(xml?.root, "docDefaults");
+  const runDefaults = readStyleProperties(child(child(defaults, "rPrDefault"), "rPr"), void 0, children);
+  const paragraphDefaults = readStyleProperties(void 0, child(child(defaults, "pPrDefault"), "pPr"), children);
+  const defined = new Map(nodes.map((n) => [styleAttribute(n, "styleId"), n]));
+  const name = (id) => {
+    if (id === void 0) return null;
+    const target = defined.get(id), stored = styleAttribute(child(target, "name"), "val");
+    return stored === void 0 ? id : styleDisplayName(stored, !storedBoolean(styleAttribute(target, "customStyle") ?? "0"));
+  };
+  const resolved = /* @__PURE__ */ new Map();
+  const defaultProperties = Object.fromEntries(Object.entries(runDefaults).map(([key, value]) => [key, value ?? paragraphDefaults[key]]));
+  for (const start of nodes) {
+    if (resolved.has(start)) continue;
+    const chain = [], seen = /* @__PURE__ */ new Set();
+    let node = start;
+    while (node && !resolved.has(node) && !seen.has(node)) {
+      budget.charge("work", 1);
+      chain.push(node);
+      seen.add(node);
+      node = defined.get(styleAttribute(child(node, "basedOn"), "val"));
+    }
+    let value = node && seen.has(node) ? null : node ? resolved.get(node) : defaultProperties;
+    for (const current of chain.reverse()) {
+      const direct = readStyleProperties(child(current, "rPr"), child(current, "pPr"), children);
+      if (value !== null) value = inheritStyleProperties(value, direct);
+      resolved.set(current, value);
+    }
+  }
+  const selected = options.name === void 0 || latent ? nodes : selectNamedStyles(nodes, options.name, children, budget);
+  if (!latent && options.name !== void 0 && selected.length !== 1) throw new SelectionError(selected.length ? "ambiguous-selection" : "missing-selection");
+  if (latent && options.name !== void 0 && !xml) throw new SelectionError("missing-selection");
+  const report = validateDocumentArchive(archive, {}, budget);
+  const data = {
+    styles: selected.map((n) => {
+      const source = (tag) => child(n, tag) ? xml.sourceXml(child(n, tag)) : null;
+      const stored = styleAttribute(child(n, "name"), "val"), builtin = !storedBoolean(styleAttribute(n, "customStyle") ?? "0");
+      const displayed = styleDisplayName(stored ?? "", builtin);
+      return {
+        id: styleAttribute(n, "styleId") ?? "",
+        name: displayed,
+        type: styleAttribute(n, "type") ?? "paragraph",
+        builtin,
+        base: name(styleAttribute(child(n, "basedOn"), "val")),
+        next: name(styleAttribute(child(n, "next"), "val")) ?? ((styleAttribute(n, "type") ?? "paragraph") === "paragraph" && stored !== void 0 ? displayed : null),
+        linkedStyle: name(styleAttribute(child(n, "link"), "val")),
+        defaultForType: storedBoolean(styleAttribute(n, "default") ?? "0"),
+        priority: styleInteger(styleAttribute(child(n, "uiPriority"), "val")),
+        hidden: styleToggle(child(n, "semiHidden")) ?? false,
+        locked: styleToggle(child(n, "locked")) ?? false,
+        quickStyle: styleToggle(child(n, "qFormat")) ?? false,
+        unhideWhenUsed: styleToggle(child(n, "unhideWhenUsed")) ?? false,
+        direct: readStyleProperties(child(n, "rPr"), child(n, "pPr"), children),
+        effective: resolved.get(n) ?? null,
+        runXml: source("rPr"),
+        paragraphXml: source("pPr"),
+        tableXml: source("tblPr")
+      };
+    }),
+    defaults: { run: runDefaults, paragraph: paragraphDefaults },
+    latentXml: child(xml?.root, "latentStyles") ? xml.sourceXml(child(xml.root, "latentStyles")) : null,
+    latent: xml ? readLatentStyles(xml.root, latent ? options.name : void 0, children) : null,
+    diagnostics: report.diagnostics.filter((d) => d.code.startsWith("style-") || d.code.startsWith("latent-") || d.code.startsWith("numbering-"))
+  };
+  budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify(data)).length);
+  return data;
+}
+var styleOrder = "name aliases basedOn next link autoRedefine hidden uiPriority semiHidden unhideWhenUsed qFormat locked personal personalCompose personalReply rsid pPr rPr tblPr trPr tcPr tblStylePr".split(" ");
+async function editDocumentStyles(input, options, context) {
+  closedRecord(options, ["operation", "input", ...Object.keys(options ?? {})]);
+  const settings = archiveSettings(context);
+  const { operation, input: identity, ...args } = options;
+  if (!["styles.add", "styles.set", "styles.remove", "styles.defaults.set", "styles.latent.add", "styles.latent.set", "styles.latent.remove", "styles.latent.defaults.set"].includes(operation)) throw new InvalidValueError("Expected a style edit operation.");
+  const invocation = validateDocxInvocation({ operation, inputs: [identity?.path ?? "document"], options: args }, settings.budget);
+  const opts = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((opts.limit ?? []).map((v) => [v.name, v.value])));
+  let archive = await readDocumentArchive(input, { ...settings, budget });
+  assertDocumentEditable(archive, { ...settings, budget });
+  if (operation === "styles.add" && opts.type === "numbering")
+    throw new UnsupportedEditError("Direct utility creation of numbering styles is unsupported; use the typed style model.");
+  const report = validateDocumentArchive(archive, {}, budget);
+  if (!report.valid) throw new SemanticValidationError(report.diagnostics);
+  let added = false;
+  if (operation === "styles.add") {
+    if (!["paragraph", "character", "table"].includes(opts.type)) throw new UnsupportedEditError("Creation supports paragraph, character and table styles.");
+    archive = await createDocumentArchive({ template: input, content: { version: 1, blocks: [], styles: [{ name: opts.name, type: opts.type }] } }, { ...settings, budget });
+    added = true;
+  }
+  let part = stylePart(archive);
+  const absentPart = part === void 0;
+  let writable = archive;
+  if (!part) {
+    if (operation !== "styles.defaults.set" && !operation.startsWith("styles.latent.")) throw new SelectionError("missing-selection");
+    const materialized = addDocumentStylesPart(archive, archive, "", budget);
+    part = materialized.name;
+    writable = { ...archive, ...materialized.archive };
+  }
+  const editor = new DocumentArchiveEditor(writable, {}, void 0, budget);
+  const xml = editor.xml(part), w = xml.root.namespace;
+  const children = activeXmlChildren(xml, budget);
+  const child = (node, name) => styleChild(node, name, children);
+  const nodes = children(xml.root).filter((n) => n.namespace === w && n.localName === "style");
+  const resolve = (name) => {
+    const matches = selectNamedStyles(nodes, name, children, budget);
+    if (matches.length !== 1) throw new SelectionError(matches.length ? "ambiguous-selection" : "missing-selection");
+    return matches[0];
+  };
+  const element = (tag, value) => `<st:${tag} xmlns:st="${w}" st:val="${xmlValue(value)}"/>`;
+  const changes = [];
+  const patches = /* @__PURE__ */ new Map();
+  const attributes = /* @__PURE__ */ new Map();
+  const update = (node, tag, markup) => {
+    const map = patches.get(node) ?? /* @__PURE__ */ new Map();
+    map.set(tag, markup);
+    patches.set(node, map);
+  };
+  const setValue = (node, tag, value) => {
+    const existing = child(node, tag);
+    if (value === null ? !existing : styleAttribute(existing, "val") === value) {
+      patches.get(node)?.delete(tag);
+      return;
+    }
+    update(node, tag, value === null ? "" : element(tag, value));
+  };
+  const formatting = (node) => {
+    const run = formattedRunProperties(xml, node, { ...opts, hidden: opts.fontHidden }, children);
+    const para = paragraphProperties(xml, node, opts, void 0, children);
+    if (run !== (child(node, "rPr") ? xml.sourceXml(child(node, "rPr")) : "")) update(node, "rPr", run);
+    if (para !== (child(node, "pPr") ? xml.sourceXml(child(node, "pPr")) : "")) update(node, "pPr", para);
+  };
+  if (operation.startsWith("styles.latent.")) {
+    const id = editLatentStyles(xml, operation, invocation.options, activeXmlChildren(xml, budget));
+    if (id !== null) changes.push({ kind: "style", id });
+  } else if (operation === "styles.remove") {
+    const selected = resolve(opts.name);
+    xml[replaceActiveStyleXml](selected, "");
+    changes.push({ kind: "style", id: styleAttribute(selected, "styleId") });
+  } else if (operation === "styles.defaults.set") {
+    const declarations = children(xml.root).filter((node) => node.namespace === w && node.localName === "docDefaults");
+    if (declarations.length > 1) throw new UnsupportedEditError("Duplicate document defaults cannot be edited.");
+    const defaults = declarations[0];
+    const defaultsXml = defaults ? xml : new DocumentXmlEditor(new TextEncoder().encode(`<st:docDefaults xmlns:st="${w}"/>`), {}, void 0, budget);
+    const target = defaults ?? defaultsXml.root;
+    const defaultsChildren = activeXmlChildren(defaultsXml, budget);
+    const updates = /* @__PURE__ */ new Map();
+    for (const [container, property] of [["rPrDefault", "rPr"], ["pPrDefault", "pPr"]]) {
+      const containers = defaultsChildren(target).filter((node) => node.namespace === w && node.localName === container);
+      if (containers.length > 1) throw new UnsupportedEditError("Duplicate default property containers cannot be edited.");
+      const existing = containers[0];
+      const fragment = existing ? defaultsXml : new DocumentXmlEditor(new TextEncoder().encode(`<st:${container} xmlns:st="${w}"/>`), {}, void 0, budget);
+      const owner = existing ?? fragment.root;
+      const fragmentChildren = activeXmlChildren(fragment, budget);
+      const props = property === "rPr" ? formattedRunProperties(fragment, owner, { ...opts, hidden: opts.fontHidden }, fragmentChildren) : paragraphProperties(fragment, owner, opts, void 0, fragmentChildren);
+      const old = styleChild(owner, property, fragmentChildren);
+      if (props === (old ? fragment.sourceXml(old) : "")) continue;
+      updates.set(container, mergeStyleChildren(fragment, owner, /* @__PURE__ */ new Map([[property, props]]), [property], {}, fragmentChildren));
+    }
+    if (updates.size) {
+      const markup = mergeStyleChildren(defaultsXml, target, updates, ["rPrDefault", "pPrDefault"], {}, defaultsChildren);
+      if (defaults) xml.replaceElement(defaults, markup);
+      else xml.insertChildren(xml.root, markup, xml.root.children[0]);
+      changes.push({ kind: "style", id: "docDefaults" });
+    }
+  } else {
+    const selected = resolve(opts.name), type = styleAttribute(selected, "type") ?? "paragraph";
+    if (!["paragraph", "character", "table", "numbering"].includes(type)) throw new UnsupportedEditError("Unknown style type cannot be edited.");
+    if (type === "character" && [opts.outlineLevel, opts.keepWithNext, opts.keepTogether, opts.widowControl, opts.pageBreakBefore, opts.spaceBefore, opts.spaceAfter, opts.alignment, opts.leftIndent, opts.rightIndent, opts.firstLineIndent, opts.lineSpacing, opts.lineSpacingRule, opts.tabStops, opts.tabStopAdd, opts.tabStopDelete, opts.tabStopsClear, opts.borders, opts.shading].some((v) => v !== void 0))
+      throw new InvalidValueError("Character styles cannot contain paragraph properties.");
+    for (const [key, tag] of [["base", "basedOn"], ["next", "next"]]) {
+      const value = opts[key];
+      if (value === void 0) continue;
+      if (key === "next" && type !== "paragraph") throw new InvalidValueError("Next style requires a paragraph style.");
+      const target = value === null ? void 0 : resolve(value);
+      if (target && (styleAttribute(target, "type") ?? "paragraph") !== type) throw new InvalidValueError("Style relationship requires matching types.");
+      setValue(selected, tag, target ? styleAttribute(target, "styleId") : null);
+    }
+    for (const [node, patch] of styleLinkPatches(nodes, selected, opts, children, budget)) {
+      if (patch.link !== void 0) setValue(node, "link", patch.link);
+      if (patch.default !== void 0) attributes.set(node, { default: patch.default });
+    }
+    for (const [key, tag] of [["hidden", "semiHidden"], ["locked", "locked"], ["quickStyle", "qFormat"], ["unhideWhenUsed", "unhideWhenUsed"]])
+      if (opts[key] !== void 0) setValue(selected, tag, opts[key] ? "1" : null);
+    if (opts.priority !== void 0) setValue(selected, "uiPriority", opts.priority === null ? null : String(opts.priority));
+    formatting(selected);
+    const patchedStyles = [.../* @__PURE__ */ new Set([...patches.keys(), ...attributes.keys()])];
+    if (opts.tabStopAdd) patchedStyles.sort((a, b) => Number(a === selected) - Number(b === selected));
+    for (const node of patchedStyles) {
+      const markup = mergeStyleChildren(xml, node, patches.get(node) ?? /* @__PURE__ */ new Map(), styleOrder, attributes.get(node), children);
+      if (markup === xml.sourceXml(node)) continue;
+      const tabs = child(child(node, "pPr"), "tabs");
+      if (node === selected && opts.tabStopAdd && tabs) xml[replaceNativeTabCollectionXml](node, markup, tabs, newTabStopXml(w, opts.tabStopAdd), paragraphUnits(opts.tabStopAdd.position));
+      else xml[replaceActiveStyleXml](node, markup);
+      changes.push({ kind: "style", id: styleAttribute(node, "styleId") });
+    }
+    if (added && !changes.some((c) => c.id === styleAttribute(selected, "styleId"))) changes.push({ kind: "style", id: styleAttribute(selected, "styleId") });
+  }
+  const staged = absentPart && changes.length === 0 ? archive : editor.snapshot();
+  const publication = { ...identity ? { input: identity } : {}, ...opts.output === void 0 ? {} : { output: opts.output }, ...opts.inPlace === void 0 ? {} : { inPlace: opts.inPlace }, ...opts.force === void 0 ? {} : { force: opts.force }, ...opts.dryRun === void 0 ? {} : { dryRun: opts.dryRun }, ...opts.json === void 0 ? {} : { json: opts.json } };
+  const prospective = { changed: changes.length > 0, changes, dryRun: opts.dryRun ?? false, output: { path: opts.output ?? null, bytes: Math.min(settings.limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) } };
+  budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify({ version: 1, operation, ok: true, data: prospective, affected: changes.length, locations: [], errors: [], warnings: [] }) + "\n").length);
+  const result = await publishDocumentArchive(staged, publication, { ...context, budget });
+  return { changed: changes.length > 0, changes, dryRun: opts.dryRun ?? false, output: result.published.length ? { path: result.published[0].path, bytes: result.published[0].bytes, sha256: result.archiveSha256 } : null };
+}
+
+export {
+  inspectDocumentStyles,
+  editDocumentStyles
+};