@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,469 @@
+import {
+  admitImage
+} from "./chunk-45BW6MGM.js";
+import {
+  readTable
+} from "./chunk-MQU6Q75R.js";
+import {
+  nodeFor
+} from "./chunk-QHS7PDG3.js";
+import {
+  readTextBodies
+} from "./chunk-XP6BHGZ6.js";
+import {
+  child,
+  escape,
+  loadShared,
+  nextRel,
+  relPart
+} from "./chunk-RAXJVM4U.js";
+import {
+  protectedEquationNodes
+} from "./chunk-5DFZAJHL.js";
+import {
+  relativePartReference
+} from "./chunk-XXFHTGV2.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/template-bindings.ts
+function invalid() {
+  throw new OfficeError(
+    "invalid-value",
+    "Bindings require typed stored JSON data with explicit scope and cardinality.",
+    "usage"
+  );
+}
+function object(value, keys, required = keys) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)) || required.some((key) => !Object.hasOwn(value, key)) || Reflect.ownKeys(value).some(
+    (key) => typeof key !== "string" || !keys.includes(key) || !("value" in Object.getOwnPropertyDescriptor(value, key))
+  ))
+    invalid();
+}
+function array(value) {
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype || Reflect.ownKeys(value).length !== value.length + 1)
+    invalid();
+  for (let i = 0; i < value.length; i++)
+    if (!("value" in (Object.getOwnPropertyDescriptor(value, String(i)) ?? {}))) invalid();
+}
+function text(value) {
+  if (typeof value !== "string") invalid();
+  for (const character of value) {
+    const point = character.codePointAt(0);
+    if (point < 32 && ![9, 10, 13].includes(point) || point >= 55296 && point <= 57343 || point === 65534 || point === 65535)
+      invalid();
+  }
+}
+function utf8Size(value) {
+  let size = 0;
+  for (const character of value) {
+    const point = character.codePointAt(0);
+    size += point <= 127 ? 1 : point <= 2047 ? 2 : point <= 65535 ? 3 : 4;
+  }
+  return size;
+}
+function validateTemplateBindings(bindings) {
+  array(bindings);
+  const seen = /* @__PURE__ */ new Set();
+  for (const binding of bindings) {
+    object(
+      binding,
+      ["kind", "name", "scope", "slide", "cardinality", "text", "table", "image"],
+      ["kind", "name", "scope", "slide", "cardinality"]
+    );
+    text(binding.name);
+    if (!binding.name || binding.name.includes("{") || binding.name.includes("}") || binding.scope !== "slides" || !Number.isSafeInteger(binding.slide) || binding.slide < 1 || !["one", "all"].includes(binding.cardinality))
+      invalid();
+    if (typeof binding.kind !== "string" || !["text", "table", "image"].includes(binding.kind))
+      invalid();
+    const field = binding.kind;
+    if (!field || Object.keys(binding).length !== 6 || !Object.hasOwn(binding, field) || ["text", "table", "image"].some((key2) => key2 !== field && Object.hasOwn(binding, key2)))
+      invalid();
+    const key = JSON.stringify([binding.slide, binding.kind, binding.name]);
+    if (seen.has(key)) invalid();
+    seen.add(key);
+    if (binding.kind === "text") text(binding.text);
+    else if (binding.kind === "table") {
+      array(binding.table);
+      if (!binding.table.length) invalid();
+      let columns = 0;
+      for (const row of binding.table) {
+        array(row);
+        if (!row.length || columns && columns !== row.length) invalid();
+        columns = row.length;
+        for (const cell of row) text(cell);
+      }
+    } else {
+      object(binding.image, ["bytes", "contentType"]);
+      array(binding.image.bytes);
+      text(binding.image.contentType);
+      if (!binding.image.contentType) invalid();
+      if (Object.keys(binding.image).length !== 2 || !binding.image.bytes.length || binding.image.bytes.some(
+        (value) => !Number.isInteger(value) || value < 0 || value > 255
+      ))
+        invalid();
+    }
+  }
+}
+function markers(value) {
+  const result = [];
+  let cursor = 0;
+  while (cursor < value.length) {
+    const start = value.indexOf("{{", cursor);
+    if (start < 0) break;
+    const end = value.indexOf("}}", start + 2);
+    if (end < 0) break;
+    const name = value.slice(start + 2, end);
+    if (name && !name.includes("{") && !name.includes("}"))
+      result.push({ name, start, end: end + 2 });
+    cursor = end + 2;
+  }
+  return result;
+}
+async function applyTemplateBindings(input, bindings, context, selectedSlides = []) {
+  validateTemplateBindings(bindings);
+  array(selectedSlides);
+  if (new Set(selectedSlides).size !== selectedSlides.length || selectedSlides.some((slide) => !Number.isSafeInteger(slide) || slide < 1))
+    invalid();
+  const selected = [...selectedSlides];
+  let cumulative = 0;
+  for (const binding of bindings) {
+    context.signal?.throwIfAborted();
+    const size = binding.kind === "text" ? utf8Size(binding.text) : binding.kind === "image" ? binding.image.bytes.length : binding.table.reduce(
+      (n, row) => n + row.reduce((m, cell) => m + utf8Size(cell) + 1, 0),
+      0
+    );
+    cumulative += size;
+    if (cumulative > context.limits.maxBytes)
+      throw new OfficeError(
+        "resource-limit",
+        "Bindings exceed the cumulative byte budget.",
+        "admit"
+      );
+  }
+  const snapshots = bindings.map(
+    (binding) => binding.kind === "image" ? { ...binding, image: { ...binding.image, bytes: [...binding.image.bytes] } } : binding.kind === "table" ? { ...binding, table: binding.table.map((row) => [...row]) } : { ...binding }
+  );
+  for (const binding of snapshots) {
+    const size = binding.kind === "text" ? utf8Size(binding.text) : binding.kind === "image" ? binding.image.bytes.length : binding.table.reduce((n, row) => n + row.reduce((m, cell) => m + utf8Size(cell), 0), 0);
+    if (size > Math.min(
+      context.limits.maxBytes,
+      binding.kind === "image" ? context.archiveLimits.maxEntryBytes : context.xmlLimits.maxBytes
+    ))
+      throw new OfficeError(
+        "resource-limit",
+        "Binding content exceeds the admitted budget.",
+        "admit"
+      );
+    if (binding.kind === "image")
+      admitImage(new Uint8Array(binding.image.bytes), binding.image.contentType);
+  }
+  const s = await loadShared(input, context);
+  if (!snapshots.length && !selected.length) return { bytes: s.source, affected: 0, locations: [] };
+  const byKey = new Map(
+    snapshots.map((binding) => [
+      JSON.stringify([binding.slide, binding.kind, binding.name]),
+      binding
+    ])
+  );
+  const counts = /* @__PURE__ */ new Map();
+  const locations = [];
+  const edits = /* @__PURE__ */ new Map();
+  const images = [];
+  const targetParts = /* @__PURE__ */ new Map();
+  for (const position of /* @__PURE__ */ new Set([...selected, ...snapshots.map((binding) => binding.slide)])) {
+    const slide = s.index.inventory.slides.find((slide2) => slide2.position === position);
+    if (!slide) throw new OfficeError("missing-binding", "Binding slide does not exist.", "select");
+    targetParts.set(slide.part, position);
+  }
+  const resolve = (slide, kind, name, location) => {
+    const binding = byKey.get(JSON.stringify([slide, kind, name]));
+    if (!binding)
+      throw new OfficeError(
+        "missing-binding",
+        "A required template binding is missing.",
+        "validate-intent"
+      );
+    const count = (counts.get(binding) ?? 0) + 1;
+    counts.set(binding, count);
+    if (count > 1 && binding.cardinality !== "all")
+      throw new OfficeError(
+        "ambiguous-selection",
+        "Repeated template slots require all cardinality.",
+        "select"
+      );
+    if (!locations.some((item) => JSON.stringify(item) === JSON.stringify(location)))
+      locations.push(location);
+    return binding;
+  };
+  const ownedTables = /* @__PURE__ */ new Set();
+  for (const record of s.index.objects) {
+    context.signal?.throwIfAborted();
+    const slide = targetParts.get(record.part);
+    if (slide === void 0) continue;
+    const named = markers(record.name);
+    if (named.length !== 1 || named[0].start !== 0 || named[0].end !== record.name.length)
+      continue;
+    const doc = edits.get(record.part)?.document ?? s.doc(record.part);
+    const node = nodeFor(doc.root, record.id);
+    const graphic = child(node, "graphic", s.a);
+    const data = graphic && child(graphic, "graphicData", s.a);
+    const table = data && child(data, "tbl", s.a);
+    if (table) {
+      const binding = resolve(slide, "table", named[0].name, record.location);
+      if (binding.kind !== "table") invalid();
+      const info = readTable(node, doc);
+      if (binding.table.length !== info.rows || binding.table.some((row) => row.length !== info.columns))
+        throw new OfficeError(
+          "invalid-value",
+          "Table bindings must match the template grid dimensions.",
+          "validate-intent"
+        );
+      if (info.cells.some((cell) => cell.isMergeOrigin || cell.isSpanned))
+        throw new OfficeError(
+          "unsupported-edit",
+          "Merged table slots are not supported.",
+          "validate-intent"
+        );
+      const values = edits.get(record.part)?.values ?? /* @__PURE__ */ new Map();
+      const rows = table.children.filter(
+        (row) => row.name.namespace === s.a && row.name.localName === "tr"
+      );
+      rows.forEach(
+        (row, r) => row.children.filter((cell) => cell.name.namespace === s.a && cell.name.localName === "tc").forEach((cell, c) => {
+          const body = child(cell, "txBody", s.a);
+          if (body?.children.filter(
+            (item) => item.name.namespace === s.a && item.name.localName === "p"
+          ).length !== 1)
+            throw new OfficeError(
+              "unsupported-edit",
+              "Table slots require one existing paragraph per cell.",
+              "validate-intent"
+            );
+          const texts = [];
+          const opaque = protectedEquationNodes(doc.root);
+          const visit = (item) => {
+            if (opaque.has(item) || item.name.namespace === s.a && ["fld", "br"].includes(item.name.localName))
+              throw new OfficeError(
+                "unsupported-edit",
+                "Structured table slots require ordinary text runs.",
+                "validate-intent"
+              );
+            if (item.name.namespace === s.a && item.name.localName === "t") texts.push(item);
+            else item.children.forEach(visit);
+          };
+          if (body) visit(body);
+          if (!texts.length)
+            throw new OfficeError(
+              "unsupported-edit",
+              "Table slots require an existing text run in each cell.",
+              "validate-intent"
+            );
+          texts.forEach((item, i) => values.set(item, i === 0 ? binding.table[r][c] : ""));
+        })
+      );
+      edits.set(record.part, { document: doc, values });
+      ownedTables.add(JSON.stringify([record.part, record.id]));
+    } else if (node.name.localName === "pic" && node.name.namespace === s.p) {
+      const binding = resolve(slide, "image", named[0].name, record.location);
+      if (binding.kind !== "image") invalid();
+      const fill = child(node, "blipFill");
+      const blip = fill && child(fill, "blip", s.a);
+      if (!blip || !blip.attributes.some(
+        (attribute) => attribute.name.namespace === s.r && attribute.name.localName === "embed"
+      ))
+        throw new OfficeError(
+          "unsupported-edit",
+          "Image slots require an embedded picture.",
+          "validate-intent"
+        );
+      if (blip.children.length || blip.attributes.some((attribute) => attribute.name.localName === "link"))
+        throw new OfficeError(
+          "unsupported-edit",
+          "Image slots require a single embedded source without extensions.",
+          "validate-intent"
+        );
+      const embed = blip.attributes.find(
+        (attribute) => attribute.name.namespace === s.r && attribute.name.localName === "embed"
+      ).value;
+      const relation = s.index.inventory.relationships.find(
+        (relation2) => relation2.owner === record.part && relation2.id === embed
+      );
+      if (!relation || relation.external || !relation.type.endsWith("/image") || !relation.targetPart)
+        throw new OfficeError(
+          "unsupported-edit",
+          "Image slot relationship is not an embedded image.",
+          "validate-intent"
+        );
+      s.doc(relPart(record.part));
+      images.push({ part: record.part, id: record.id, binding });
+    }
+  }
+  let replacementBudget = 0;
+  const bodies = await readTextBodies(s.source, { scope: "slides" }, context);
+  for (const body of bodies) {
+    context.signal?.throwIfAborted();
+    const slide = targetParts.get(body.part);
+    if (slide === void 0) continue;
+    if (ownedTables.has(JSON.stringify([body.part, body.segment.location.objectId]))) continue;
+    let edit = edits.get(body.part);
+    if (!edit) {
+      edit = { document: body.document, values: /* @__PURE__ */ new Map() };
+      edits.set(body.part, edit);
+    }
+    const opaque = protectedEquationNodes(body.document.root);
+    for (const [paragraphIndex, paragraph] of body.paragraphs.entries()) {
+      let range = [];
+      const runText = /* @__PURE__ */ new Map();
+      const flush = () => {
+        const original = range.map((node) => runText.get(node)).join("");
+        const replacements = markers(original).map((marker) => {
+          const binding = resolve(slide, "text", marker.name, body.segment.location);
+          if (binding.kind !== "text") invalid();
+          return { ...marker, value: binding.text };
+        });
+        let projected = utf8Size(original);
+        for (const replacement of replacements) {
+          const size = utf8Size(replacement.value);
+          projected += size - utf8Size(original.slice(replacement.start, replacement.end));
+          replacementBudget += size;
+          if (!Number.isSafeInteger(projected) || projected > context.xmlLimits.maxBytes || replacementBudget > context.archiveLimits.maxTotalBytes)
+            throw new OfficeError(
+              "resource-limit",
+              "Expanded binding text exceeds the output budget.",
+              "validate-intent"
+            );
+        }
+        let offset = 0;
+        for (const node of range) {
+          const before = runText.get(node);
+          const end = offset + before.length;
+          let cursor = offset;
+          let value = "";
+          for (const replacement of replacements) {
+            if (replacement.end <= offset || replacement.start >= end) continue;
+            value += original.slice(cursor, Math.max(offset, replacement.start));
+            if (replacement.start >= offset) value += replacement.value;
+            cursor = Math.min(end, replacement.end);
+          }
+          value += original.slice(cursor, end);
+          if (value !== before) {
+            const path = [];
+            let found = false;
+            const locate = (item, steps) => {
+              if (item === node) {
+                path.push(...steps);
+                found = true;
+                return;
+              }
+              item.children.forEach((next, i) => {
+                if (!found) locate(next, [...steps, i]);
+              });
+            };
+            locate(body.document.root, []);
+            let target = edit.document.root;
+            for (const index of path) target = target.children[index];
+            edit.values.set(target, value);
+          }
+          offset = end;
+        }
+        range = [];
+      };
+      let previous = -1;
+      let inlineIndex = 0;
+      for (const inline of paragraph.inlines) {
+        const segment = body.segment.paragraphs[paragraphIndex].inlines[inlineIndex];
+        if (inline.name.namespace === s.a && ["r", "fld", "br"].includes(inline.name.localName))
+          inlineIndex++;
+        const position = paragraph.node.children.indexOf(inline);
+        if (position !== previous + 1) flush();
+        previous = position;
+        if (inline.name.namespace !== s.a || inline.name.localName !== "r" || opaque.has(inline)) {
+          flush();
+          continue;
+        }
+        const nodes = inline.children.filter(
+          (node) => node.name.namespace === s.a && node.name.localName === "t"
+        );
+        if (nodes.length !== 1 || nodes[0].children.length)
+          throw new OfficeError(
+            "unsupported-edit",
+            "Template text requires simple run text.",
+            "validate-intent"
+          );
+        runText.set(nodes[0], segment?.kind === "run" ? segment.text : "");
+        range.push(nodes[0]);
+      }
+      flush();
+    }
+  }
+  for (const binding of snapshots)
+    if (!counts.has(binding))
+      throw new OfficeError(
+        "missing-binding",
+        "A binding has no matching template slot.",
+        "validate-intent"
+      );
+  for (const [part, edit] of edits) {
+    context.signal?.throwIfAborted();
+    const paths = [];
+    const visit = (node, path) => {
+      const value = edit.values.get(node);
+      if (value !== void 0) paths.push({ path, value });
+      node.children.forEach((item, i) => visit(item, [...path, i]));
+    };
+    visit(edit.document.root, []);
+    let doc = edit.document;
+    for (const { path, value } of paths) {
+      let node = doc.root;
+      for (const i of path) node = node.children[i];
+      doc = doc.setText(node, value);
+    }
+    if (paths.length) s.save(part, doc);
+  }
+  for (const image of images) {
+    context.signal?.throwIfAborted();
+    const bytes = new Uint8Array(image.binding.image.bytes);
+    const metadata = admitImage(bytes, image.binding.image.contentType);
+    let n = 1;
+    while ([...s.reader.names, ...s.changes.keys()].some(
+      (name) => name.toLowerCase() === `/ppt/media/binding${n}.${metadata.extension}`
+    ))
+      n++;
+    const media = `/ppt/media/binding${n}.${metadata.extension}`;
+    const relations = s.doc(relPart(image.part));
+    const id = nextRel(relations);
+    s.save(
+      relPart(image.part),
+      relations.spliceChildren(relations.root, relations.root.children.length, 0, [
+        `<Relationship xmlns="${relations.root.name.namespace}" Id="${id}" Type="${s.r}/image" Target="${escape(relativePartReference(media, image.part.slice(0, image.part.lastIndexOf("/"))))}"/>`
+      ])
+    );
+    const types = s.doc("/[Content_Types].xml");
+    s.save(
+      "/[Content_Types].xml",
+      types.spliceChildren(types.root, types.root.children.length, 0, [
+        `<Override xmlns="${types.root.name.namespace}" PartName="${media}" ContentType="${escape(image.binding.image.contentType)}"/>`
+      ])
+    );
+    s.changes.set(media, bytes);
+    const doc = s.doc(image.part);
+    const picture = nodeFor(doc.root, image.id);
+    const blip = child(child(picture, "blipFill"), "blip", s.a);
+    s.save(
+      image.part,
+      doc.merge(blip, { attributes: [{ namespace: s.r, localName: "embed", value: id }] })
+    );
+  }
+  return {
+    bytes: (await s.finish(s.main, [...targetParts.values()])).bytes,
+    affected: [...counts.values()].reduce((a, b) => a + b, 0),
+    locations
+  };
+}
+
+export {
+  validateTemplateBindings,
+  applyTemplateBindings
+};

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

@@ -0,0 +1,144 @@
+import {
+  readXmlCoordinate,
+  readXmlInteger
+} from "./chunk-3W6PTHHB.js";
+import {
+  Length
+} from "./chunk-I6AMDG2T.js";
+import {
+  attr,
+  child
+} from "./chunk-RAXJVM4U.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/shape-transforms.ts
+function invalid() {
+  throw new OfficeError(
+    "unsupported-edit",
+    "Explicit nonsingular geometry is required for coordinate projection.",
+    "validate-intent"
+  );
+}
+function transform(node) {
+  const a = node.name.namespace === "http://purl.oclc.org/ooxml/presentationml/main" ? "http://purl.oclc.org/ooxml/drawingml/main" : "http://schemas.openxmlformats.org/drawingml/2006/main";
+  const owner = node.name.localName === "graphicFrame" ? node : child(node, node.name.localName === "grpSp" ? "grpSpPr" : "spPr");
+  const xfrm = owner && child(owner, "xfrm", node.name.localName === "graphicFrame" ? node.name.namespace : a);
+  if (!xfrm) return null;
+  const integer = (name, key) => {
+    const pair = child(xfrm, name, a), value = pair && attr(pair, key);
+    if (value === void 0) return null;
+    try {
+      return name === "off" || name === "chOff" ? readXmlCoordinate(value) : readXmlInteger(value);
+    } catch {
+      invalid();
+    }
+  };
+  const x = integer("off", "x"), y = integer("off", "y"), w = integer("ext", "cx"), h = integer("ext", "cy");
+  if (x === null || y === null || w === null || h === null) return null;
+  if (w < 0 || h < 0) invalid();
+  const rawRotation = attr(xfrm, "rot");
+  let rotation = 0;
+  if (rawRotation !== void 0) {
+    try {
+      rotation = readXmlInteger(rawRotation);
+    } catch {
+      invalid();
+    }
+  }
+  const flip = (key) => {
+    const value = attr(xfrm, key);
+    if (value !== void 0 && !["true", "false", "1", "0"].includes(value)) invalid();
+    return value === "true" || value === "1" ? -1 : 1;
+  };
+  const angle = (rotation % 216e5 + 216e5) % 216e5;
+  const quarter = angle / 54e5;
+  const cos = Number.isInteger(quarter) ? [1, 0, -1, 0][quarter] : Math.cos(angle / 6e4 * Math.PI / 180);
+  const sin = Number.isInteger(quarter) ? [0, 1, 0, -1][quarter] : Math.sin(angle / 6e4 * Math.PI / 180);
+  const fx = flip("flipH"), fy = flip("flipV");
+  return {
+    x,
+    y,
+    w,
+    h,
+    integer,
+    map(px, py) {
+      const dx = (px - x - w / 2) * fx, dy = (py - y - h / 2) * fy;
+      return { x: x + w / 2 + dx * cos - dy * sin, y: y + h / 2 + dx * sin + dy * cos };
+    }
+  };
+}
+function readShapeGeometry(root, node) {
+  const projection = prepareProjection(root, node);
+  if (!projection) return null;
+  const { own, groups } = projection;
+  return {
+    coordinateSystem: groups.length ? "group" : "slide",
+    unit: "emu",
+    groupPath: groups.map((group) => {
+      const nv = child(group, "nvGrpSpPr"), cn = nv && child(nv, "cNvPr");
+      return cn ? attr(cn, "id") ?? null : null;
+    }),
+    corners: projection.project([
+      { x: own.x, y: own.y },
+      { x: own.x + own.w, y: own.y },
+      { x: own.x + own.w, y: own.y + own.h },
+      { x: own.x, y: own.y + own.h }
+    ])
+  };
+}
+function projectShapePoint(root, node, x, y) {
+  const projection = prepareProjection(root, node);
+  return projection?.project([{ x, y }])[0] ?? null;
+}
+function prepareProjection(root, node) {
+  const pending = [{ node: root, groups: [] }];
+  let groups;
+  while (pending.length) {
+    const current = pending.pop();
+    if (current.node === node) {
+      groups = current.groups;
+      break;
+    }
+    const ancestors = current.node.name.namespace === node.name.namespace && current.node.name.localName === "grpSp" ? [...current.groups, current.node] : current.groups;
+    for (const next of current.node.children) pending.push({ node: next, groups: ancestors });
+  }
+  if (!groups)
+    throw new OfficeError(
+      "invalid-selection",
+      "Shape does not belong to the supplied drawing.",
+      "select"
+    );
+  const own = transform(node);
+  if (!own) return null;
+  const parents = [];
+  for (const group of [...groups].reverse()) {
+    const parent = transform(group);
+    if (!parent) return null;
+    const cx = parent.integer("chOff", "x"), cy = parent.integer("chOff", "y"), cw = parent.integer("chExt", "cx"), ch = parent.integer("chExt", "cy");
+    if (cx === null || cy === null || cw === null || ch === null) return null;
+    if (cw <= 0 || ch <= 0 || parent.w <= 0 || parent.h <= 0) invalid();
+    parents.push({ parent, cx, cy, cw, ch });
+  }
+  return {
+    own,
+    groups,
+    project(points) {
+      let projected = points.map((point) => own.map(point.x, point.y));
+      for (const { parent, cx, cy, cw, ch } of parents)
+        projected = projected.map(
+          (point) => parent.map(
+            parent.x + (point.x - cx) * parent.w / cw,
+            parent.y + (point.y - cy) * parent.h / ch
+          )
+        );
+      return projected.map((point) => ({ x: new Length(point.x).emu, y: new Length(point.y).emu }));
+    }
+  };
+}
+
+export {
+  readShapeGeometry,
+  projectShapePoint
+};