@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,357 @@
+import {
+  themeColorSlots,
+  validateColor
+} from "./chunk-LHRXDH45.js";
+import {
+  readXmlPercentage
+} from "./chunk-3W6PTHHB.js";
+import {
+  callableConstructor
+} from "./chunk-HR2Y6YEP.js";
+import {
+  IndexError,
+  OfficeError,
+  PropertyAccessError,
+  TypeError,
+  ValueError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/enum-definition.ts
+function defineEnum(values) {
+  const entries = Object.entries(values).filter(([, value]) => typeof value === "number").map(([name, value]) => Object.freeze({ name, value }));
+  const definition = Object.assign(values, {
+    metadata(value) {
+      const entry = entries.find((item) => item.value === value);
+      if (!entry) throw new ValueError("Unknown enumeration value.");
+      return entry;
+    }
+  });
+  for (const name of Object.keys(definition)) {
+    if (typeof definition[name] === "function")
+      Object.defineProperty(definition, name, { enumerable: false });
+  }
+  return Object.freeze(definition);
+}
+function defineXmlEnum(values, tokens) {
+  const entries = Object.entries(values).filter(([, value]) => typeof value === "number").map(
+    ([name, value]) => Object.freeze({ name, value, xml_value: tokens[value] ?? null })
+  );
+  function invalid2() {
+    throw new ValueError("Unsupported enumeration conversion.");
+  }
+  const definition = Object.assign(values, {
+    metadata(value) {
+      return entries.find((item) => item.value === value) ?? invalid2();
+    },
+    from_xml(xml_value) {
+      return entries.find((item) => item.xml_value !== null && item.xml_value === xml_value)?.value ?? invalid2();
+    },
+    to_xml(value) {
+      return entries.find((item) => item.value === value)?.xml_value ?? invalid2();
+    },
+    validate(value) {
+      if (!entries.some((item) => item.value === value && item.xml_value !== null)) invalid2();
+    }
+  });
+  for (const name of Object.keys(definition)) {
+    if (typeof definition[name] === "function")
+      Object.defineProperty(definition, name, { enumerable: false });
+  }
+  return Object.freeze(definition);
+}
+
+// packages/safe-bash-presentation-engine/src/color-enums.ts
+var MSO_COLOR_TYPEValues = /* @__PURE__ */ ((MSO_COLOR_TYPEValues2) => {
+  MSO_COLOR_TYPEValues2[MSO_COLOR_TYPEValues2["RGB"] = 1] = "RGB";
+  MSO_COLOR_TYPEValues2[MSO_COLOR_TYPEValues2["SCHEME"] = 2] = "SCHEME";
+  MSO_COLOR_TYPEValues2[MSO_COLOR_TYPEValues2["HSL"] = 101] = "HSL";
+  MSO_COLOR_TYPEValues2[MSO_COLOR_TYPEValues2["PRESET"] = 102] = "PRESET";
+  MSO_COLOR_TYPEValues2[MSO_COLOR_TYPEValues2["SCRGB"] = 103] = "SCRGB";
+  MSO_COLOR_TYPEValues2[MSO_COLOR_TYPEValues2["SYSTEM"] = 104] = "SYSTEM";
+  return MSO_COLOR_TYPEValues2;
+})(MSO_COLOR_TYPEValues || {});
+var MSO_COLOR_TYPE = defineEnum(MSO_COLOR_TYPEValues);
+var MSO_THEME_COLOR_INDEXValues = {
+  NOT_THEME_COLOR: 0,
+  ACCENT_1: 5,
+  ACCENT_2: 6,
+  ACCENT_3: 7,
+  ACCENT_4: 8,
+  ACCENT_5: 9,
+  ACCENT_6: 10,
+  BACKGROUND_1: 14,
+  BACKGROUND_2: 16,
+  DARK_1: 1,
+  DARK_2: 3,
+  FOLLOWED_HYPERLINK: 12,
+  HYPERLINK: 11,
+  LIGHT_1: 2,
+  LIGHT_2: 4,
+  TEXT_1: 13,
+  TEXT_2: 15,
+  MIXED: -2
+};
+var MSO_THEME_COLOR_INDEX = defineXmlEnum(MSO_THEME_COLOR_INDEXValues, {
+  "0": null,
+  "1": "dk1",
+  "2": "lt1",
+  "3": "dk2",
+  "4": "lt2",
+  "5": "accent1",
+  "6": "accent2",
+  "7": "accent3",
+  "8": "accent4",
+  "9": "accent5",
+  "10": "accent6",
+  "11": "hlink",
+  "12": "folHlink",
+  "13": "tx1",
+  "14": "bg1",
+  "15": "tx2",
+  "16": "bg2",
+  "-2": null
+});
+
+// packages/safe-bash-presentation-engine/src/text-run-color.ts
+var kinds = {
+  hslClr: "HSL",
+  prstClr: "PRESET",
+  schemeClr: "SCHEME",
+  scrgbClr: "SCRGB",
+  srgbClr: "RGB",
+  sysClr: "SYSTEM"
+};
+var slots = [...themeColorSlots, "tx1", "tx2", "bg1", "bg2", "phClr"];
+function invalid(message) {
+  throw new OfficeError("invalid-value", message, "usage");
+}
+function brightness(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < -1 || value > 1)
+    invalid("Brightness must be between -1 and 1.");
+}
+function validateRunColor(value) {
+  if (typeof value === "string") {
+    validateColor(value);
+    return;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    invalid("Color must be hexadecimal RGB or an explicit color object.");
+  const data = value;
+  const key = Object.hasOwn(data, "rgb") ? "rgb" : "theme";
+  if (Object.keys(data).some((k) => k !== key && k !== "brightness") || !Object.hasOwn(data, key))
+    invalid("Color requires exactly one RGB or theme value.");
+  if (key === "rgb") validateColor(data.rgb);
+  else if (typeof data.theme !== "string" || !slots.includes(data.theme))
+    invalid("Unknown theme color slot.");
+  if (data.brightness !== void 0) brightness(data.brightness);
+}
+function colorBrightnessMerge(value, namespace) {
+  brightness(value);
+  const name = (localName) => ({ namespace, localName });
+  const entries = value > 0 ? [
+    ["lumMod", Math.round((1 - value) * 1e5)],
+    ["lumOff", Math.round(value * 1e5)]
+  ] : value < 0 ? [["lumMod", Math.round((1 + value) * 1e5)]] : [];
+  return {
+    children: {
+      sequence: [name("lumMod"), name("lumOff")],
+      remove: ["lumMod", "lumOff"].filter((k) => !entries.some(([local]) => local === k)).map(name),
+      upsert: entries.map(([localName, amount]) => ({
+        name: name(localName),
+        merge: { attributes: [{ namespace: "", localName: "val", value: String(amount) }] }
+      }))
+    }
+  };
+}
+function colorMerge(value, namespace) {
+  validateRunColor(value);
+  const rgb = typeof value === "string" ? value : "rgb" in value ? value.rgb : void 0;
+  const kind = rgb === void 0 ? "schemeClr" : "srgbClr";
+  const token = rgb?.toUpperCase() ?? value.theme;
+  const adjustment = typeof value === "string" ? void 0 : value.brightness;
+  const merge = {
+    attributes: [{ namespace: "", localName: "val", value: token }],
+    ...adjustment === void 0 ? {} : colorBrightnessMerge(adjustment, namespace)
+  };
+  return {
+    children: {
+      sequence: Object.keys(kinds).map((localName) => ({ namespace, localName })),
+      remove: Object.keys(kinds).filter((localName) => localName !== kind).map((localName) => ({ namespace, localName })),
+      upsert: [{ name: { namespace, localName: kind }, merge }]
+    }
+  };
+}
+function readRunColor(parent) {
+  const nodes = parent.children.filter(
+    (n) => n.name.namespace === parent.name.namespace && Object.hasOwn(kinds, n.name.localName)
+  );
+  if (nodes.length > 1) throw new OfficeError("invalid-xml", "Multiple color choices.", "index");
+  const node = nodes[0];
+  if (!node) return null;
+  const attr = (n, key) => n.attributes.find((a) => a.name.namespace === "" && a.name.localName === key)?.value;
+  const transform = (localName) => {
+    const children = node.children.filter(
+      (n) => n.name.namespace === node.name.namespace && n.name.localName === localName
+    );
+    if (children.length > 1)
+      throw new OfficeError("invalid-xml", "Multiple brightness transforms.", "index");
+    return children[0] ? readXmlPercentage(attr(children[0], "val")) : void 0;
+  };
+  const off = transform("lumOff"), mod = transform("lumMod");
+  return {
+    type: kinds[node.name.localName],
+    rgb: node.name.localName === "srgbClr" ? attr(node, "val") ?? null : null,
+    theme: node.name.localName === "schemeClr" ? attr(node, "val") ?? null : null,
+    brightness: off ?? (mod === void 0 ? 0 : mod - 1)
+  };
+}
+var RGBColorValue = class {
+  length = 3;
+  0;
+  1;
+  2;
+  red;
+  green;
+  blue;
+  constructor(red, green, blue) {
+    if ([red, green, blue].some((v) => typeof v !== "number"))
+      throw new TypeError("RGB channels must be numeric.");
+    if ([red, green, blue].some((v) => !Number.isInteger(v) || v < 0 || v > 255))
+      throw new ValueError("RGB channels must be integers between 0 and 255.");
+    this[0] = red;
+    this[1] = green;
+    this[2] = blue;
+    this.red = red;
+    this.green = green;
+    this.blue = blue;
+    Object.freeze(this);
+    return new Proxy(this, {
+      get(target, property, receiver) {
+        if (typeof property === "string" && String(Number(property)) === property) {
+          const index = Number(property);
+          if (!Number.isInteger(index) || index < 0 || index >= 3)
+            throw new IndexError("RGB channel index is out of range.");
+        }
+        return Reflect.get(target, property, receiver);
+      }
+    });
+  }
+  at(index) {
+    if (!Number.isInteger(index) || index < -3 || index > 2)
+      throw new IndexError("RGB channel index is out of range.");
+    return [this.red, this.green, this.blue][index < 0 ? index + 3 : index];
+  }
+  slice(start, end, step = 1) {
+    if (!Number.isSafeInteger(step) || step === 0 || [start, end].some((v) => v !== void 0 && !Number.isSafeInteger(v)))
+      throw new ValueError("Invalid RGB slice bounds.");
+    const normalize = (value) => Math.max(step > 0 ? 0 : -1, Math.min(step > 0 ? 3 : 2, value < 0 ? value + 3 : value));
+    const first = start === void 0 ? step > 0 ? 0 : 2 : normalize(start);
+    const last = end === void 0 ? step > 0 ? 3 : -1 : normalize(end);
+    const output = [];
+    for (let i = first; step > 0 ? i < last : i > last; i += step) output.push(this.at(i));
+    return Object.freeze(output);
+  }
+  equals(other) {
+    return other instanceof RGBColor && this.red === other.red && this.green === other.green && this.blue === other.blue;
+  }
+  static from_string(value) {
+    if (typeof value !== "string")
+      throw new TypeError("RGB hexadecimal input must be a string.");
+    try {
+      validateColor(value);
+    } catch (error) {
+      if (error instanceof OfficeError && error.code === "invalid-value")
+        throw new ValueError(error.message);
+      throw error;
+    }
+    return new RGBColor(
+      Number.parseInt(value.slice(0, 2), 16),
+      Number.parseInt(value.slice(2, 4), 16),
+      Number.parseInt(value.slice(4, 6), 16)
+    );
+  }
+  *[Symbol.iterator]() {
+    yield this.red;
+    yield this.green;
+    yield this.blue;
+  }
+  toString() {
+    return [this.red, this.green, this.blue].map((v) => v.toString(16).padStart(2, "0")).join("").toUpperCase();
+  }
+};
+var ColorFormat = class {
+  #storedXml;
+  #binding;
+  get #xml() {
+    return this.#binding?.read() ?? this.#storedXml;
+  }
+  set #xml(xml) {
+    if (this.#binding) this.#binding.write(xml);
+    else this.#storedXml = xml;
+  }
+  constructor(xml, binding) {
+    if (!["solidFill", "highlight"].includes(xml.root.name.localName) || ![
+      "http://schemas.openxmlformats.org/drawingml/2006/main",
+      "http://purl.oclc.org/ooxml/drawingml/main"
+    ].includes(xml.root.name.namespace))
+      invalid("Color view requires a DrawingML color container.");
+    readRunColor(xml.root);
+    this.#storedXml = xml;
+    this.#binding = binding;
+  }
+  get xml() {
+    return this.#xml;
+  }
+  get type() {
+    const type = readRunColor(this.#xml.root)?.type;
+    return type === void 0 ? null : MSO_COLOR_TYPE[type];
+  }
+  get rgb() {
+    const value = readRunColor(this.#xml.root)?.rgb;
+    if (value == null) throw new PropertyAccessError("RGB color is unavailable.");
+    return RGBColor.from_string(value);
+  }
+  set rgb(value) {
+    if (!(value instanceof RGBColor)) invalid("RGB assignment requires an RGBColor value.");
+    const xml = this.#xml;
+    this.#xml = xml.merge(xml.root, colorMerge(value.toString(), xml.root.name.namespace));
+  }
+  get theme_color() {
+    const value = readRunColor(this.#xml.root);
+    if (value === null) throw new PropertyAccessError("Theme color is unavailable.");
+    return value.theme === null ? MSO_THEME_COLOR_INDEX.NOT_THEME_COLOR : MSO_THEME_COLOR_INDEX.from_xml(value.theme);
+  }
+  set theme_color(value) {
+    const xml = this.#xml;
+    this.#xml = xml.merge(
+      xml.root,
+      colorMerge({ theme: MSO_THEME_COLOR_INDEX.to_xml(value) }, xml.root.name.namespace)
+    );
+  }
+  get brightness() {
+    return readRunColor(this.#xml.root)?.brightness ?? 0;
+  }
+  set brightness(value) {
+    brightness(value);
+    const xml = this.#xml;
+    const color = xml.root.children.find(
+      (n) => n.name.namespace === xml.root.name.namespace && Object.hasOwn(kinds, n.name.localName)
+    );
+    if (!color) invalid("Brightness requires an explicit color.");
+    this.#xml = xml.merge(color, colorBrightnessMerge(value, color.name.namespace));
+  }
+};
+var RGBColor = callableConstructor(RGBColorValue);
+
+export {
+  defineEnum,
+  defineXmlEnum,
+  MSO_COLOR_TYPE,
+  MSO_THEME_COLOR_INDEX,
+  validateRunColor,
+  colorBrightnessMerge,
+  colorMerge,
+  readRunColor,
+  ColorFormat,
+  RGBColor
+};

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

@@ -0,0 +1,194 @@
+import {
+  readTextSegments
+} from "./chunk-LWVDJB5S.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  LocationIndex
+} from "./chunk-IR6ZKAUH.js";
+import {
+  admittedXml,
+  readDocumentArchive
+} from "./chunk-GLPIFP7N.js";
+import {
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  InputTypeError,
+  ResourceLimitError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/diff.ts
+var mce = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+var xmlns = "http://www.w3.org/2000/xmlns/";
+function semanticXml(root, budget, wordNamespace, storyRoots = /* @__PURE__ */ new Set()) {
+  const tokens = [];
+  let text = [];
+  const token = (value) => {
+    const size = (item) => typeof item === "string" ? item.length + 2 : Array.isArray(item) ? item.reduce((n, child) => n + size(child) + 1, 2) : item && typeof item === "object" ? Object.entries(item).reduce((n, [key, child]) => n + key.length + size(child) + 4, 2) : 16;
+    const capacity = size(value);
+    budget.charge("retainedBytes", capacity * 24 + 32);
+    budget.charge("work", capacity * 6);
+    const encoded = JSON.stringify(value);
+    tokens.push(encoded);
+  };
+  const flush = () => {
+    if (!text.length) return;
+    budget.charge("retainedBytes", text.reduce((n, item) => n + item.length * 2, 0));
+    token(["text", text.join("")]);
+    text = [];
+  };
+  const content = (nodes) => {
+    for (const node of nodes) {
+      budget.charge("work", 1);
+      if (node.kind === "element") visit(node);
+      else if (node.kind === "text" || node.kind === "cdata") {
+        budget.charge("retainedBytes", node.text.length * 2);
+        text.push(node.text);
+      } else {
+        flush();
+        token(node);
+      }
+    }
+  };
+  const visit = (node) => {
+    if (node !== root && storyRoots.has(node)) return;
+    const logical = wordNamespace === node.namespace;
+    if (logical && ["r", "t"].includes(node.localName) && node.attributes.every((a) => a.namespace === xmlns || a.namespace === "http://www.w3.org/XML/1998/namespace" && a.localName === "space")) {
+      content(node.content);
+      return;
+    }
+    flush();
+    const attributes = node.attributes.filter((a) => a.namespace !== xmlns).map((a) => {
+      budget.charge("work", a.value.length + a.namespace.length + a.localName.length + 1);
+      budget.charge("retainedBytes", a.value.length * 4 + 128);
+      let value = a.value;
+      if (a.namespace === mce && ["Ignorable", "MustUnderstand", "Requires", "ProcessContent", "PreserveElements", "PreserveAttributes"].includes(a.localName) || !a.namespace && node.namespace === mce && a.localName === "Requires") {
+        const words = [];
+        let word = "";
+        for (const c of a.value + " ") {
+          if (" 	\r\n".includes(c)) {
+            if (word) words.push(word);
+            word = "";
+          } else word += c;
+        }
+        value = words.map((word2) => {
+          const colon = word2.indexOf(":");
+          return colon < 0 ? [node.namespaces.get(word2) ?? word2] : [node.namespaces.get(word2.slice(0, colon)) ?? word2.slice(0, colon), word2.slice(colon + 1)];
+        });
+      }
+      if (a.namespace === "http://www.w3.org/2001/XMLSchema-instance" && a.localName === "type") {
+        const qname = a.value.trim();
+        const colon = qname.indexOf(":");
+        value = colon < 0 ? [node.namespaces.get("") ?? "", qname] : [node.namespaces.get(qname.slice(0, colon)) ?? qname.slice(0, colon), qname.slice(colon + 1)];
+      }
+      return [a.namespace, a.localName, value];
+    }).sort((a, b) => JSON.stringify(a.slice(0, 2)) < JSON.stringify(b.slice(0, 2)) ? -1 : 1);
+    token(["start", node.namespace, node.localName, attributes]);
+    content(node.content);
+    flush();
+    token(["end"]);
+  };
+  content(root.prolog ?? []);
+  visit(root);
+  content(root.epilog ?? []);
+  flush();
+  return tokens.join("\n");
+}
+async function comparisonParts(input, context, mode, scope) {
+  const settings = archiveSettings(context), { budget } = settings;
+  const archive = await readDocumentArchive(input, { ...settings, budget: budget.document() });
+  budget.charge("work", input.length);
+  budget.charge("retainedBytes", input.length + 1024);
+  const digest = await crypto.subtle.digest("SHA-256", new Uint8Array(input));
+  const sourceSha256 = [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  const locate = (entry) => {
+    const value = { version: 1, sourceSha256, generation: 0, part: entry.part, story: entry.story, path: entry.path, range: null };
+    const token = encodeGeneratedLocation(value);
+    budget.charge("retainedBytes", token.length * 4 + 256);
+    return { kind: entry.kind, token, value, positions: entry.positions };
+  };
+  const result = /* @__PURE__ */ new Map();
+  if (scope === "package") {
+    for (const member of archive.members) {
+      if (member.directory) continue;
+      const part = "/" + member.name;
+      const root = archive[admittedXml]?.get(member.bytes);
+      result.set(part, { value: mode === "xml" && root ? semanticXml(root, budget) : member.bytes, location: locate({ kind: "part", part, story: "package", path: [], positions: {} }) });
+    }
+  } else {
+    const index = new LocationIndex(archive, settings.limits, archive.mainPart, archive.dialect, budget);
+    const storyRoots = new Set(index.entries.filter((entry) => entry.kind === "story").map((entry) => entry.node));
+    budget.charge("retainedBytes", storyRoots.size * 64);
+    const storyParts = /* @__PURE__ */ new Map();
+    const stories = index.entries.filter((entry) => entry.kind === "story" && (scope === "all-stories" || entry.scope === scope));
+    for (const story of stories) {
+      const location = locate(story);
+      const value = mode === "text" ? readTextSegments(index, [location], "final", locate, budget).text : semanticXml(story.node, budget, story.wordNamespace ?? story.node.namespace, storyRoots);
+      const previous = storyParts.get(story.part);
+      budget.charge("retainedBytes", value.length * 4 + 256);
+      if (previous) previous.values.push(value);
+      else storyParts.set(story.part, { values: [value], location });
+      if (mode === "structure") {
+        const stack = [story.node];
+        while (stack.length) {
+          const node = stack.pop();
+          if (node !== story.node && storyRoots.has(node)) continue;
+          budget.charge("work", 1);
+          const target = index.imageTargets.get(node);
+          if (target) {
+            const media = archive.package.getPart(target);
+            result.set(target, { value: media.bytes, location: locate({ kind: "part", part: target, story: story.story, path: [], positions: {} }) });
+          }
+          for (const child of node.children) stack.push(child);
+        }
+      }
+    }
+    for (const [part, item] of storyParts) {
+      const size = item.values.reduce((n, value) => n + value.length, 0);
+      budget.charge("retainedBytes", size * 12 + item.values.length * 64);
+      budget.charge("work", size);
+      result.set(part, { value: JSON.stringify(item.values), location: item.location });
+    }
+  }
+  return result;
+}
+async function compareDocument(left, right, context, options = {}) {
+  const settings = archiveSettings(context);
+  const invocation = validateDocxInvocation({ operation: "diff", inputs: ["left", "right"], options }, settings.budget);
+  const mode = invocation.options.mode ?? "parts";
+  const scope = invocation.options.scope ?? (mode === "text" || mode === "structure" ? "body" : "package");
+  if (!(left instanceof Uint8Array) || !(right instanceof Uint8Array)) throw new InputTypeError("Expected two document byte inputs.");
+  const budget = settings.budget.lower(Object.fromEntries((options.limit ?? []).map((item) => [item.name, item.value])));
+  budget.check("compressedInput", left.length);
+  budget.check("compressedInput", right.length);
+  if (left.length > settings.limits.maxArchiveBytes || right.length > settings.limits.maxArchiveBytes)
+    throw new ResourceLimitError("Document input byte limit exceeded.");
+  budget.charge("retainedBytes", left.length + right.length);
+  left = new Uint8Array(left);
+  right = new Uint8Array(right);
+  const a = await comparisonParts(left, { ...settings, budget }, mode, scope);
+  const b = await comparisonParts(right, { ...settings, budget }, mode, scope);
+  const differences = [];
+  const count = a.size + b.size;
+  budget.charge("retainedBytes", count * 128);
+  budget.charge("work", count * Math.max(1, Math.ceil(Math.log2(count + 1))) * settings.limits.maxPathBytes);
+  const names = [.../* @__PURE__ */ new Set([...a.keys(), ...b.keys()])].sort();
+  for (const part of names) {
+    const before = a.get(part), after = b.get(part);
+    await budget.checkpoint((before?.value.length ?? 0) + (after?.value.length ?? 0) + 1);
+    const equal = before && after && (typeof before.value === "string" ? before.value === after.value : after.value instanceof Uint8Array && before.value.length === after.value.length && before.value.every((byte, i) => byte === after.value[i]));
+    if (!equal) {
+      budget.charge("matches", 1);
+      budget.charge("retainedBytes", 256 + part.length * 4);
+      differences.push({ kind: !before ? "add" : !after ? "remove" : "change", left: before?.location ?? null, right: after?.location ?? null, part });
+    }
+  }
+  return { equal: differences.length === 0, mode, differences };
+}
+
+export {
+  compareDocument
+};