@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,62 @@
+import {
+  admitImage
+} from "./chunk-45BW6MGM.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/image-value.ts
+import { sha1 } from "@noble/hashes/legacy.js";
+function detectImageContentType(bytes) {
+  if (!(bytes instanceof Uint8Array))
+    throw new OfficeError("invalid-type", "Image bytes must be a Uint8Array.", "admit");
+  const prefix = (values) => values.every((value, index) => bytes[index] === value);
+  if (prefix([137, 80, 78, 71, 13, 10, 26, 10])) return "image/png";
+  if (prefix([255, 216])) return "image/jpeg";
+  if (prefix([71, 73, 70, 56])) return "image/gif";
+  if (prefix([66, 77])) return "image/bmp";
+  if (prefix([73, 73, 42, 0]) || prefix([77, 77, 0, 42])) return "image/tiff";
+  if (prefix([215, 205, 198, 154])) return "image/x-wmf";
+  throw new OfficeError("unsupported-profile", "Image format is not recognized.", "admit");
+}
+var Image = class {
+  #bytes;
+  #metadata;
+  content_type;
+  filename;
+  constructor(blob, filename = null, contentType) {
+    if (!(blob instanceof Uint8Array))
+      throw new OfficeError("invalid-type", "Image bytes must be a Uint8Array.", "admit");
+    if (filename !== null && typeof filename !== "string")
+      throw new OfficeError("invalid-type", "Image filename must be a string or null.", "admit");
+    this.content_type = contentType ?? detectImageContentType(blob);
+    this.#metadata = admitImage(blob, this.content_type);
+    this.#bytes = Uint8Array.from(blob);
+    this.filename = filename;
+    Object.freeze(this);
+  }
+  get blob() {
+    return this.#bytes.slice();
+  }
+  get dpi() {
+    return Object.freeze([this.#metadata.dpiX, this.#metadata.dpiY]);
+  }
+  get ext() {
+    return this.#metadata.extension;
+  }
+  /** Compatibility metadata; package identity uses SHA-256. */
+  get sha1() {
+    return Array.from(sha1(this.#bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+  get size() {
+    const { pixelWidth, pixelHeight } = this.#metadata;
+    if (pixelWidth === null || pixelHeight === null)
+      throw new OfficeError("invalid-value", "Image pixel dimensions are unavailable.", "admit");
+    return Object.freeze([pixelWidth, pixelHeight]);
+  }
+};
+
+export {
+  detectImageContentType,
+  Image
+};

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

@@ -0,0 +1,244 @@
+import {
+  validateColor
+} from "./chunk-LHRXDH45.js";
+import {
+  attr,
+  child,
+  escape,
+  fields,
+  invalid,
+  loadShared,
+  nextRel,
+  relPart,
+  required,
+  unique
+} from "./chunk-RAXJVM4U.js";
+import {
+  readBinary
+} from "./chunk-TL3KDYEM.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  relativePartReference
+} from "./chunk-XXFHTGV2.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/backgrounds.ts
+var fills = ["solidFill", "gradFill", "blipFill", "noFill", "pattFill", "grpFill"];
+function owners(s, scope) {
+  return scope === "slides" ? s.index.inventory.slides.map((slide) => slide.part) : scope === "masters" ? s.index.inventory.masters : s.index.inventory.layouts;
+}
+function affected(s, part) {
+  return s.index.inventory.slides.filter((slide) => [slide.part, slide.layout, slide.master].includes(part)).map((slide) => slide.position);
+}
+async function readBackgrounds(input, options, context) {
+  fields(options, ["scope"], ["slides", "layouts", "masters"]);
+  const s = await loadShared(input, context, false);
+  return owners(s, options.scope).map((part) => {
+    const bg = child(required(s.doc(part).root, "cSld"), "bg"), pr = bg && child(bg, "bgPr"), ref = bg && child(bg, "bgRef"), fill = pr?.children.find((n) => n.name.namespace === s.a && fills.includes(n.name.localName));
+    const rgb = (n) => {
+      const c = n && child(n, "srgbClr", s.a);
+      return c ? attr(c, "val") ?? null : null;
+    };
+    const stopList = fill && child(fill, "gsLst", s.a), line = fill && child(fill, "lin", s.a), blip = fill && child(fill, "blip", s.a);
+    const rid = blip?.attributes.find(
+      (a) => a.name.namespace === s.r && a.name.localName === "embed"
+    )?.value;
+    return {
+      part,
+      kind: ref ? "style-reference" : fill ? { solidFill: "solid", gradFill: "gradient", blipFill: "picture", noFill: "none" }[fill.name.localName] ?? "unsupported" : bg ? "unsupported" : "inherit",
+      color: rgb(fill),
+      stops: (stopList?.children ?? []).map((n) => {
+        const color = rgb(n) ?? "", c = child(n, "srgbClr", s.a), alpha = c && child(c, "alpha", s.a);
+        return {
+          position: Number(attr(n, "pos")) / 1e5,
+          color,
+          ...alpha ? { opacity: Number(attr(alpha, "val")) / 1e5 } : {}
+        };
+      }),
+      angle: line ? Number(attr(line, "ang")) / 6e4 : null,
+      imagePart: rid ? s.index.inventory.relationships.find((e) => e.owner === part && e.id === rid)?.targetPart ?? null : null,
+      styleIndex: ref ? Number(attr(ref, "idx")) : null,
+      styleColor: rgb(ref),
+      affectedSlides: affected(s, part)
+    };
+  });
+}
+async function mutateBackground(input, options, context) {
+  fields(
+    options,
+    ["scope", "part", "kind", "color", "stops", "angle", "image", "styleIndex", "styleColor"],
+    ["slides", "layouts", "masters"]
+  );
+  const payload = {
+    solid: ["color"],
+    gradient: ["stops", "angle"],
+    picture: ["image"],
+    inherit: [],
+    "style-reference": ["styleIndex", "styleColor"]
+  };
+  if (!Object.hasOwn(payload, options.kind)) invalid("Unknown background kind.");
+  const allowed = payload[options.kind];
+  if (!allowed || ["color", "stops", "angle", "image", "styleIndex", "styleColor"].some(
+    (k) => options[k] !== void 0 && !allowed.includes(k)
+  ))
+    invalid("Background payload does not match its kind.");
+  if (options.kind === "solid") validateColor(options.color);
+  if (options.kind === "picture" && options.image === void 0)
+    invalid("Picture background requires image bytes.");
+  if (options.kind === "style-reference") {
+    validateColor(options.styleColor);
+    if (!Number.isSafeInteger(options.styleIndex) || options.styleIndex < 1)
+      invalid("Invalid background style index.");
+  }
+  if (options.kind === "gradient") {
+    if (!Array.isArray(options.stops) || options.stops.length < 2 || options.stops.length > context.xmlLimits.maxNodes)
+      invalid("Gradient requires a bounded list of at least two stops.");
+    let position = -1;
+    for (const stop of options.stops) {
+      if (!stop || Object.keys(stop).some((k) => !["position", "color", "opacity"].includes(k)))
+        invalid("Invalid gradient stop.");
+      validateColor(stop.color);
+      if (!Number.isFinite(stop.position) || stop.position < 0 || stop.position > 1 || stop.position < position || stop.opacity !== void 0 && (!Number.isFinite(stop.opacity) || stop.opacity < 0 || stop.opacity > 1))
+        invalid("Invalid gradient stop.");
+      position = stop.position;
+    }
+    if (options.angle !== void 0 && (!Number.isFinite(options.angle) || Math.abs(options.angle) > 36e4))
+      invalid("Invalid gradient angle.");
+  }
+  const s = await loadShared(input, context), part = unique(
+    owners(s, options.scope).filter((p) => p === options.part),
+    "Select one background owner."
+  );
+  let xml = s.doc(part);
+  const common = required(xml.root, "cSld"), bg = child(common, "bg"), pr = bg && child(bg, "bgPr"), ref = bg && child(bg, "bgRef");
+  if (pr && ref) invalid("Ambiguous background definition.");
+  if (ref && (ref.attributes.some((a) => a.name.namespace !== "" || a.name.localName !== "idx") || ref.children.length !== 1 || ref.children.some(
+    (n) => n.name.namespace !== s.a || n.name.localName !== "srgbClr" || n.children.length || n.attributes.some((a) => a.name.namespace !== "" || a.name.localName !== "val")
+  )))
+    throw new OfficeError(
+      "unsupported-edit",
+      "Unsupported style reference payload cannot be discarded.",
+      "validate-intent"
+    );
+  if (options.kind === "inherit" || options.kind === "style-reference") {
+    const safe = (n) => n.name.namespace === s.a && (fills.includes(n.name.localName) || n.name.localName === "effectLst" && n.children.length === 0 && n.attributes.length === 0);
+    if (bg && (bg.attributes.length || bg.children.some((n) => n !== pr && n !== ref) || pr && (pr.attributes.length || pr.children.some((n) => !safe(n))) || ref && ref.children.some((n) => n.name.namespace !== s.a)))
+      throw new OfficeError(
+        "unsupported-edit",
+        "Background effects or extensions cannot be discarded.",
+        "validate-intent"
+      );
+  }
+  if (options.kind === "inherit") {
+    if (bg) xml = xml.spliceChildren(common, common.children.indexOf(bg), 1, []);
+    s.save(part, xml);
+    return s.finish(part, affected(s, part));
+  }
+  let fill = "";
+  if (options.kind === "solid")
+    fill = `<a:solidFill xmlns:a="${s.a}"><a:srgbClr val="${options.color}"/></a:solidFill>`;
+  if (options.kind === "gradient")
+    fill = `<a:gradFill xmlns:a="${s.a}"><a:gsLst>${options.stops.map((stop) => `<a:gs pos="${Math.round(stop.position * 1e5)}"><a:srgbClr val="${stop.color}">${stop.opacity === void 0 ? "" : `<a:alpha val="${Math.round(stop.opacity * 1e5)}"/>`}</a:srgbClr></a:gs>`).join("")}</a:gsLst><a:lin ang="${Math.round(((options.angle ?? 0) % 360 + 360) % 360 * 6e4)}" scaled="1"/></a:gradFill>`;
+  if (options.kind === "picture") {
+    const bytes = await readBinary(options.image, context);
+    const png = bytes.length >= 24 && [137, 80, 78, 71, 13, 10, 26, 10].every((v, i2) => bytes[i2] === v) && [73, 72, 68, 82].every((v, i2) => bytes[i2 + 12] === v);
+    const jpeg = bytes.length >= 4 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255;
+    if (!png && !jpeg)
+      throw new OfficeError(
+        "unsupported-edit",
+        "Only PNG and JPEG picture backgrounds are supported.",
+        "validate-intent"
+      );
+    const ext = png ? "png" : "jpg";
+    let i = 1;
+    while (s.reader.names.some((p) => p.toLowerCase() === `/ppt/media/image${i}.${ext}`)) i++;
+    const imagePart = `/ppt/media/image${i}.${ext}`;
+    s.changes.set(imagePart, bytes);
+    const relationPart = relPart(part), rels = s.reader.has(relationPart) ? s.doc(relationPart) : parseXmlPart(
+      new TextEncoder().encode(
+        '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"/>'
+      ),
+      context.xmlLimits
+    ), rid = nextRel(rels);
+    s.save(
+      relationPart,
+      rels.spliceChildren(rels.root, rels.root.children.length, 0, [
+        `<Relationship xmlns="${rels.root.name.namespace}" Id="${rid}" Type="${s.r}/image" Target="${escape(relativePartReference(imagePart, part.slice(0, 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="${imagePart}" ContentType="image/${png ? "png" : "jpeg"}"/>`
+      ])
+    );
+    fill = `<a:blipFill xmlns:a="${s.a}" xmlns:r="${s.r}"><a:blip r:embed="${rid}"/><a:stretch><a:fillRect/></a:stretch></a:blipFill>`;
+  }
+  if (options.kind === "style-reference") {
+    const selectedSlide = s.index.inventory.slides.find((slide) => slide.part === part);
+    const layout = selectedSlide?.layout;
+    const master = options.scope === "masters" ? part : s.index.inventory.relationships.find(
+      (e) => e.owner === (layout ?? part) && e.type === `${s.r}/slideMaster` && !e.external
+    )?.targetPart;
+    const theme = s.index.inventory.relationships.find(
+      (e) => e.owner === master && e.type === `${s.r}/theme` && !e.external
+    )?.targetPart;
+    const lineage = [part, layout, master].filter(
+      (x, i, all) => !!x && all.indexOf(x) === i
+    );
+    const overrides = lineage.flatMap(
+      (owner) => s.index.inventory.relationships.filter((e) => e.owner === owner && e.type === `${s.r}/themeOverride` && !e.external).map((e) => e.targetPart)
+    );
+    const fmt = [...overrides, ...theme ? [theme] : []].map((p) => {
+      const root = s.doc(p).root;
+      return child(
+        root.name.localName === "themeOverride" ? root : required(root, "themeElements"),
+        "fmtScheme",
+        s.a
+      );
+    }).find((n) => n !== void 0);
+    const index = options.styleIndex, list = fmt && child(fmt, index >= 1001 ? "bgFillStyleLst" : "fillStyleLst", s.a), offset = index >= 1001 ? index - 1001 : index - 1;
+    if (!list || offset < 0 || offset >= list.children.length)
+      invalid("Background style index is outside the effective theme style list.");
+    const target = list.children[offset];
+    if (target.name.namespace !== s.a || !fills.includes(target.name.localName))
+      throw new OfficeError(
+        "unsupported-edit",
+        "Selected theme style is not a supported fill.",
+        "validate-intent"
+      );
+    const reference = `<p:bgRef xmlns:p="${s.p}" xmlns:a="${s.a}" idx="${index}"><a:srgbClr val="${options.styleColor}"/></p:bgRef>`;
+    if (bg) xml = xml.spliceChildren(bg, 0, bg.children.length, [reference]);
+    else xml = xml.spliceChildren(common, 0, 0, [`<p:bg xmlns:p="${s.p}">${reference}</p:bg>`]);
+  } else if (pr) {
+    const existing = pr.children.filter(
+      (n) => n.name.namespace === s.a && fills.includes(n.name.localName)
+    );
+    if (existing.length > 1) invalid("Ambiguous background fill.");
+    xml = xml.spliceChildren(
+      pr,
+      existing[0] ? pr.children.indexOf(existing[0]) : 0,
+      existing.length,
+      [fill]
+    );
+  } else if (bg) {
+    xml = xml.spliceChildren(bg, ref ? bg.children.indexOf(ref) : 0, ref ? 1 : 0, [
+      `<p:bgPr xmlns:p="${s.p}" xmlns:a="${s.a}">${fill}<a:effectLst/></p:bgPr>`
+    ]);
+  } else
+    xml = xml.spliceChildren(common, 0, 0, [
+      `<p:bg xmlns:p="${s.p}" xmlns:a="${s.a}"><p:bgPr>${fill}<a:effectLst/></p:bgPr></p:bg>`
+    ]);
+  s.save(part, xml);
+  return s.finish(part, affected(s, part));
+}
+
+export {
+  readBackgrounds,
+  mutateBackground
+};

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

@@ -0,0 +1,85 @@
+import {
+  callableConstructor
+} from "./chunk-HR2Y6YEP.js";
+import {
+  TypeError,
+  ValueError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/length.ts
+var LengthValue = class {
+  emu;
+  constructor(emu) {
+    if (typeof emu !== "number") throw new TypeError("Length must be numeric.");
+    if (!Number.isFinite(emu) || Math.abs(emu) > Number.MAX_SAFE_INTEGER)
+      throw new ValueError("Length must be finite and within the safe integer range.");
+    const rounded = Math.sign(emu) * Math.round(Math.abs(emu));
+    if (!Number.isSafeInteger(rounded)) throw new ValueError("Length exceeds safe integer range.");
+    this.emu = rounded === 0 ? 0 : rounded;
+    Object.freeze(this);
+  }
+  get inches() {
+    return this.emu / 914400;
+  }
+  get cm() {
+    return this.emu / 36e4;
+  }
+  get mm() {
+    return this.emu / 36e3;
+  }
+  get pt() {
+    return this.emu / 12700;
+  }
+  get centipoints() {
+    return Math.floor(this.emu / 127);
+  }
+};
+var Length = callableConstructor(LengthValue);
+var EmuValue = class extends Length {
+};
+var InchesValue = class extends Length {
+  constructor(value) {
+    if (typeof value !== "number") throw new TypeError("Length must be numeric.");
+    super(value * 914400);
+  }
+};
+var CmValue = class extends Length {
+  constructor(value) {
+    if (typeof value !== "number") throw new TypeError("Length must be numeric.");
+    super(value * 36e4);
+  }
+};
+var MmValue = class extends Length {
+  constructor(value) {
+    if (typeof value !== "number") throw new TypeError("Length must be numeric.");
+    super(value * 36e3);
+  }
+};
+var PtValue = class extends Length {
+  constructor(value) {
+    if (typeof value !== "number") throw new TypeError("Length must be numeric.");
+    super(value * 12700);
+  }
+};
+var CentipointsValue = class extends Length {
+  constructor(value) {
+    if (typeof value !== "number") throw new TypeError("Length must be numeric.");
+    super(value * 127);
+  }
+};
+var Emu = callableConstructor(EmuValue);
+var Inches = callableConstructor(InchesValue);
+var Cm = callableConstructor(CmValue);
+var Mm = callableConstructor(MmValue);
+var Pt = callableConstructor(PtValue);
+var Centipoints = callableConstructor(CentipointsValue);
+
+export {
+  Length,
+  Emu,
+  Inches,
+  Cm,
+  Mm,
+  Pt,
+  Centipoints
+};