@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,163 @@
+import {
+  inspectDocumentSignatures,
+  stripDocumentSignatures
+} from "./chunk-YH4DC4RP.js";
+import {
+  editDocumentStyles,
+  inspectDocumentStyles
+} from "./chunk-A2YEQYCC.js";
+import {
+  editDocumentTables
+} from "./chunk-4FNQPK7C.js";
+import {
+  editDocumentRevisions
+} from "./chunk-3SWT2KYH.js";
+import {
+  formatDocumentRuns
+} from "./chunk-L2KEA6SN.js";
+import {
+  editDocumentRevisionDecisions
+} from "./chunk-7LEADSSA.js";
+import {
+  inspectDocumentSettings
+} from "./chunk-OIPATOZW.js";
+import {
+  extractDocumentText
+} from "./chunk-7DADVPKN.js";
+import {
+  editDocumentParagraphs
+} from "./chunk-AQ6RTM2M.js";
+import {
+  editDocumentProperties,
+  inspectDocumentProperties
+} from "./chunk-AIOB34IX.js";
+import {
+  inspectDocumentRevisions
+} from "./chunk-WGOL3MM6.js";
+import {
+  inspectDocumentTable,
+  inspectDocumentTables
+} from "./chunk-HOAM3F5I.js";
+import {
+  inspectDocumentParagraph,
+  inspectDocumentParagraphs,
+  inspectDocumentRun,
+  inspectDocumentRuns
+} from "./chunk-5AU5ENL5.js";
+import {
+  inspectDocumentFonts
+} from "./chunk-KR2PQ7GD.js";
+import {
+  editDocumentFields,
+  inspectDocumentFields
+} from "./chunk-XFEUWSYG.js";
+import {
+  replaceDocumentText,
+  setDocumentDummyText
+} from "./chunk-NY4ZPV3N.js";
+import {
+  insertDocumentImage
+} from "./chunk-YH7KKMMN.js";
+import {
+  setDocumentImageLayout
+} from "./chunk-7MMSBVUP.js";
+import {
+  replaceDocumentImage
+} from "./chunk-E7AYF54A.js";
+import {
+  inspectDocumentImages
+} from "./chunk-2VGAC6S6.js";
+import {
+  editDocumentLists
+} from "./chunk-W543LSYH.js";
+import {
+  editDocumentComments,
+  inspectDocumentComments
+} from "./chunk-TVAEX4WQ.js";
+import {
+  applyDocumentTemplate
+} from "./chunk-DV745GFU.js";
+import {
+  editDocumentControlBindings
+} from "./chunk-RKPPUYZE.js";
+import {
+  editDocumentControlRepeats
+} from "./chunk-N4DY4FPA.js";
+import {
+  editDocumentControls,
+  inspectDocumentControls
+} from "./chunk-2B6XWO6A.js";
+import {
+  editDocumentBookmarks
+} from "./chunk-2NE2GPSF.js";
+import {
+  inspectDocumentPackageResources,
+  packageResourceWarnings
+} from "./chunk-W6DV2CLS.js";
+import {
+  docxOperationSchemas
+} from "./chunk-R4TYL2G6.js";
+
+// packages/safe-bash-docx-engine/src/batch-operations.ts
+var documentBatchActions = /* @__PURE__ */ new Map();
+for (const operation of ["comments.list", "comments.get"])
+  documentBatchActions.set(operation, (input, item, context) => inspectDocumentComments(input, { operation: item.operation, options: item.arguments }, context, "resource"));
+for (const operation of ["comments.add", "comments.set", "comments.remove"])
+  documentBatchActions.set(operation, (input, item, context) => editDocumentComments(input, { operation: item.operation, options: item.arguments }, context));
+documentBatchActions.set("revisions.list", (input, item, context) => inspectDocumentRevisions(input, item.arguments, context, "resource"));
+documentBatchActions.set("revisions.add", (input, item, context) => editDocumentRevisions(input, item.arguments, context));
+for (const operation of ["revisions.accept", "revisions.reject"])
+  documentBatchActions.set(operation, (input, item, context) => editDocumentRevisionDecisions(input, { operation: item.operation, options: item.arguments }, context));
+documentBatchActions.set("controls.list", (input, item, context) => inspectDocumentControls(input, item.arguments, context));
+documentBatchActions.set("controls.set", (input, item, context) => editDocumentControls(input, item.arguments, context));
+documentBatchActions.set("controls.repeat", (input, item, context) => editDocumentControlRepeats(input, item.arguments, context));
+documentBatchActions.set("template.apply", (input, item, context) => applyDocumentTemplate(input, item.arguments, context));
+documentBatchActions.set("settings.list", (input, item, context) => inspectDocumentSettings(input, item.arguments, context, "resource"));
+documentBatchActions.set("fonts.list", (input, item, context) => inspectDocumentFonts(input, item.arguments, context));
+documentBatchActions.set("controls.bind", (input, item, context) => editDocumentControlBindings(input, item.arguments, context));
+for (const operation of ["custom-xml.list", "glossary.list"])
+  documentBatchActions.set(operation, async (input, item, context) => {
+    const data = await inspectDocumentPackageResources(input, operation, item.arguments, context);
+    return { ...data, warnings: packageResourceWarnings(data) };
+  });
+documentBatchActions.set("signatures.list", (input, item, context) => inspectDocumentSignatures(input, item.arguments, context));
+documentBatchActions.set("signatures.remove", (input, item, context) => stripDocumentSignatures(input, item.arguments, context));
+for (const operation of ["lists.add", "lists.set"])
+  documentBatchActions.set(operation, (input, item, context) => editDocumentLists(input, { operation: item.operation, options: item.arguments }, context));
+documentBatchActions.set("bookmarks.add", (input, item, context) => editDocumentBookmarks(input, { operation: item.operation, options: item.arguments }, context));
+for (const operation of ["fields.add", "fields.set", "toc.add", "toc.set", "captions.add", "captions.set"])
+  documentBatchActions.set(operation, (input, item, context) => editDocumentFields(input, { operation: item.operation, options: item.arguments }, context));
+for (const operation of ["paragraphs.add", "paragraphs.set", "runs.add", "tables.add"])
+  documentBatchActions.set(operation, (input, item, context) => editDocumentParagraphs(input, { operation: item.operation, options: item.arguments }, context));
+for (const operation of ["tables.set", "tables.rows.add", "tables.rows.remove", "tables.columns.add", "tables.columns.remove", "tables.merge", "tables.split"])
+  documentBatchActions.set(operation, (input, item, context) => editDocumentTables(input, { operation: item.operation, options: item.arguments }, context));
+for (const operation of ["styles.add", "styles.set", "styles.remove", "styles.defaults.set", "styles.latent.add", "styles.latent.set", "styles.latent.remove", "styles.latent.defaults.set"])
+  documentBatchActions.set(operation, (input, item, context) => editDocumentStyles(input, { ...item.arguments, operation: item.operation }, context));
+for (const operation of ["styles.list", "styles.get", "styles.defaults.get", "styles.latent.list", "styles.latent.get", "styles.latent.defaults.get"])
+  documentBatchActions.set(operation, (input, item, context) => inspectDocumentStyles(input, { ...item.arguments, ...operation.includes(".latent.") ? { latent: true } : {} }, context));
+documentBatchActions.set("text.replace", (input, item, context) => replaceDocumentText(input, item.arguments, context));
+documentBatchActions.set("lorem.set", (input, item, context) => setDocumentDummyText(input, item.arguments, context));
+documentBatchActions.set("runs.set", (input, item, context) => formatDocumentRuns(input, item.arguments, context));
+documentBatchActions.set("images.add", (input, item, context) => insertDocumentImage(input, { operation: "images.add", options: item.arguments }, context));
+documentBatchActions.set("images.replace", (input, item, context) => replaceDocumentImage(input, { operation: "images.replace", options: item.arguments }, context));
+documentBatchActions.set("images.set", (input, item, context) => setDocumentImageLayout(input, { operation: "images.set", options: item.arguments }, context));
+for (const operation of ["properties.set", "properties.remove"])
+  documentBatchActions.set(operation, (input, item, context) => editDocumentProperties(input, { ...item.arguments, operation: item.operation }, context));
+documentBatchActions.set("text.get", (input, item, context) => extractDocumentText(input, context, item.arguments));
+documentBatchActions.set("paragraphs.get", (input, item, context) => inspectDocumentParagraph(input, item.arguments, context));
+documentBatchActions.set("runs.get", (input, item, context) => inspectDocumentRun(input, item.arguments, context));
+documentBatchActions.set("paragraphs.list", (input, item, context) => inspectDocumentParagraphs(input, item.arguments, context));
+documentBatchActions.set("runs.list", (input, item, context) => inspectDocumentRuns(input, item.arguments, context));
+documentBatchActions.set("fields.list", (input, item, context) => inspectDocumentFields(input, item.arguments, context));
+documentBatchActions.set("tables.get", (input, item, context) => inspectDocumentTable(input, item.arguments, context));
+documentBatchActions.set("tables.list", (input, item, context) => inspectDocumentTables(input, item.arguments, context));
+for (const operation of ["images.list", "images.get"])
+  documentBatchActions.set(operation, (input, item, context) => inspectDocumentImages(input, { ...item.arguments, operation: item.operation }, context));
+for (const operation of ["properties.list", "properties.get"])
+  documentBatchActions.set(operation, (input, item, context) => inspectDocumentProperties(input, item.arguments, context));
+var documentBatchOperations = Object.freeze([...documentBatchActions.keys()].filter((id) => docxOperationSchemas[id]?.batchFields !== void 0));
+
+export {
+  documentBatchActions,
+  documentBatchOperations
+};

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

@@ -0,0 +1,186 @@
+import {
+  textMarkup
+} from "./chunk-NY4ZPV3N.js";
+import {
+  openDocumentLocations,
+  resolveDocxSelection
+} from "./chunk-LHDB4QO5.js";
+import {
+  DocumentArchiveEditor
+} from "./chunk-MAHX3IW3.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  LocationIndex,
+  addressKey,
+  pathContains
+} from "./chunk-IR6ZKAUH.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  UnsupportedEditError,
+  assertOutsideRevisionRanges,
+  containsRevision,
+  runElementOpen
+} from "./chunk-YPVBU7QF.js";
+import {
+  dialectForNamespace
+} from "./chunk-MG7AJD5E.js";
+import {
+  closedRecord,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+import {
+  InvalidValueError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/removal.ts
+var annotationNames = /* @__PURE__ */ new Set(["bookmarkStart", "bookmarkEnd", "commentRangeStart", "commentRangeEnd", "commentReference", "permStart", "permEnd"]);
+var blockContainers = /* @__PURE__ */ new Set(["body", "tc", "hdr", "ftr", "footnote", "endnote", "comment", "txbxContent", "sdtContent"]);
+async function removeDocumentContent(input, request, context) {
+  closedRecord(request, ["operation", "options", "input"]);
+  if (!["paragraphs.remove", "runs.remove", "tables.remove"].includes(request.operation)) throw new DocxUsageError("Expected a content removal operation.");
+  const settings = archiveSettings(context);
+  const invocation = validateDocxInvocation({ operation: request.operation, inputs: [request.input?.path ?? "document"], options: request.options }, settings.budget);
+  const opts = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((opts.limit ?? []).map((item) => [item.name, item.value])));
+  const document = await openDocumentLocations(input, { ...settings, budget });
+  const selected = resolveDocxSelection(document, invocation);
+  const archive = document.snapshot();
+  assertDocumentEditable(archive, { ...settings, budget }, archive);
+  const editor = new DocumentArchiveEditor(archive, {}, void 0, budget);
+  const plans = [];
+  for (const before of selected) {
+    budget.charge("work", before.value.path.length + selected.length);
+    if (selected.some((other) => other !== before && other.value.part === before.value.part && pathContains(other.value.path, before.value.path)))
+      throw new InvalidValueError("Overlapping structure selections cannot be removed together.");
+    const range = before.value.range;
+    if (range && !opts.markers) throw new DocxUsageError("Range removal requires explicit markers exclude or include.");
+    if (!range && opts.markers !== void 0) throw new DocxUsageError("Marker inclusion requires a scalar range.");
+    if (range && range.start === range.end && !opts.allowEmpty) throw new InvalidValueError("Removal requires a nonempty scalar range.");
+    const xml = editor.xml(before.value.part.slice(1));
+    let node = xml.root, parent = node;
+    const ancestors = [node];
+    for (const i of before.value.path) {
+      parent = node;
+      node = node.children[i];
+      ancestors.push(node);
+    }
+    if (ancestors.some((n) => ["ins", "del", "moveFrom", "moveTo", "fldSimple"].includes(n.localName) && n.namespace === node.namespace) || containsRevision(node))
+      throw new UnsupportedEditError("Removal cannot discard or cross fields or review history.");
+    assertOutsideRevisionRanges(xml.root, node, budget, xml.compatibility.branches);
+    xml.assertShapeEditAllowed(node);
+    const active = /* @__PURE__ */ new Set();
+    let fieldDepth = 0;
+    const scan = (current) => {
+      budget.charge("work", 1);
+      if (current === node && (active.size || fieldDepth)) throw new UnsupportedEditError("Removal crosses an annotation or field boundary.");
+      if (current.namespace === node.namespace) {
+        const id = current.attributes.find((a) => a.namespace === node.namespace && a.localName === "id")?.value ?? "";
+        const key = current.localName.replace("Start", "").replace("End", "") + ":" + id;
+        if (["bookmarkStart", "commentRangeStart", "permStart"].includes(current.localName)) active.add(key);
+        if (["bookmarkEnd", "commentRangeEnd", "permEnd"].includes(current.localName)) active.delete(key);
+        if (current.localName === "fldChar") {
+          const type = current.attributes.find((a) => a.localName === "fldCharType")?.value;
+          if (type === "begin") fieldDepth++;
+          else if (type === "end") fieldDepth--;
+        }
+      }
+      for (const child of current.children) scan(child);
+    };
+    const story = ancestors.find((n) => n !== node && blockContainers.has(n.localName) && n.localName !== "tc" && n.localName !== "sdtContent") ?? xml.root;
+    scan(story);
+    const check = (current) => {
+      budget.charge("work", 1);
+      if (annotationNames.has(current.localName) && current.namespace === node.namespace)
+        throw new UnsupportedEditError("Affected bookmarks, comments and permission ranges require their explicit resource operations.");
+      if (current.namespace !== node.namespace || !["p", "pPr", "r", "rPr", "t", "tab", "br", "cr", "noBreakHyphen", "softHyphen", "proofErr", "lastRenderedPageBreak", "hyperlink", "tbl", "tblPr", "tblGrid", "gridCol", "tr", "trPr", "tc", "tcPr"].includes(current.localName))
+        throw new UnsupportedEditError("Removal includes unsupported fields, notes, objects or opaque structures.");
+      if (current.content.some((c) => c.kind !== "element" && (c.kind !== "text" || !["t"].includes(current.localName) && c.text.trim())))
+        throw new UnsupportedEditError("Removal cannot discard XML annotations.");
+      if (["pPr", "rPr", "tblPr", "trPr", "tcPr", "tblGrid"].includes(current.localName)) return;
+      for (const child of current.children) check(child);
+    };
+    check(node);
+    if (!range && request.operation === "tables.remove" && before.kind !== "table") throw new InvalidValueError("Table removal requires a whole table.");
+    if (range) {
+      if (before.kind !== "paragraph" && before.kind !== "run") throw new InvalidValueError("Removal endpoints require a paragraph or run.");
+      if (range.start === range.end) continue;
+      let offset = 0;
+      const patches = /* @__PURE__ */ new Map();
+      const visit = (current) => {
+        budget.charge("work", 1);
+        if (["pPr", "rPr"].includes(current.localName)) return;
+        if (["proofErr", "lastRenderedPageBreak"].includes(current.localName)) {
+          if (opts.markers === "include" && range.start <= offset && offset <= range.end) patches.set(current, "");
+          return;
+        }
+        const text = current.localName === "t" ? current.text : current.localName === "tab" ? "	" : ["br", "cr"].includes(current.localName) ? "\n" : current.localName === "noBreakHyphen" ? "\u2011" : current.localName === "softHyphen" ? "\xAD" : void 0;
+        if (text !== void 0) {
+          const chars = [...text];
+          budget.charge("retainedBytes", chars.length * 8);
+          const start = Math.max(0, range.start - offset), end = Math.min(chars.length, range.end - offset);
+          if (start < end) patches.set(current, current.localName === "t" ? textMarkup(current, chars.slice(0, start).concat(chars.slice(end)).join(""), true) : "");
+          offset += chars.length;
+        } else for (const child of current.children) visit(child);
+      };
+      visit(node);
+      const render = (current) => {
+        if (patches.has(current)) return patches.get(current);
+        return xml.sourceXml(current, new Map(current.children.map((child) => [child, render(child)])));
+      };
+      plans.push({ before, xml, node, parent, markup: render(node), retained: true });
+    } else {
+      if (before.kind !== "run" && (!blockContainers.has(parent.localName) || parent.namespace !== node.namespace))
+        throw new UnsupportedEditError("Structure removal requires an admitted block container.");
+      const props = node.children.find((c) => c.namespace === node.namespace && c.localName === "pPr");
+      const section = props?.children.some((c) => c.namespace === node.namespace && c.localName === "sectPr");
+      if (before.kind === "table" && containsSection(node)) throw new UnsupportedEditError("A table containing section breaks cannot be removed.");
+      plans.push({ before, xml, node, parent, markup: section ? runElementOpen(node) + xml.sourceXml(props) + `</${node.name}>` : "", retained: !!section });
+    }
+  }
+  for (const plan of plans.filter((p) => !p.before.value.range && p.before.kind !== "run")) {
+    const siblings = plans.filter((p) => p.parent === plan.parent && !p.before.value.range);
+    const surviving = plan.parent.children.filter((n) => ["p", "tbl"].includes(n.localName) && !siblings.some((p) => p.node === n && !p.retained));
+    const needsParagraph = !surviving.length || plan.parent.localName === "tc" && surviving.at(-1)?.localName !== "p";
+    if (needsParagraph && siblings.at(-1) === plan) {
+      const props = plan.node.children.find((n) => n.namespace === plan.node.namespace && n.localName === "pPr");
+      plan.markup = plan.before.kind === "paragraph" ? plan.node.children.every((n) => n === props) ? plan.xml.sourceXml(plan.node) : runElementOpen(plan.node) + (props ? plan.xml.sourceXml(props) : "") + `</${plan.node.name}>` : `<w:p xmlns:w="${plan.node.namespace}"/>`;
+      plan.retained = plan.before.kind === "paragraph";
+    }
+  }
+  const changedPlans = plans.filter((plan) => plan.markup !== plan.xml.sourceXml(plan.node));
+  for (const plan of changedPlans) plan.xml.replaceElement(plan.node, plan.markup);
+  const candidate = editor.snapshot();
+  const mainPart = document.list("story", { scope: "body" })[0].value.part.slice(1);
+  const index = new LocationIndex(candidate, settings.limits, mainPart, dialectForNamespace(editor.xml(mainPart).root.namespace), budget);
+  const changes = changedPlans.map((plan) => {
+    const value = { ...plan.before.value, generation: 1, range: plan.before.value.range ? { start: plan.before.value.range.start, end: plan.before.value.range.start } : null };
+    const shift = plans.filter((p) => p.parent === plan.parent && !p.markup && p.node !== plan.node && p.before.value.path.at(-1) < plan.before.value.path.at(-1)).length;
+    const path = [...value.path];
+    path[path.length - 1] = path.at(-1) - shift;
+    const entry = plan.retained ? index.byAddress.get(addressKey({ ...value, path }))?.find((e) => e.kind === plan.before.kind) : void 0;
+    if (plan.retained && (!entry || value.range && !index.validRange(entry, value.range.start, value.range.end)))
+      throw new UnsupportedEditError("Removal could not resolve its surviving location.");
+    const after = plan.retained ? { ...plan.before, positions: entry.positions, value: { ...value, path }, token: encodeGeneratedLocation({ ...value, path }) } : null;
+    return { kind: "remove", before: plan.before, after };
+  });
+  const publication = { ...request.input ? { input: request.input } : {}, ...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 } };
+  budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify({ version: 1, operation: request.operation, ok: true, data: { changed: !!changes.length, changes, dryRun: opts.dryRun ?? false, output: opts.dryRun ? null : { path: opts.output ?? null, bytes: Math.min(settings.limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) } }, affected: changes.length, locations: changes.flatMap((c) => c.after ? [c.after] : []), warnings: [], errors: [] }) + "\n").length);
+  const result = await publishDocumentArchive(candidate, publication, { ...context, budget }, archive);
+  return { changed: !!changes.length, changes, dryRun: opts.dryRun ?? false, output: result.published.length ? { path: result.published[0].path, bytes: result.published[0].bytes, sha256: result.archiveSha256 } : null };
+}
+function containsSection(node) {
+  return node.localName === "sectPr" || node.children.some(containsSection);
+}
+
+export {
+  removeDocumentContent
+};