@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/chunk-5DFZAJHL.js

@@ -0,0 +1,324 @@
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/equations-compatibility.ts
+var equationNamespaces = [
+  "http://schemas.openxmlformats.org/officeDocument/2006/math",
+  "http://purl.oclc.org/ooxml/officeDocument/math"
+];
+var equationOpaqueElements = [
+  ...equationNamespaces.flatMap(
+    (namespace) => ["oMath", "oMathPara"].map((localName) => ({ namespace, localName }))
+  ),
+  { namespace: "http://schemas.microsoft.com/office/drawing/2010/main", localName: "m" }
+];
+function protectedEquationNodes(root) {
+  const nodes = [root];
+  for (let index = 0; index < nodes.length; index++) nodes.push(...nodes[index].children);
+  const containsMath = /* @__PURE__ */ new Set();
+  const pending = [];
+  for (const node of nodes.reverse()) {
+    const math = equationNamespaces.includes(node.name.namespace) || equationOpaqueElements.some(
+      (name) => name.namespace === node.name.namespace && name.localName === node.name.localName
+    );
+    if (!math && !node.children.some((child) => containsMath.has(child))) continue;
+    containsMath.add(node);
+    if (math || node.name.namespace === "http://schemas.openxmlformats.org/markup-compatibility/2006" && node.name.localName === "AlternateContent" || [
+      "http://schemas.openxmlformats.org/drawingml/2006/main",
+      "http://purl.oclc.org/ooxml/drawingml/main"
+    ].includes(node.name.namespace) && node.name.localName === "r")
+      pending.push(node);
+  }
+  const result = /* @__PURE__ */ new Set();
+  while (pending.length) {
+    const node = pending.pop();
+    if (result.has(node)) continue;
+    result.add(node);
+    pending.push(...node.children);
+  }
+  return result;
+}
+
+// packages/safe-bash-presentation-engine/src/compatibility.ts
+import { SaxesParser } from "saxes";
+var mc = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+var xml = "http://www.w3.org/XML/1998/namespace";
+var dialects = /* @__PURE__ */ new Map([
+  ["http://purl.oclc.org/ooxml/presentationml/main", "strict"],
+  ["http://purl.oclc.org/ooxml/drawingml/main", "strict"],
+  ["http://schemas.openxmlformats.org/presentationml/2006/main", "transitional"],
+  ["http://schemas.openxmlformats.org/drawingml/2006/main", "transitional"]
+]);
+function invalid() {
+  throw new OfficeError("invalid-xml", "Invalid markup compatibility controls.", "parse");
+}
+function unsupported() {
+  throw new OfficeError(
+    "unsupported-profile",
+    "Required XML namespace is not understood.",
+    "parse"
+  );
+}
+function tokens(value) {
+  const result = [];
+  let token = "";
+  for (const character of value) {
+    if (" 	\r\n".includes(character)) {
+      if (token) result.push(token);
+      token = "";
+    } else token += character;
+  }
+  if (token) result.push(token);
+  return result;
+}
+function validLocalName(value) {
+  if (!value || value.includes(":")) invalid();
+  const parser = new SaxesParser();
+  let count = 0;
+  parser.on("error", invalid);
+  parser.on("opentag", (tag) => {
+    if (++count !== 1 || tag.name !== value || Object.keys(tag.attributes).length) invalid();
+  });
+  parser.write(`<${value}/>`).close();
+}
+function interpretCompatibility(part, understoodNamespaces, opaqueElements = [], expandOpaque) {
+  if (!Array.isArray(understoodNamespaces) || expandOpaque !== void 0 && typeof expandOpaque !== "function" || understoodNamespaces.some((uri) => typeof uri !== "string" || !uri))
+    throw new OfficeError("invalid-value", "Expected understood namespace URIs.", "usage");
+  if (!Array.isArray(opaqueElements) || opaqueElements.some(
+    (name) => !name || typeof name.namespace !== "string" || typeof name.localName !== "string" || !name.localName
+  ))
+    throw new OfficeError("invalid-value", "Expected opaque element names.", "usage");
+  const opaque = opaqueElements.map((name) => Object.freeze({ ...name }));
+  const supplied = [...understoodNamespaces];
+  const understood = /* @__PURE__ */ new Set(["", xml, mc, ...supplied]);
+  const children = /* @__PURE__ */ new Map();
+  const attributes = /* @__PURE__ */ new Map();
+  const alternatives = [];
+  const preserved = [];
+  const scan = [part.root];
+  while (scan.length) {
+    const element = scan.pop();
+    if (element.name.namespace === mc && element.name.localName === "AlternateContent") {
+      preserved.push(part.markup(element));
+    } else scan.push(...[...element.children].reverse());
+  }
+  function prefixUri(element, prefix) {
+    validLocalName(prefix);
+    const uri = part.resolveNamespace(element, prefix);
+    if (!uri || uri === mc) invalid();
+    return uri;
+  }
+  function rules(element, inherited) {
+    const ignorable = new Set(inherited.ignorable);
+    const process = new Set(inherited.process);
+    const controls = /* @__PURE__ */ new Map();
+    for (const attribute of element.attributes) {
+      if (attribute.name.namespace === mc) {
+        if (![
+          "Ignorable",
+          "MustUnderstand",
+          "ProcessContent",
+          "PreserveElements",
+          "PreserveAttributes"
+        ].includes(attribute.name.localName))
+          invalid();
+        controls.set(attribute.name.localName, attribute.value);
+      }
+    }
+    for (const prefix of tokens(controls.get("Ignorable") ?? ""))
+      ignorable.add(prefixUri(element, prefix));
+    for (const prefix of tokens(controls.get("MustUnderstand") ?? "")) prefixUri(element, prefix);
+    for (const control of ["ProcessContent", "PreserveElements", "PreserveAttributes"]) {
+      for (const token of tokens(controls.get(control) ?? "")) {
+        const names = token.split(":");
+        if (names.length !== 2) invalid();
+        const uri = prefixUri(element, names[0]);
+        const local = names[1];
+        if (local !== "*") validLocalName(local);
+        if (!ignorable.has(uri)) invalid();
+        if (control === "ProcessContent") process.add(JSON.stringify([uri, local]));
+      }
+    }
+    return { ignorable, process };
+  }
+  function mustUnderstand(element) {
+    const declaration = element.attributes.find(
+      (attribute) => attribute.name.namespace === mc && attribute.name.localName === "MustUnderstand"
+    );
+    for (const prefix of tokens(declaration?.value ?? "")) {
+      if (!understood.has(prefixUri(element, prefix))) unsupported();
+    }
+  }
+  function wrapperAttributes(element, context) {
+    for (const attribute of element.attributes) {
+      const uri = attribute.name.namespace;
+      if (uri === xml || uri && uri !== mc && !context.ignorable.has(uri)) invalid();
+      if (!uri && !(element.name.localName === "Choice" && attribute.name.localName === "Requires"))
+        invalid();
+    }
+  }
+  function checkedAttributes(element, context) {
+    const result = [];
+    for (const attribute of element.attributes) {
+      const uri = attribute.name.namespace;
+      if (uri === mc) continue;
+      if (!understood.has(uri)) {
+        if (!context.ignorable.has(uri)) unsupported();
+        continue;
+      }
+      result.push(attribute);
+    }
+    return Object.freeze(result);
+  }
+  const rootOutput = [];
+  const tasks = [
+    {
+      element: part.root,
+      inherited: { ignorable: /* @__PURE__ */ new Set(), process: /* @__PURE__ */ new Set() },
+      output: rootOutput
+    }
+  ];
+  while (tasks.length) {
+    const task = tasks.pop();
+    const { element, inherited, output } = task;
+    if (task.finish) {
+      Object.freeze(children.get(element));
+      continue;
+    }
+    const context = rules(element, inherited);
+    if (element.name.namespace === mc && !task.branch) {
+      if (element.name.localName !== "AlternateContent") invalid();
+      wrapperAttributes(element, context);
+      mustUnderstand(element);
+      let selected = null;
+      let fallback = false;
+      let choices = 0;
+      for (const branch of element.children) {
+        const branchRules = rules(branch, context);
+        if (branch.name.namespace !== mc) {
+          if (!branchRules.ignorable.has(branch.name.namespace)) invalid();
+          if (understood.has(branch.name.namespace) || branchRules.process.has(
+            JSON.stringify([branch.name.namespace, branch.name.localName])
+          ) || branchRules.process.has(JSON.stringify([branch.name.namespace, "*"])))
+            unsupported();
+          continue;
+        }
+        wrapperAttributes(branch, branchRules);
+        const branchAttributes = checkedAttributes(branch, branchRules);
+        if (branch.name.localName === "Choice" && !fallback) {
+          choices++;
+          const requires = branchAttributes.find(
+            (attribute) => !attribute.name.namespace && attribute.name.localName === "Requires"
+          );
+          if (!requires) invalid();
+          const prefixes = tokens(requires.value);
+          if (!prefixes.length) invalid();
+          const namespaces = prefixes.map((prefix) => prefixUri(branch, prefix));
+          if (branchAttributes.some(
+            (attribute) => !attribute.name.namespace && attribute.name.localName !== "Requires"
+          ))
+            invalid();
+          if (!selected && namespaces.every((uri) => understood.has(uri))) selected = branch;
+        } else if (branch.name.localName === "Fallback" && !fallback && choices) {
+          fallback = true;
+          if (branchAttributes.some((attribute) => !attribute.name.namespace)) invalid();
+          if (!selected) selected = branch;
+        } else invalid();
+      }
+      if (!choices) invalid();
+      alternatives.push(Object.freeze({ element, selected }));
+      if (selected) {
+        mustUnderstand(selected);
+        tasks.push({ element: selected, inherited: context, output, branch: true });
+      }
+      continue;
+    }
+    let destination = output;
+    if (!task.branch) {
+      const uri = element.name.namespace;
+      if (!understood.has(uri) && opaque.some((name) => name.namespace === uri && name.localName === element.name.localName)) {
+        mustUnderstand(element);
+        output.push(element);
+        children.set(element, Object.freeze([]));
+        attributes.set(
+          element,
+          Object.freeze(element.attributes.filter((attribute) => attribute.name.namespace !== mc))
+        );
+        continue;
+      }
+      if (!understood.has(uri)) {
+        if (!context.ignorable.has(uri)) unsupported();
+        if (!context.process.has(JSON.stringify([uri, element.name.localName])) && !context.process.has(JSON.stringify([uri, "*"])))
+          continue;
+        if (element.attributes.some(
+          (attribute) => attribute.name.namespace === xml && ["base", "lang", "space"].includes(attribute.name.localName)
+        ))
+          invalid();
+        mustUnderstand(element);
+      } else {
+        mustUnderstand(element);
+        attributes.set(element, checkedAttributes(element, context));
+        output.push(element);
+        destination = [];
+        children.set(element, destination);
+        tasks.push({ ...task, finish: true });
+      }
+    }
+    if (opaque.some(
+      (name) => name.namespace === element.name.namespace && name.localName === element.name.localName
+    ) && !expandOpaque?.(element))
+      continue;
+    for (const child of [...element.children].reverse())
+      tasks.push({ element: child, inherited: context, output: destination });
+  }
+  const dialect = dialects.get(part.root.name.namespace) ?? null;
+  return Object.freeze({
+    part,
+    dialect,
+    alternatives: Object.freeze(alternatives),
+    children(element) {
+      const result = children.get(element);
+      if (!result)
+        throw new OfficeError("invalid-value", "Expected a processed XML element.", "usage");
+      return result;
+    },
+    attributes(element) {
+      const result = attributes.get(element);
+      if (!result)
+        throw new OfficeError("invalid-value", "Expected a processed XML element.", "usage");
+      return result;
+    },
+    merge(element, update) {
+      if (!children.has(element))
+        throw new OfficeError(
+          "unsupported-edit",
+          "Only processed XML elements can be edited.",
+          "validate-intent"
+        );
+      const edited = part.merge(element, update);
+      const found = [];
+      const scan2 = [edited.root];
+      while (scan2.length) {
+        const candidate = scan2.pop();
+        if (candidate.name.namespace === mc && candidate.name.localName === "AlternateContent")
+          found.push(edited.markup(candidate));
+        else scan2.push(...[...candidate.children].reverse());
+      }
+      if (found.length !== preserved.length || found.some((value, index) => value !== preserved[index]))
+        throw new OfficeError(
+          "unsupported-edit",
+          "Alternate representations require synchronized editing.",
+          "validate-intent"
+        );
+      return interpretCompatibility(edited, supplied, opaque, expandOpaque);
+    }
+  });
+}
+
+export {
+  equationNamespaces,
+  equationOpaqueElements,
+  protectedEquationNodes,
+  interpretCompatibility
+};

package/dist/safe-bash/command-chunks/chunk-5GEFJROP.js

@@ -0,0 +1,270 @@
+import {
+  asciiKey,
+  packageUri,
+  partName,
+  relativePartReference,
+  resolvePartReference
+} from "./chunk-XXFHTGV2.js";
+import {
+  resourceContext
+} from "./chunk-FOO3AXFK.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/relationships.ts
+import { SaxesParser } from "saxes";
+function invalid() {
+  throw new OfficeError("invalid-opc", "Invalid package relationships.", "index");
+}
+function bounded(count, limit) {
+  if (limit !== Infinity && !Number.isSafeInteger(limit) || limit < 1)
+    throw new OfficeError("invalid-value", "Explicit relationship limits are required.", "usage");
+  if (count > limit)
+    throw new OfficeError("resource-limit", "Relationship limit exceeded.", "index");
+}
+function validate(relationship) {
+  if (!relationship || typeof relationship.id !== "string" || !relationship.id || typeof relationship.type !== "string" || !relationship.type || typeof relationship.target !== "string" || !relationship.target || typeof relationship.external !== "boolean")
+    invalid();
+}
+function parseRelationships(bytes, settings = {}) {
+  const limits = resourceContext({ relationshipLimits: settings }).relationshipLimits;
+  bounded(bytes?.length ?? 0, limits.maxBytes);
+  bounded(0, limits.maxRelationships);
+  if (bytes === null) return Object.freeze([]);
+  const relationships = [];
+  const ids = /* @__PURE__ */ new Set();
+  let encoding = "utf-8";
+  if (bytes[0] === 255 && bytes[1] === 254 || bytes[0] === 60 && bytes[1] === 0)
+    encoding = "utf-16le";
+  if (bytes[0] === 254 && bytes[1] === 255 || bytes[0] === 0 && bytes[1] === 60)
+    encoding = "utf-16be";
+  try {
+    const parser = new SaxesParser({ xmlns: true });
+    let depth = 0;
+    parser.on("error", invalid);
+    parser.on("doctype", invalid);
+    parser.on("cdata", invalid);
+    parser.on("xmldecl", (declaration) => {
+      if (declaration.version !== "1.0" || declaration.encoding && asciiKey(declaration.encoding) !== (encoding === "utf-8" ? "utf-8" : "utf-16"))
+        invalid();
+    });
+    parser.on("text", (value) => {
+      if ([...value].some((character) => !" 	\r\n".includes(character))) invalid();
+    });
+    parser.on("opentag", (tag) => {
+      depth++;
+      if (tag.uri !== "http://schemas.openxmlformats.org/package/2006/relationships" || depth > 2)
+        invalid();
+      const attributes = Object.values(tag.attributes).filter(
+        (a) => a.uri !== "http://www.w3.org/2000/xmlns/"
+      );
+      if (depth === 1) {
+        if (tag.local !== "Relationships" || attributes.length) invalid();
+        return;
+      }
+      if (tag.local !== "Relationship" || attributes.some((a) => a.uri || !["Id", "Type", "Target", "TargetMode"].includes(a.local)))
+        invalid();
+      const get = (name) => attributes.find((a) => a.local === name)?.value;
+      const mode = get("TargetMode");
+      if (mode !== void 0 && mode !== "Internal" && mode !== "External") invalid();
+      const relationship = {
+        id: get("Id") ?? "",
+        type: get("Type") ?? "",
+        target: get("Target") ?? "",
+        external: mode === "External"
+      };
+      validate(relationship);
+      if (ids.has(relationship.id)) invalid();
+      bounded(relationships.length + 1, limits.maxRelationships);
+      ids.add(relationship.id);
+      relationships.push(Object.freeze(relationship));
+    });
+    parser.on("closetag", () => {
+      depth--;
+    });
+    parser.write(new TextDecoder(encoding, { fatal: true }).decode(bytes)).close();
+  } catch (error) {
+    if (error instanceof OfficeError) throw error;
+    invalid();
+  }
+  return Object.freeze(relationships);
+}
+function relationshipGraph(parts, sets, settings = {}) {
+  const limits = resourceContext({ relationshipLimits: settings }).relationshipLimits;
+  bounded(parts.length, limits.maxParts);
+  bounded(0, limits.maxRelationships);
+  const names = /* @__PURE__ */ new Map();
+  const parents = /* @__PURE__ */ new Set();
+  for (const input of parts) {
+    const name = partName(input, false);
+    const key = asciiKey(name);
+    if (names.has(key) || parents.has(key) || key === "/[content_types].xml" || relationshipOwner(name) !== null)
+      invalid();
+    let parent = key.slice(0, key.lastIndexOf("/"));
+    while (parent) {
+      if (names.has(parent)) invalid();
+      parents.add(parent);
+      parent = parent.slice(0, parent.lastIndexOf("/"));
+    }
+    names.set(key, name);
+  }
+  const ownerName = (input) => {
+    if (input === "/") return "/";
+    const name = names.get(asciiKey(partName(input, false)));
+    if (!name) throw new OfficeError("missing-binding", "Relationship owner is absent.", "index");
+    return name;
+  };
+  const forward = /* @__PURE__ */ new Map();
+  const reverse = /* @__PURE__ */ new Map();
+  const dangling = [];
+  let count = 0;
+  for (const set of sets) {
+    const owner = ownerName(set.owner);
+    if (forward.has(owner)) invalid();
+    const ids = /* @__PURE__ */ new Set();
+    const edges = [];
+    for (const relationship of set.relationships) {
+      bounded(++count, limits.maxRelationships);
+      validate(relationship);
+      if (ids.has(relationship.id)) invalid();
+      ids.add(relationship.id);
+      const resolved = relationship.external ? null : resolvePartReference(packageUri(owner).baseURI, relationship.target);
+      const targetPart = resolved === null ? null : names.get(asciiKey(resolved)) ?? resolved;
+      const edge = Object.freeze({
+        id: relationship.id,
+        type: relationship.type,
+        target: relationship.target,
+        external: relationship.external,
+        owner,
+        targetPart
+      });
+      edges.push(edge);
+      if (targetPart !== null) {
+        const key = asciiKey(targetPart);
+        const incoming = reverse.get(key) ?? [];
+        incoming.push(edge);
+        reverse.set(key, incoming);
+        if (!names.has(key)) dangling.push(edge);
+      }
+    }
+    forward.set(owner, Object.freeze(edges));
+  }
+  for (const edges of reverse.values()) Object.freeze(edges);
+  const empty = Object.freeze([]);
+  return Object.freeze({
+    parts: Object.freeze([...names.values()]),
+    dangling: Object.freeze(dangling),
+    outgoing(owner) {
+      return forward.get(ownerName(owner)) ?? empty;
+    },
+    incoming(target) {
+      return reverse.get(asciiKey(partName(target, false))) ?? empty;
+    },
+    closure(roots) {
+      bounded(roots.length, limits.maxParts);
+      const visited = /* @__PURE__ */ new Set();
+      const result = [];
+      const stack = [...roots].reverse();
+      while (stack.length) {
+        const name = ownerName(stack.pop());
+        if (visited.has(name)) continue;
+        visited.add(name);
+        if (name !== "/") result.push(name);
+        const edges = forward.get(name) ?? empty;
+        for (let index = edges.length - 1; index >= 0; index--) {
+          const edge = edges[index];
+          if (edge.targetPart !== null) stack.push(edge.targetPart);
+        }
+      }
+      return Object.freeze(result);
+    }
+  });
+}
+function importRelationships(destination, source, roots, limits) {
+  if (roots.includes("/"))
+    throw new OfficeError("invalid-value", "Import requires part roots.", "usage");
+  const selected = source.closure(roots);
+  bounded(destination.parts.length + selected.length, limits.maxParts);
+  const occupied = new Set([...destination.parts, ...selected].map(asciiKey));
+  const existing = new Set(destination.parts.map(asciiKey));
+  const mapping = /* @__PURE__ */ new Map();
+  for (const name of selected) {
+    let target = name;
+    if (existing.has(asciiKey(name))) {
+      const uri = packageUri(name);
+      const dot = uri.filename.lastIndexOf(".");
+      const stem = dot < 0 ? name : name.slice(0, name.length - uri.ext.length - 1);
+      const suffix = dot < 0 ? "" : `.${uri.ext}`;
+      let index = 1;
+      do {
+        target = `${stem}-import${index++}${suffix}`;
+      } while (occupied.has(asciiKey(target)));
+    }
+    occupied.add(asciiKey(target));
+    mapping.set(name, target);
+  }
+  const sets = ["/", ...destination.parts].map((owner) => ({
+    owner,
+    relationships: destination.outgoing(owner)
+  }));
+  for (const name of selected) {
+    const owner = mapping.get(name);
+    sets.push({
+      owner,
+      relationships: source.outgoing(name).map((edge) => ({
+        id: edge.id,
+        type: edge.type,
+        external: edge.external,
+        target: edge.targetPart === null ? edge.target : relativePartReference(mapping.get(edge.targetPart), packageUri(owner).baseURI)
+      }))
+    });
+  }
+  return Object.freeze({
+    graph: relationshipGraph([...destination.parts, ...mapping.values()], sets, limits),
+    mapping: Object.freeze([...mapping].map((pair) => Object.freeze(pair)))
+  });
+}
+function relationshipOwner(name) {
+  const key = asciiKey(name);
+  if (key === "/_rels/.rels") return "/";
+  const slash = name.lastIndexOf("/");
+  const directory = name.slice(0, slash);
+  if (!asciiKey(directory).endsWith("/_rels") || !key.endsWith(".rels")) return null;
+  return partName(`${directory.slice(0, -6)}/${name.slice(slash + 1, -5)}`, false);
+}
+function readRelationshipGraph(reader, settings = {}) {
+  const limits = resourceContext({ relationshipLimits: settings }).relationshipLimits;
+  const parts = [];
+  const sets = [];
+  let bytesRead = 0;
+  let relationships = 0;
+  bounded(0, limits.maxBytes);
+  bounded(0, limits.maxParts);
+  bounded(0, limits.maxRelationships);
+  for (const name of reader.names) {
+    if (asciiKey(name) === "/[content_types].xml") continue;
+    const owner = relationshipOwner(name);
+    if (owner === null) {
+      bounded(parts.length + 1, limits.maxParts);
+      parts.push(name);
+    } else {
+      bounded(sets.length + 1, limits.maxParts + 1);
+      const bytes = reader.get(name);
+      bytesRead += bytes.length;
+      bounded(bytesRead, limits.maxBytes);
+      const parsed = parseRelationships(bytes, limits);
+      relationships += parsed.length;
+      bounded(relationships, limits.maxRelationships);
+      sets.push({ owner, relationships: parsed });
+    }
+  }
+  return relationshipGraph(parts, sets, limits);
+}
+
+export {
+  parseRelationships,
+  relationshipGraph,
+  importRelationships,
+  readRelationshipGraph
+};