@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,342 @@
+import {
+  relationshipOwner
+} from "./chunk-WAKYUXVQ.js";
+import {
+  InvalidXmlError,
+  UnsupportedProfileError
+} from "./chunk-MWAAMNAM.js";
+import {
+  DocumentBudget,
+  InvalidValueError,
+  documentXmlCache
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/compatibility.ts
+var mc = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+var xml = "http://www.w3.org/XML/1998/namespace";
+var xmlns = "http://www.w3.org/2000/xmlns/";
+var drawingNamespaces = ["http://schemas.openxmlformats.org/drawingml/2006/main", "http://purl.oclc.org/ooxml/drawingml/main"];
+var graphicNamespaces = [
+  ...drawingNamespaces,
+  "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
+  "http://purl.oclc.org/ooxml/drawingml/wordprocessingDrawing",
+  "http://schemas.openxmlformats.org/drawingml/2006/picture",
+  "http://purl.oclc.org/ooxml/drawingml/picture"
+];
+var documentCompatibilityProfile = Object.freeze({
+  understoodNamespaces: Object.freeze([
+    "",
+    xml,
+    "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+    "http://purl.oclc.org/ooxml/wordprocessingml/main",
+    ...graphicNamespaces,
+    "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+    "http://purl.oclc.org/ooxml/officeDocument/relationships",
+    "http://schemas.openxmlformats.org/officeDocument/2006/math",
+    "http://purl.oclc.org/ooxml/officeDocument/math",
+    "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties",
+    "http://purl.oclc.org/ooxml/officeDocument/extendedProperties",
+    "http://schemas.openxmlformats.org/officeDocument/2006/custom-properties",
+    "http://purl.oclc.org/ooxml/officeDocument/customProperties",
+    "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes",
+    "http://purl.oclc.org/ooxml/officeDocument/docPropsVTypes",
+    "http://schemas.openxmlformats.org/package/2006/content-types",
+    "http://schemas.openxmlformats.org/package/2006/relationships",
+    "http://schemas.openxmlformats.org/package/2006/metadata/core-properties",
+    "http://purl.org/dc/elements/1.1/",
+    "http://purl.org/dc/terms/"
+  ]),
+  extensionElements: Object.freeze(drawingNamespaces.map((namespace) => Object.freeze({ namespace, localName: "ext" }))),
+  understoodElements: Object.freeze([...["checkbox", "checked", "checkedState", "uncheckedState"].map((localName) => Object.freeze({
+    namespace: "http://schemas.microsoft.com/office/word/2010/wordml",
+    localName,
+    attributes: Object.freeze((localName === "checkbox" ? [] : localName === "checked" ? ["val"] : ["val", "font"]).map((name) => Object.freeze({ namespace: "http://schemas.microsoft.com/office/word/2010/wordml", localName: name })))
+  })), ...["repeatingSection", "repeatingSectionItem", "sectionTitle", "doNotAllowInsertDeleteSection"].map((localName) => Object.freeze({
+    namespace: "http://schemas.microsoft.com/office/word/2012/wordml",
+    localName,
+    attributes: Object.freeze((localName === "sectionTitle" || localName === "doNotAllowInsertDeleteSection" ? ["val"] : []).map((name) => Object.freeze({ namespace: "http://schemas.microsoft.com/office/word/2012/wordml", localName: name })))
+  }))])
+});
+var relationshipNamespace = "http://schemas.openxmlformats.org/package/2006/relationships";
+var relationshipCompatibilityProfile = Object.freeze({
+  understoodNamespaces: Object.freeze([relationshipNamespace])
+});
+function compatibilityProfileForRoot(root) {
+  return root.namespace === relationshipNamespace && root.localName === "Relationships" ? relationshipCompatibilityProfile : documentCompatibilityProfile;
+}
+function compatibilityProfileForPart(partname) {
+  return relationshipOwner(partname) === null ? documentCompatibilityProfile : relationshipCompatibilityProfile;
+}
+function compatibilitySettings(profile) {
+  if (!profile || typeof profile !== "object" || Array.isArray(profile) || Object.keys(profile).some((key) => !["understoodNamespaces", "extensionElements", "understoodElements"].includes(key)) || !Array.isArray(profile.understoodNamespaces) || profile.understoodNamespaces.some((uri) => typeof uri !== "string" || uri === mc) || profile.extensionElements !== void 0 && (!Array.isArray(profile.extensionElements) || profile.extensionElements.some((name) => !name || typeof name !== "object" || typeof name.namespace !== "string" || name.namespace === mc || typeof name.localName !== "string" || !isXmlLocalName(name.localName) || Object.keys(name).some((key) => !["namespace", "localName"].includes(key)))))
+    throw new InvalidValueError("Invalid markup compatibility profile.");
+  if (profile.understoodElements !== void 0 && (!Array.isArray(profile.understoodElements) || profile.understoodElements.some((name) => !name || typeof name.namespace !== "string" || name.namespace === mc || !isXmlLocalName(name.localName) || !Array.isArray(name.attributes) || Object.keys(name).some((key) => !["namespace", "localName", "attributes"].includes(key)) || name.attributes.some((attribute) => !attribute || typeof attribute.namespace !== "string" || attribute.namespace === mc || !isXmlLocalName(attribute.localName) || Object.keys(attribute).some((key) => !["namespace", "localName"].includes(key)))))) throw new InvalidValueError("Invalid exact markup compatibility names.");
+  return Object.freeze({
+    understoodNamespaces: Object.freeze([...profile.understoodNamespaces]),
+    extensionElements: Object.freeze((profile.extensionElements ?? []).map((name) => Object.freeze({ ...name }))),
+    understoodElements: Object.freeze((profile.understoodElements ?? []).map((name) => Object.freeze({ ...name, attributes: Object.freeze(name.attributes.map((attribute) => Object.freeze({ ...attribute }))) })))
+  });
+}
+var compatibilityContainers = /* @__PURE__ */ Symbol("compatibilityContainers");
+function invalid() {
+  throw new InvalidXmlError("Malformed markup compatibility declaration or structure.");
+}
+function tokens(value) {
+  const result = [];
+  let token = "";
+  for (const char of value) {
+    if (" 	\r\n".includes(char)) {
+      if (token) result.push(token);
+      token = "";
+    } else token += char;
+  }
+  if (token) result.push(token);
+  return result;
+}
+function isXmlLocalName(value) {
+  let first = true;
+  for (const char of value) {
+    const p = char.codePointAt(0);
+    const start = p === 95 || p >= 65 && p <= 90 || p >= 97 && p <= 122 || p >= 192 && p <= 214 || p >= 216 && p <= 246 || p >= 248 && p <= 767 || p >= 880 && p <= 893 || p >= 895 && p <= 8191 || p >= 8204 && p <= 8205 || p >= 8304 && p <= 8591 || p >= 11264 && p <= 12271 || p >= 12289 && p <= 55295 || p >= 63744 && p <= 64975 || p >= 65008 && p <= 65533 || p >= 65536 && p <= 983039;
+    if (!start && (first || !(p === 45 || p === 46 || p === 183 || p >= 48 && p <= 57 || p >= 768 && p <= 879 || p >= 8255 && p <= 8256))) return false;
+    first = false;
+  }
+  return !first;
+}
+function namespaces(element, value) {
+  return tokens(value).map((prefix) => {
+    const uri = element.namespaces.get(prefix);
+    if (!isXmlLocalName(prefix) || !uri || uri === mc) invalid();
+    return uri;
+  });
+}
+function pairs(element, value, ignorable) {
+  return tokens(value).map((token) => {
+    const parts = token.split(":");
+    if (parts.length !== 2 || !isXmlLocalName(parts[0]) || parts[1] !== "*" && !isXmlLocalName(parts[1])) invalid();
+    const namespace = element.namespaces.get(parts[0]);
+    if (!namespace || namespace === mc || !ignorable.has(namespace)) invalid();
+    return { namespace, localName: parts[1] };
+  });
+}
+function matches(name, pair) {
+  return name.namespace === pair.namespace && (pair.localName === "*" || name.localName === pair.localName);
+}
+var MarkupCompatibility = class {
+  content;
+  branches;
+  [compatibilityContainers];
+  #editable = /* @__PURE__ */ new Set();
+  constructor(root, profile = compatibilityProfileForRoot(root), budget = new DocumentBudget()) {
+    const settings = compatibilitySettings(profile);
+    const xmlCache = budget[documentXmlCache];
+    const cache = xmlCache?.immutableRoots?.has(root) ? xmlCache.compatibility ??= /* @__PURE__ */ new WeakMap() : void 0;
+    const key = cache ? JSON.stringify(settings) : void 0;
+    const cached = key === void 0 ? void 0 : cache.get(root)?.get(key);
+    if (cached) {
+      budget.charge("work", cached.work);
+      budget.charge("retainedBytes", cached.retainedBytes);
+      this.content = cached.content;
+      this.branches = cached.branches;
+      this[compatibilityContainers] = cached.containers;
+      this.#editable = cached.editable;
+      return;
+    }
+    const before = cache ? budget.usage : void 0;
+    if (key !== void 0) {
+      budget.charge("work", key.length);
+      budget.charge("retainedBytes", key.length * 2 + 128);
+    }
+    const understood = new Set(settings.understoodNamespaces);
+    const branches = [];
+    const containers = [];
+    const editable = this.#editable;
+    const attribute = (element, name) => element.attributes.find((a) => a.namespace === mc && a.localName === name)?.value;
+    const scopeFor = (element, parent) => {
+      budget.charge("work", 1 + parent.ignorable.size + parent.process.length * (element.attributes.length + 1) + element.attributes.reduce((sum, a) => sum + a.name.length + a.value.length * 8, 0));
+      budget.charge("retainedBytes", (parent.ignorable.size + parent.process.length + element.attributes.length) * 16);
+      if (!element.attributes.some((a) => a.namespace === mc)) return parent;
+      const ignorable = /* @__PURE__ */ new Set([...parent.ignorable, ...namespaces(element, attribute(element, "Ignorable") ?? "")]);
+      const process = [...parent.process, ...pairs(element, attribute(element, "ProcessContent") ?? "", ignorable)];
+      pairs(element, attribute(element, "PreserveElements") ?? "", ignorable);
+      pairs(element, attribute(element, "PreserveAttributes") ?? "", ignorable);
+      for (const a of element.attributes) if (a.namespace === mc && !["Ignorable", "ProcessContent", "MustUnderstand", "PreserveElements", "PreserveAttributes"].includes(a.localName)) invalid();
+      return { ignorable, process, alternate: parent.alternate };
+    };
+    const mustUnderstand = (element) => {
+      const required = attribute(element, "MustUnderstand");
+      if (required !== void 0 && namespaces(element, required).some((uri) => !understood.has(uri)))
+        throw new UnsupportedProfileError("A required namespace is not understood by the declared profile.");
+    };
+    const controlAttributes = (element, scope) => {
+      for (const a of element.attributes) {
+        if (a.namespace === xmlns || a.namespace === mc) continue;
+        if (!a.namespace && a.localName === "Requires" && element.localName === "Choice") continue;
+        if (!a.namespace || a.namespace === xml || !scope.ignorable.has(a.namespace)) invalid();
+      }
+    };
+    const opaque = function* (element) {
+      budget.charge("work", 1 + element.content.length);
+      const content2 = [];
+      for (const node of element.content) {
+        if (node.kind === "element") {
+          const children = yield { mode: "opaque", element: node };
+          for (const child of children) content2.push(child);
+        } else content2.push(node);
+      }
+      return [Object.freeze({
+        source: element,
+        disposition: "extension",
+        attributes: element.attributes,
+        content: Object.freeze(content2)
+      })];
+    };
+    const visitContent = function* (element, scope, blocked) {
+      const result = [];
+      for (const node of element.content) {
+        budget.charge("work", 1);
+        if (node.kind === "element") {
+          const children = yield { mode: "visit", element: node, scope, blocked, owner: element };
+          for (const child of children) result.push(child);
+        } else {
+          result.push(node);
+          if (!blocked) editable.add(node);
+        }
+      }
+      return result;
+    };
+    const visit = function* (element, parent, blocked, owner) {
+      const exact = settings.understoodElements.find((name) => matches(element, name));
+      const exactAttribute = (attribute2) => exact?.attributes.some((name) => matches(attribute2, name)) === true;
+      const dimensions = drawingNamespaces.includes(element.namespace) && element.localName === "ext" && owner?.namespace === element.namespace && owner.localName === "xfrm" && !element.children.length && element.content.every((node) => node.kind === "text" && !node.text.trim()) && ["cx", "cy"].every((name) => element.attributes.filter((attribute2) => attribute2.namespace === "" && attribute2.localName === name).length === 1) && element.attributes.every((attribute2) => attribute2.namespace === xmlns || attribute2.namespace === "" && ["cx", "cy"].includes(attribute2.localName) && attribute2.value.length > 0 && [...attribute2.value].every((char) => "0123456789".includes(char)) && Number.isSafeInteger(Number(attribute2.value)) && Number(attribute2.value) > 0);
+      if (!dimensions && settings.extensionElements.some((name) => matches(element, name))) return yield { mode: "opaque", element };
+      const scope = scopeFor(element, parent);
+      if (scope.ignorable.has(element.namespace) && !understood.has(element.namespace) && !exact) {
+        if (!scope.process.some((pair) => matches(element, pair))) return [];
+        if (element.attributes.some((a) => a.namespace === xml && ["base", "lang", "space"].includes(a.localName))) invalid();
+        mustUnderstand(element);
+        containers.push(element);
+        return yield { mode: "content", element, scope, blocked };
+      }
+      if (element.namespace === mc) {
+        if (element.localName !== "AlternateContent") invalid();
+        controlAttributes(element, scope);
+        let count = 0;
+        let fallback = false;
+        let selected;
+        let selectedScope = scope;
+        for (const node of element.content) {
+          if (node.kind !== "element") {
+            if ((node.kind === "text" || node.kind === "cdata") && tokens(node.text).length) invalid();
+            continue;
+          }
+          if (settings.extensionElements.some((name) => matches(node, name)))
+            throw new UnsupportedProfileError("An alternate-content extension survives compatibility processing.");
+          const childScope = scopeFor(node, scope);
+          if (node.namespace !== mc) {
+            if (!childScope.ignorable.has(node.namespace)) invalid();
+            if (understood.has(node.namespace) || childScope.process.some((pair) => matches(node, pair)))
+              throw new UnsupportedProfileError("An alternate-content extension survives compatibility processing.");
+            continue;
+          }
+          controlAttributes(node, childScope);
+          if (node.localName === "Choice") {
+            if (fallback) invalid();
+            count++;
+            const requires = node.attributes.find((a) => !a.namespace && a.localName === "Requires");
+            if (!requires) invalid();
+            const required = namespaces(node, requires.value);
+            if (!required.length) invalid();
+            if (!selected && required.every((uri) => understood.has(uri))) {
+              selected = node;
+              selectedScope = childScope;
+            }
+          } else if (node.localName === "Fallback") {
+            if (!count || fallback) invalid();
+            fallback = true;
+            if (!selected) {
+              selected = node;
+              selectedScope = childScope;
+            }
+          } else invalid();
+        }
+        if (!count) invalid();
+        mustUnderstand(element);
+        branches.push(Object.freeze({ alternateContent: element, selected }));
+        if (!selected) return [];
+        mustUnderstand(selected);
+        containers.push(element, selected);
+        return yield { mode: "content", element: selected, scope: { ...selectedScope, alternate: true }, blocked };
+      }
+      mustUnderstand(element);
+      const known = understood.has(element.namespace) || exact !== void 0;
+      const pairedImage = drawingNamespaces.includes(element.namespace) && element.localName === "blip" && element.children.some((child) => child.namespace === element.namespace && child.localName === "extLst");
+      const alternateGraphic = scope.alternate && (graphicNamespaces.includes(element.namespace) || ["http://schemas.openxmlformats.org/wordprocessingml/2006/main", "http://purl.oclc.org/ooxml/wordprocessingml/main"].includes(element.namespace) && ["drawing", "pict", "object"].includes(element.localName));
+      const storedMath = ["http://schemas.openxmlformats.org/officeDocument/2006/math", "http://purl.oclc.org/ooxml/officeDocument/math"].includes(element.namespace);
+      const protectedContent = blocked || !known || pairedImage || alternateGraphic || storedMath;
+      const attributes = element.attributes.filter((a) => a.namespace !== mc && !(scope.ignorable.has(a.namespace) && !understood.has(a.namespace) && !exactAttribute(a)));
+      if (!protectedContent) {
+        editable.add(element);
+        for (const a of attributes) if (a.namespace !== xmlns && (exact ? a.namespace === xml && ["lang", "space"].includes(a.localName) || exactAttribute(a) : !a.namespace || a.namespace === xml || understood.has(a.namespace))) editable.add(a);
+      }
+      const content2 = yield { mode: "content", element, scope, blocked: protectedContent };
+      return [Object.freeze({
+        source: element,
+        disposition: known ? "understood" : "opaque",
+        attributes: Object.freeze(attributes),
+        content: Object.freeze(content2)
+      })];
+    };
+    budget.charge("retainedBytes", 128);
+    const pending = [visit(root, { ignorable: /* @__PURE__ */ new Set(), process: [], alternate: false }, false)];
+    let content = [];
+    while (pending.length) {
+      const step = pending[pending.length - 1].next(content);
+      if (step.done) {
+        pending.pop();
+        content = step.value;
+      } else {
+        const request = step.value;
+        budget.charge("work", 1);
+        budget.charge("retainedBytes", 128);
+        content = [];
+        pending.push(request.mode === "opaque" ? opaque(request.element) : request.mode === "content" ? visitContent(request.element, request.scope, request.blocked) : visit(request.element, request.scope, request.blocked, request.owner));
+      }
+    }
+    this.content = Object.freeze(content);
+    this.branches = Object.freeze(branches);
+    this[compatibilityContainers] = Object.freeze(containers);
+    if (key !== void 0) {
+      const usage = budget.usage;
+      const profiles = cache.get(root) ?? /* @__PURE__ */ new Map();
+      profiles.set(key, Object.freeze({
+        content: this.content,
+        branches: this.branches,
+        containers: this[compatibilityContainers],
+        editable: this.#editable,
+        work: usage.work - before.work,
+        retainedBytes: usage.retainedBytes - before.retainedBytes
+      }));
+      cache.set(root, profiles);
+    }
+  }
+  canEdit(node) {
+    return this.#editable.has(node);
+  }
+};
+function hasCompatibilityMarkup(element, profile) {
+  return profile.extensionElements.some((name) => matches(element, name)) || element.namespace === mc || element.attributes.some((a) => a.namespace === mc) || drawingNamespaces.includes(element.namespace) && element.localName === "blip" && element.children.some((child) => child.namespace === element.namespace && child.localName === "extLst");
+}
+
+export {
+  documentCompatibilityProfile,
+  relationshipNamespace,
+  relationshipCompatibilityProfile,
+  compatibilityProfileForRoot,
+  compatibilityProfileForPart,
+  compatibilitySettings,
+  compatibilityContainers,
+  isXmlLocalName,
+  MarkupCompatibility,
+  hasCompatibilityMarkup
+};

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

@@ -0,0 +1,216 @@
+import {
+  attr,
+  child
+} from "./chunk-RAXJVM4U.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/shape-paths.ts
+import { SaxesParser } from "saxes";
+var coordinateLimit = 2147483647;
+function invalid() {
+  throw new OfficeError("invalid-value", "Invalid bounded shape path.", "usage");
+}
+function unsupported() {
+  throw new OfficeError(
+    "unsupported-edit",
+    "Geometry requires an unsupported geometry engine.",
+    "validate-intent"
+  );
+}
+function record(value, keys) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+    invalid();
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  if (Reflect.ownKeys(value).length !== keys.length || keys.some((k) => !descriptors[k] || !("value" in descriptors[k])))
+    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 coordinate(value) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || Math.abs(value) > coordinateLimit)
+    invalid();
+}
+function validateShapePath(path) {
+  record(path, ["unit", "width", "height", "commands"]);
+  if (path.unit !== "emu") invalid();
+  coordinate(path.width);
+  coordinate(path.height);
+  if (path.width <= 0 || path.height <= 0) invalid();
+  array(path.commands);
+  if (path.commands.length < 2) invalid();
+  let active = false, segments = 0;
+  for (const command of path.commands) {
+    if (!command || typeof command !== "object") invalid();
+    const type = Object.getOwnPropertyDescriptor(command, "type");
+    if (!type || !("value" in type)) invalid();
+    const keys = type.value === "close" ? [] : type.value === "move" || type.value === "line" ? ["x", "y"] : type.value === "quadratic" ? ["cx", "cy", "x", "y"] : type.value === "cubic" ? ["cx1", "cy1", "cx2", "cy2", "x", "y"] : null;
+    if (keys === null) invalid();
+    record(command, ["type", ...keys]);
+    for (const key of keys) coordinate(command[key]);
+    if (command.type === "move") {
+      if (active && !segments) invalid();
+      active = true;
+      segments = 0;
+    } else if (!active) invalid();
+    else if (command.type === "close") {
+      if (!segments) invalid();
+      active = false;
+    } else segments++;
+  }
+  if (active && !segments) invalid();
+}
+function pathFromVertices(vertices, close) {
+  array(vertices);
+  if (typeof close !== "boolean" || vertices.length < 2) invalid();
+  const commands = [];
+  let width = 1, height = 1;
+  const distinct = /* @__PURE__ */ new Set();
+  for (const vertex of vertices) {
+    let x, y;
+    if (Array.isArray(vertex)) {
+      array(vertex);
+      if (vertex.length !== 2) invalid();
+      [x, y] = vertex;
+    } else {
+      record(vertex, ["x", "y"]);
+      x = vertex.x;
+      y = vertex.y;
+    }
+    coordinate(x);
+    coordinate(y);
+    width = Math.max(width, x);
+    height = Math.max(height, y);
+    distinct.add(`${x},${y}`);
+    commands.push({ type: commands.length ? "line" : "move", x, y });
+  }
+  if (close) {
+    if (distinct.size < 3) invalid();
+    commands.push({ type: "close" });
+  }
+  const path = { unit: "emu", width, height, commands };
+  validateShapePath(path);
+  return path;
+}
+function geometry(node) {
+  const p = node.name.namespace;
+  const a = p === "http://schemas.openxmlformats.org/presentationml/2006/main" ? "http://schemas.openxmlformats.org/drawingml/2006/main" : p === "http://purl.oclc.org/ooxml/presentationml/main" ? "http://purl.oclc.org/ooxml/drawingml/main" : "";
+  if (!a || !["sp", "pic", "cxnSp"].includes(node.name.localName)) unsupported();
+  const props = child(node, "spPr"), custom = props && child(props, "custGeom", a);
+  return { a, props, custom };
+}
+function only(node, namespace, attrs, children) {
+  if (node.name.namespace !== namespace || node.attributes.some(
+    (v) => v.name.namespace !== "http://www.w3.org/2000/xmlns/" && (v.name.namespace !== "" || !attrs.includes(v.name.localName))
+  ) || node.children.some(
+    (v) => v.name.namespace !== namespace || !children.includes(v.name.localName)
+  ))
+    unsupported();
+}
+function literal(node, key) {
+  const value = attr(node, key);
+  if (value === void 0 || !value.length || Array.from(value).some((c, i) => !"0123456789".includes(c) && !(i === 0 && c === "-")))
+    unsupported();
+  const result = Number(value);
+  coordinate(result);
+  return result;
+}
+function readShapePath(document, node) {
+  const { a, custom } = geometry(node);
+  if (!custom) return { path: null, xml: null, unsupported: false };
+  const xml = document.markup(custom);
+  if (node.name.localName !== "sp") return { path: null, xml, unsupported: true };
+  try {
+    const parser = new SaxesParser();
+    parser.on("text", (text) => {
+      if (text.trim()) unsupported();
+    });
+    parser.on("cdata", (text) => {
+      if (text.trim()) unsupported();
+    });
+    parser.write(xml).close();
+    only(custom, a, [], ["avLst", "gdLst", "ahLst", "cxnLst", "pathLst"]);
+    for (const name of ["avLst", "gdLst", "ahLst", "cxnLst"]) {
+      const list2 = custom.children.filter((v) => v.name.localName === name);
+      if (list2.length > 1) unsupported();
+      for (const item of list2) only(item, a, [], []);
+    }
+    const lists = custom.children.filter((v) => v.name.localName === "pathLst");
+    if (lists.length !== 1) unsupported();
+    const list = lists[0];
+    only(list, a, [], ["path"]);
+    if (list.children.length !== 1) unsupported();
+    const path = list.children[0];
+    only(path, a, ["w", "h"], ["moveTo", "lnTo", "quadBezTo", "cubicBezTo", "close"]);
+    const commands = [];
+    for (const command of path.children) {
+      only(command, a, [], ["pt"]);
+      const expected = { moveTo: 1, lnTo: 1, quadBezTo: 2, cubicBezTo: 3, close: 0 }[command.name.localName];
+      if (command.children.length !== expected) unsupported();
+      const points = command.children.map((pt) => {
+        only(pt, a, ["x", "y"], []);
+        return { x: literal(pt, "x"), y: literal(pt, "y") };
+      });
+      const p = points.at(-1);
+      if (command.name.localName === "close") commands.push({ type: "close" });
+      else if (command.name.localName === "quadBezTo")
+        commands.push({ type: "quadratic", cx: points[0].x, cy: points[0].y, ...p });
+      else if (command.name.localName === "cubicBezTo")
+        commands.push({
+          type: "cubic",
+          cx1: points[0].x,
+          cy1: points[0].y,
+          cx2: points[1].x,
+          cy2: points[1].y,
+          ...p
+        });
+      else commands.push({ type: command.name.localName === "moveTo" ? "move" : "line", ...p });
+    }
+    const result = {
+      unit: "emu",
+      width: literal(path, "w"),
+      height: literal(path, "h"),
+      commands
+    };
+    validateShapePath(result);
+    return { path: result, xml, unsupported: false };
+  } catch (error) {
+    if (!(error instanceof OfficeError)) throw error;
+    return { path: null, xml, unsupported: true };
+  }
+}
+function shapePathXml(path, namespace) {
+  validateShapePath(path);
+  if (![
+    "http://schemas.openxmlformats.org/drawingml/2006/main",
+    "http://purl.oclc.org/ooxml/drawingml/main"
+  ].includes(namespace))
+    invalid();
+  const point = (x, y) => `<a:pt x="${x}" y="${y}"/>`;
+  const commands = path.commands.map(
+    (c) => c.type === "close" ? "<a:close/>" : c.type === "move" ? `<a:moveTo>${point(c.x, c.y)}</a:moveTo>` : c.type === "line" ? `<a:lnTo>${point(c.x, c.y)}</a:lnTo>` : c.type === "quadratic" ? `<a:quadBezTo>${point(c.cx, c.cy)}${point(c.x, c.y)}</a:quadBezTo>` : `<a:cubicBezTo>${point(c.cx1, c.cy1)}${point(c.cx2, c.cy2)}${point(c.x, c.y)}</a:cubicBezTo>`
+  ).join("");
+  return `<a:custGeom xmlns:a="${namespace}"><a:avLst/><a:gdLst/><a:ahLst/><a:cxnLst/><a:pathLst><a:path w="${path.width}" h="${path.height}">${commands}</a:path></a:pathLst></a:custGeom>`;
+}
+function applyShapePath(document, node, path) {
+  validateShapePath(path);
+  const { props, custom, a } = geometry(node);
+  if (!props || !custom || !readShapePath(document, node).path || props.children.filter(
+    (v) => v.name.namespace === a && ["custGeom", "prstGeom"].includes(v.name.localName)
+  ).length !== 1)
+    unsupported();
+  return document.spliceChildren(props, props.children.indexOf(custom), 1, [shapePathXml(path, a)]);
+}
+
+export {
+  validateShapePath,
+  pathFromVertices,
+  readShapePath,
+  shapePathXml,
+  applyShapePath
+};