@poe-platform/safe-bash 0.1.818 → 0.1.820

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

@@ -0,0 +1,495 @@
+import {
+  openRetainedPresentationIndex
+} from "./chunk-LZHFVNEV.js";
+import {
+  stageRetainedOutput,
+  streamJson
+} from "./chunk-R36PDP3L.js";
+import {
+  attr,
+  child,
+  invalid,
+  loadShared
+} from "./chunk-UDRJKA3P.js";
+import {
+  SelectionError
+} from "./chunk-SKF6PGA5.js";
+import {
+  openRetainedPresentationValidation
+} from "./chunk-SKDJCMGI.js";
+import {
+  OfficeError,
+  RetainedValues,
+  characters,
+  equal,
+  literal,
+  openRetainedXmlDocument,
+  resolveOfficeResources
+} from "./chunk-VJQ5OWS5.js";
+
+// packages/safe-bash-presentation-engine/src/transitions.ts
+import { SaxesParser } from "saxes";
+
+// packages/safe-bash-presentation-engine/src/retained-transitions.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+var durationNamespace = "http://schemas.microsoft.com/office/powerpoint/2010/main";
+var compatibilityNamespace = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+async function transitionRecord(document) {
+  async function local(node, name) {
+    return equal(document.raw(node.localName), literal(name));
+  }
+  async function same(node, parent) {
+    return equal(document.namespace(node), document.namespace(parent));
+  }
+  async function attr2(node, name, namespace = "") {
+    if (node) {
+      for await (const value of document.attributes(node)) if (await local(value, name) && await equal(document.namespace(value), literal(namespace))) return value;
+    }
+    return void 0;
+  }
+  async function token(node, tokens) {
+    if (node) {
+      for (const value of tokens) if (await equal(document.text(node), literal(value))) return value;
+    }
+    return void 0;
+  }
+  let direct, wrapped = false;
+  for await (const node of document.children(document.root)) if (node.kind === "element" && await same(node, document.root) && await local(node, "transition")) {
+    if (direct) throw new OfficeError("invalid-xml", "Multiple slide transitions.", "parse");
+    direct = node;
+  }
+  for await (const node of document.children(document.root)) {
+    if (node.kind !== "element" || direct && document.reference(node) === document.reference(direct) || await local(node, "cSld")) continue;
+    for await (const nested of document.elements(node)) if (await same(nested, document.root) && await local(nested, "transition")) {
+      wrapped = true;
+      break;
+    }
+    if (wrapped) break;
+  }
+  let kind = direct || wrapped ? "unsupported" : null, effect;
+  if (direct && !wrapped) {
+    let supported = true, sounds = 0, effects = 0;
+    for await (const value of document.attributes(direct)) {
+      const plain = await equal(document.namespace(value), literal(""));
+      let allowed = await equal(document.namespace(value), literal(compatibilityNamespace)) || await equal(document.namespace(value), literal(durationNamespace)) && await local(value, "dur");
+      if (plain) {
+        for (const key of ["advTm", "advClick", "spd"]) if (await local(value, key)) allowed = true;
+      }
+      if (!allowed) supported = false;
+    }
+    for await (const node of document.children(direct)) if (node.kind === "element") {
+      if (await same(node, direct) && await local(node, "sndAc")) sounds++;
+      else {
+        effects++;
+        if (effects === 1) effect = node;
+      }
+    }
+    if (sounds > 1 || effects !== 1 || !effect || !await same(effect, direct)) supported = false;
+    let candidate = "unsupported";
+    if (effect) {
+      for (const name of ["cut", "fade", "push", "wipe"]) if (await local(effect, name)) candidate = name;
+      for await (const node of document.children(effect)) if (node.kind === "element") supported = false;
+      for await (const value of document.attributes(effect)) {
+        const direction2 = candidate === "push" || candidate === "wipe";
+        if (!await equal(document.namespace(value), literal("")) || !await local(value, direction2 ? "dir" : "thruBlk") || await token(value, direction2 ? ["l", "r", "u", "d"] : ["0", "false"]) === void 0) supported = false;
+      }
+    }
+    if (supported) kind = candidate;
+  }
+  async function milliseconds2(node) {
+    if (!node) return null;
+    let started = false, trailing = false, digits = false, number = 0;
+    const invalid2 = () => {
+      throw new OfficeError("invalid-xml", "Invalid transition millisecond metadata.", "parse");
+    };
+    for await (const character of characters(document.text(node))) {
+      if (character.trim() === "") {
+        if (started) trailing = true;
+        continue;
+      }
+      if (trailing) invalid2();
+      if (!started && character === "+") {
+        started = true;
+        continue;
+      }
+      started = true;
+      if (character < "0" || character > "9") invalid2();
+      digits = true;
+      number = number * 10 + (character.charCodeAt(0) - 48);
+      if (number > 2147483647) invalid2();
+    }
+    if (!digits) invalid2();
+    return number;
+  }
+  const duration = await milliseconds2(await attr2(direct, "dur", durationNamespace)), advanceAfter = await milliseconds2(await attr2(direct, "advTm"));
+  const click = await attr2(direct, "advClick"), clickValue = await token(click, ["0", "1", "true", "false"]);
+  if (click && clickValue === void 0) throw new OfficeError("invalid-xml", "Invalid transition click metadata.", "parse");
+  let direction = null;
+  if (kind === "push" || kind === "wipe") {
+    const dir = await attr2(effect, "dir"), value = dir ? await token(dir, ["l", "r", "u", "d"]) : "l";
+    direction = { l: "left", r: "right", u: "up", d: "down" }[value] ?? null;
+  }
+  return { kind, direction, duration: kind === "cut" ? 0 : duration, advanceAfter, advanceOnClick: direct ? !["0", "false"].includes(clickValue ?? "true") : null };
+}
+async function openRetainedTransitions(archive, fingerprint, options, settings) {
+  if (!options || Object.keys(options).some((key) => key !== "selection")) throw new OfficeError("invalid-value", "Invalid transition query.", "usage");
+  const selection = options.selection ? { ...options.selection, kind: options.selection.kind ?? "slide", ...options.selection.position ? { position: { ...options.selection.position } } : {} } : void 0;
+  const context = { ...resolveOfficeResources(settings), workingStorage: { ...settings.workingStorage } }, signal = context.signal ?? new AbortController().signal;
+  const index = await openRetainedPresentationIndex(archive, fingerprint, context);
+  const pages = new PagedStorage({ fs: context.workingStorage.fs, cwd: context.workingStorage.directory, env: {}, signal }, (context.workingStorage.cacheBytes ?? 1024 * 1024) / 16384);
+  let closed = false, closing, head = 0, tail = 0, count = 0;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Transitions are closed.", "index");
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "index");
+  };
+  const close = () => {
+    closed = true;
+    return closing ??= (async () => {
+      const results = await Promise.allSettled([index.close(), pages.close()]);
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    })();
+  };
+  const failure = (error) => error instanceof OfficeError ? error : new OfficeError(signal.aborted ? "cancelled" : "io-failure", "Transition storage operation failed.", "index");
+  const values = new RetainedValues(pages, check, signal);
+  async function write(pointer, numbers) {
+    const bytes = new Uint8Array(numbers.length * 8), view = new DataView(bytes.buffer);
+    numbers.forEach((number, n) => view.setFloat64(n * 8, number, true));
+    await pages.write(pointer, bytes);
+  }
+  try {
+    const validation = await openRetainedPresentationValidation(archive, context, { ...context.xmlLimits, ...context.relationshipLimits, maxBytes: Math.min(context.xmlLimits.maxBytes, context.relationshipLimits.maxBytes), maxEntries: context.archiveLimits.maxMembers });
+    const valid = validation.valid;
+    try {
+      await validation.close();
+    } catch (error) {
+      if (valid) await Promise.reject(error);
+    }
+    if (!valid) throw new OfficeError("invalid-opc", "Invalid presentation graph.", "validate-intent");
+    if (selection) {
+      for await (const record2 of index.records.select(selection)) if (record2.kind !== "slide") throw new SelectionError("invalid-selection");
+    }
+    for await (const record2 of selection ? index.records.select(selection) : index.records.records("slide")) {
+      const document = await openRetainedXmlDocument(archive.read(record2.part), context);
+      let failed = false;
+      try {
+        const formatting = await transitionRecord(document);
+        const value = { selector: record2.token, location: record2.location, slide: record2.position, part: record2.part, ...formatting };
+        const stored = await values.store(literal(JSON.stringify(value))), pointer = pages.allocate(24);
+        await write(pointer, [0, stored.start, stored.length]);
+        if (tail) await write(tail, [pointer]);
+        else head = pointer;
+        tail = pointer;
+        count++;
+      } catch (error) {
+        failed = true;
+        throw error;
+      } finally {
+        try {
+          await document.close();
+        } catch (error) {
+          if (!failed) await Promise.reject(error);
+        }
+      }
+    }
+    await index.close();
+    check();
+    return Object.freeze({ close, count, async *records() {
+      try {
+        check();
+        for (let pointer = head; pointer; ) {
+          const bytes = await pages.read(pointer, 24), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+          pointer = view.getFloat64(0, true);
+          let json = "";
+          const decoder = new TextDecoder();
+          for await (const chunk of values.read({ start: view.getFloat64(8, true), length: view.getFloat64(16, true) })) json += decoder.decode(chunk, { stream: true });
+          check();
+          yield JSON.parse(json + decoder.decode());
+        }
+        check();
+      } catch (error) {
+        throw failure(error);
+      }
+    } });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw failure(error);
+  }
+}
+async function stageRetainedTransitions(archive, fingerprint, options, settings, output) {
+  const format = { ...output }, reader = await openRetainedTransitions(archive, fingerprint, options, settings);
+  let staged;
+  async function* locations() {
+    for await (const record2 of reader.records()) yield record2.location;
+  }
+  async function* items() {
+    for await (const record2 of reader.records()) if (record2.kind !== null) yield { location: record2.location, kind: record2.kind, name: null, fields: ["direction", "duration", "advanceAfter", "advanceOnClick"].map((name) => ({ name, value: { type: record2[name] === null ? "null" : typeof record2[name], value: record2[name] } })) };
+  }
+  async function* render() {
+    if (format.json) {
+      yield* streamJson({ version: 1, operation: format.operation, ok: true, data: { items: items() }, warnings: [], errors: [], affected: 0, locations: locations() });
+      yield* literal("\n");
+    } else for await (const record2 of reader.records()) if (record2.kind !== null) yield* literal(`Slide ${record2.slide}: ${record2.kind}${record2.direction ? " " + record2.direction : ""}
+  Duration: ${record2.duration === null ? "unspecified" : record2.duration + " ms"}
+  Advance: ${record2.advanceAfter === null ? "manual" : record2.advanceAfter + " ms"}; click: ${record2.advanceOnClick === null ? "unspecified" : record2.advanceOnClick ? "enabled" : "disabled"}
+`);
+  }
+  try {
+    if (format.operation === "transitions.get" && reader.count !== 1) throw new SelectionError(reader.count ? "ambiguous-selection" : "missing-selection");
+    staged = await stageRetainedOutput(render(), settings, format.maxOutputBytes);
+    await reader.close();
+    return staged;
+  } catch (error) {
+    await Promise.allSettled([reader.close(), staged?.close()]);
+    throw error;
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/transitions.ts
+var durationNamespace2 = "http://schemas.microsoft.com/office/powerpoint/2010/main";
+var compatibilityNamespace2 = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+var directions = { left: "l", right: "r", up: "u", down: "d" };
+var kinds = ["cut", "fade", "push", "wipe"];
+function unsupported() {
+  throw new OfficeError(
+    "unsupported-edit",
+    "Unsupported transition content is preserve-only.",
+    "validate-intent"
+  );
+}
+function milliseconds(value) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 2147483647)
+    invalid("Transition times must be integer milliseconds in 0..2147483647.");
+}
+function validateTransitionOptions(action, options) {
+  if (!["add", "set", "remove"].includes(action) || !options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Object.keys(options).some(
+    (k) => ![
+      "selection",
+      "kind",
+      "direction",
+      "duration",
+      "advanceAfter",
+      "advanceOnClick",
+      "allowEmpty"
+    ].includes(k)
+  ))
+    invalid("Invalid transition options.");
+  if (action === "set" && [
+    options.kind,
+    options.direction,
+    options.duration,
+    options.advanceAfter,
+    options.advanceOnClick
+  ].every((v) => v === void 0))
+    invalid("Setting a transition requires an update.");
+  if (options.kind !== void 0 && !kinds.includes(options.kind))
+    invalid("Unsupported transition kind.");
+  if (action === "add" && options.kind === void 0)
+    invalid("Adding a transition requires a kind.");
+  if (action === "remove" && [
+    options.kind,
+    options.direction,
+    options.duration,
+    options.advanceAfter,
+    options.advanceOnClick
+  ].some((v) => v !== void 0))
+    invalid("Removal accepts no transition settings.");
+  if (options.direction !== void 0 && (typeof options.direction !== "string" || !Object.hasOwn(directions, options.direction)))
+    invalid("Invalid transition direction.");
+  if (options.duration !== void 0) milliseconds(options.duration);
+  if (options.advanceAfter !== void 0 && options.advanceAfter !== null)
+    milliseconds(options.advanceAfter);
+  if (options.advanceOnClick !== void 0 && typeof options.advanceOnClick !== "boolean")
+    invalid("Click advance requires a boolean.");
+  if (options.allowEmpty !== void 0 && typeof options.allowEmpty !== "boolean")
+    invalid("allowEmpty requires a boolean.");
+  if ((options.kind === "cut" || options.kind === "fade") && options.direction !== void 0)
+    invalid("Cut and fade forbid direction.");
+  if ((options.kind === "push" || options.kind === "wipe") && options.direction === void 0)
+    invalid("Push and wipe require direction.");
+  if (options.kind === "cut" && options.duration !== void 0 && options.duration !== 0)
+    invalid("Cut duration must be zero.");
+}
+function transition(doc) {
+  if (doc.root.children.filter(
+    (n) => n.name.namespace === doc.root.name.namespace && n.name.localName === "transition"
+  ).length > 1)
+    throw new OfficeError("invalid-xml", "Multiple slide transitions.", "parse");
+  const direct = child(doc.root, "transition");
+  const wrapped = doc.root.children.some(
+    (n) => n !== direct && n.name.localName !== "cSld" && containsTransition(n, doc.root.name.namespace)
+  );
+  return { direct, wrapped };
+}
+function containsTransition(node, ns) {
+  return node.name.namespace === ns && node.name.localName === "transition" || node.children.some((n) => containsTransition(n, ns));
+}
+function effectKind(node) {
+  if (node.attributes.some(
+    (a) => !(a.name.namespace === "" && ["advTm", "advClick", "spd"].includes(a.name.localName) || a.name.namespace === durationNamespace2 && a.name.localName === "dur" || a.name.namespace === compatibilityNamespace2)
+  ) || node.children.filter(
+    (n) => n.name.namespace === node.name.namespace && n.name.localName === "sndAc"
+  ).length > 1)
+    return "unsupported";
+  const effects = node.children.filter(
+    (n) => n.name.namespace !== node.name.namespace || n.name.localName !== "sndAc"
+  );
+  const effect = effects[0];
+  if (effects.length !== 1 || !effect || effect.name.namespace !== node.name.namespace || !kinds.includes(effect.name.localName) || effect.children.length)
+    return "unsupported";
+  const kind = effect.name.localName;
+  if (effect.attributes.some(
+    (a) => a.name.namespace !== "" || !(kind === "push" || kind === "wipe" ? a.name.localName === "dir" && Object.values(directions).includes(a.value) : a.name.localName === "thruBlk" && ["0", "false"].includes(a.value))
+  ))
+    return "unsupported";
+  return kind;
+}
+function record(doc, selected) {
+  const { direct: node, wrapped } = transition(doc), kind = wrapped ? "unsupported" : node ? effectKind(node) : null;
+  const effect = node?.children.find(
+    (n) => n.name.localName === kind && n.name.namespace === node.name.namespace
+  );
+  const dir = effect ? attr(effect, "dir") : void 0;
+  const duration = node?.attributes.find(
+    (a) => a.name.namespace === durationNamespace2 && a.name.localName === "dur"
+  )?.value;
+  for (const value of [duration, node && attr(node, "advTm")])
+    if (value !== void 0 && (value.trim() === "" || ![...value.trim().startsWith("+") ? value.trim().slice(1) : value.trim()].every(
+      (c) => c >= "0" && c <= "9"
+    ) || !Number.isInteger(Number(value)) || Number(value) < 0 || Number(value) > 2147483647))
+      throw new OfficeError("invalid-xml", "Invalid transition millisecond metadata.", "parse");
+  if (node && attr(node, "advClick") !== void 0 && !["0", "1", "true", "false"].includes(attr(node, "advClick")))
+    throw new OfficeError("invalid-xml", "Invalid transition click metadata.", "parse");
+  return {
+    selector: selected.token,
+    location: selected.location,
+    slide: selected.position,
+    part: selected.part,
+    kind,
+    direction: kind === "push" || kind === "wipe" ? Object.entries(directions).find(
+      ([, v]) => v === (dir ?? "l")
+    )?.[0] ?? null : null,
+    duration: kind === "cut" ? 0 : duration === void 0 ? null : Number(duration),
+    advanceAfter: node && attr(node, "advTm") !== void 0 ? Number(attr(node, "advTm")) : null,
+    advanceOnClick: node ? !["0", "false"].includes(attr(node, "advClick") ?? "true") : null
+  };
+}
+function selectedSlides(s, selection) {
+  const selected = s.index.select({ ...selection, kind: selection.kind ?? "slide" });
+  if (selected.some((n) => n.kind !== "slide")) throw new SelectionError("invalid-selection");
+  return selected;
+}
+async function readTransitions(input, options, context) {
+  if (!options || Object.keys(options).some((k) => k !== "selection"))
+    invalid("Invalid transition query.");
+  const s = await loadShared(input, context, false);
+  const selected = options.selection ? selectedSlides(s, options.selection) : s.index.slides;
+  return selected.map((n) => record(s.doc(n.part), n));
+}
+function exactDuration(doc, duration) {
+  let node = child(doc.root, "transition");
+  doc = doc.merge(node, {
+    attributes: [{ namespace: durationNamespace2, localName: "dur", value: String(duration) }]
+  });
+  node = child(doc.root, "transition");
+  let prefix = "";
+  const parser = new SaxesParser({ xmlns: true });
+  parser.on("opentag", (tag) => {
+    if (tag.local === "transition" && tag.uri === node.name.namespace)
+      prefix = Object.values(tag.attributes).find((a) => a.uri === durationNamespace2 && a.local === "dur")?.prefix ?? "";
+  });
+  parser.write(doc.markup(node, true)).close();
+  const existing = node.attributes.find(
+    (a) => a.name.namespace === compatibilityNamespace2 && a.name.localName === "Ignorable"
+  )?.value ?? "";
+  return doc.merge(node, {
+    attributes: [
+      {
+        namespace: compatibilityNamespace2,
+        localName: "Ignorable",
+        value: [...new Set(`${existing} ${prefix}`.split(" ").filter(Boolean))].join(" ")
+      }
+    ]
+  });
+}
+async function mutateTransitions(input, action, options, context) {
+  validateTransitionOptions(action, options);
+  if (!options.selection) throw new SelectionError("invalid-selection");
+  const s = await loadShared(input, context);
+  let selected;
+  try {
+    selected = selectedSlides(s, options.selection);
+  } catch (error) {
+    if (!(error instanceof SelectionError) || error.code !== "missing-selection" || !options.allowEmpty)
+      throw error;
+    selected = [];
+  }
+  if (action === "add" && selected.length > 1) throw new SelectionError("ambiguous-selection");
+  const affected = [];
+  for (const slide of selected) {
+    let doc = s.doc(slide.part);
+    const { direct, wrapped } = transition(doc);
+    let node = direct;
+    if (wrapped || node && effectKind(node) === "unsupported") unsupported();
+    if (action === "add" && node) invalid("A transition already exists.");
+    if (action === "remove") {
+      if (!node) continue;
+      affected.push(slide.position);
+      if (node) doc = doc.spliceChildren(doc.root, doc.root.children.indexOf(node), 1, []);
+      s.save(slide.part, doc);
+      continue;
+    }
+    const current = record(doc, slide), kind = options.kind ?? current.kind;
+    if (!kind || kind === "unsupported") invalid("Creating a transition requires a kind.");
+    const directional = kind === "push" || kind === "wipe";
+    const direction = options.direction ?? (directional && current.kind === kind ? current.direction : void 0);
+    if (directional && !direction || !directional && options.direction !== void 0)
+      invalid("Transition direction conflicts with its kind.");
+    if (kind === "cut" && options.duration !== void 0 && options.duration !== 0)
+      invalid("Cut duration must be zero.");
+    const duration = kind === "cut" ? 0 : options.duration ?? (!node || current.kind === "cut" ? 500 : void 0);
+    if (!node) {
+      const before = doc.root.children.findIndex(
+        (n) => n.name.namespace === s.p && ["timing", "extLst"].includes(n.name.localName)
+      );
+      doc = doc.spliceChildren(doc.root, before < 0 ? doc.root.children.length : before, 0, [
+        `<p:transition xmlns:p="${s.p}" advClick="1"/>`
+      ]);
+      node = child(doc.root, "transition");
+    }
+    if (options.kind !== void 0 || options.direction !== void 0 || !node.children.length) {
+      const effect = node.children.find(
+        (n) => n.name.namespace === s.p && kinds.includes(n.name.localName)
+      );
+      doc = doc.spliceChildren(node, effect ? node.children.indexOf(effect) : 0, effect ? 1 : 0, [
+        `<p:${kind} xmlns:p="${s.p}"${directional ? ` dir="${directions[direction]}"` : ""}/>`
+      ]);
+      node = child(doc.root, "transition");
+    }
+    doc = doc.merge(node, {
+      attributes: [
+        ...options.advanceAfter === void 0 ? [] : [
+          {
+            namespace: "",
+            localName: "advTm",
+            value: options.advanceAfter === null ? null : String(options.advanceAfter)
+          }
+        ],
+        ...options.advanceOnClick === void 0 ? [] : [{ namespace: "", localName: "advClick", value: options.advanceOnClick ? "1" : "0" }]
+      ]
+    });
+    if (duration !== void 0) doc = exactDuration(doc, duration);
+    s.save(slide.part, doc);
+    affected.push(slide.position);
+  }
+  if (!affected.length && !options.allowEmpty) throw new SelectionError("missing-selection");
+  return s.finish(selected[0]?.part ?? s.main, affected);
+}
+
+export {
+  openRetainedTransitions,
+  stageRetainedTransitions,
+  validateTransitionOptions,
+  readTransitions,
+  mutateTransitions
+};

package/dist/safe-bash/command-chunks/{chunk-HQEYSSZV.js → chunk-JLS6XKAR.js}

@@ -4,7 +4,7 @@ import {
   openRetainedXml,
   openRetainedXmlDocument,
   resolveOfficeResources
-} from "./chunk-KM2SMMXZ.js";
+} from "./chunk-VJQ5OWS5.js";
 
 // packages/office-xml/src/retained-xml-edits.ts
 import { PagedStorage } from "@poe-platform/safe-fs/storage";

package/dist/safe-bash/command-chunks/{chunk-IJE65P52.js → chunk-JMUB5A26.js}

@@ -668,6 +668,12 @@ async function evaluateExpression(program, node, position, last, budget, select)
             break;
           }
           result = selected?.kind === "element" || selected?.kind === "attribute" ? instruction.name === "name" ? selected.value.name : instruction.name === "local-name" ? selected.value.localName : selected.value.namespace : selected?.kind === "processing-instruction" && instruction.name !== "namespace-uri" ? selected.value.kind === "processing-instruction" ? selected.value.target : "" : "";
+          if (instruction.name === "namespace-uri" && selected?.stored && (selected.kind === "element" || selected.kind === "attribute"))
+            result = await TextValue.create(selected.stored.document.namespaceText(selected.value), budget, storage);
+          else if (instruction.name !== "namespace-uri" && selected?.stored && (selected.kind === "element" || selected.kind === "attribute"))
+            result = await TextValue.create(selected.stored.document.nameText(selected.value, instruction.name === "local-name"), budget, storage);
+          else if (instruction.name !== "namespace-uri" && selected?.stored && selected.kind === "processing-instruction" && selected.value.kind === "processing-instruction")
+            result = await TextValue.create(selected.stored.document.targetText(selected.value), budget, storage);
           break;
         }
       }
@@ -900,7 +906,8 @@ async function evaluatePaths(query, tree, budget, context) {
 async function* stringValue(node, budget) {
   if (node === void 0) return;
   if (node.kind === "attribute") {
-    yield node.value.value;
+    if (node.stored) yield* node.stored.document.text(node.stored.reference);
+    else yield node.value.value;
     return;
   }
   if (node.stored) {
@@ -947,8 +954,12 @@ async function* serialize(node, budget) {
     return;
   }
   if (node.kind === "attribute") {
-    yield ` ${node.value.name}="`;
-    yield* escape(node.value.value, true, budget);
+    if (node.stored) {
+      yield " ";
+      yield* node.stored.document.nameText(node.value);
+      yield '="';
+    } else yield ` ${node.value.name}="`;
+    for await (const part of stringValue(node, budget)) yield* escape(part, true, budget);
     yield '"';
     return;
   }
@@ -964,15 +975,22 @@ async function* serialize(node, budget) {
           break;
         }
         if (event.closing) {
-          if (hasChildren) yield `</${value.name}>`;
+          if (hasChildren) {
+            yield "</";
+            yield* document.nameText(value);
+            yield ">";
+          }
           continue;
         }
-        yield `<${value.name}`;
+        yield "<";
+        yield* document.nameText(value);
         for await (const attribute of document.attributes(event.reference)) {
           const p = budget.tick();
           if (p) await p;
-          yield ` ${attribute.name}="`;
-          yield* escape(attribute.value, true, budget);
+          yield " ";
+          yield* document.nameText(attribute);
+          yield '="';
+          for await (const part of document.attributeText(attribute)) yield* escape(part, true, budget);
           yield '"';
         }
         yield hasChildren ? ">" : "/>";
@@ -988,7 +1006,8 @@ async function* serialize(node, budget) {
           yield* document.text(event.reference);
           yield "-->";
         } else if (value.kind === "processing-instruction") {
-          yield `<?${value.target}`;
+          yield "<?";
+          yield* document.targetText(value);
           if (value.text) {
             yield " ";
             yield* document.text(event.reference);

package/dist/safe-bash/command-chunks/{chunk-IJZUUXLL.js → chunk-JQPDVCBU.js}

@@ -1,25 +1,25 @@
 import {
   nodeFor
-} from "./chunk-YW7WU7W2.js";
+} from "./chunk-4HJEZGYN.js";
 import {
   TextFrame,
   applyFrameFormatting,
   readShape
-} from "./chunk-NZF56C25.js";
+} from "./chunk-64L57DEI.js";
 import {
   Length
-} from "./chunk-B6XTAKKQ.js";
+} from "./chunk-GNVAW6NL.js";
 import {
   attr,
   child,
   required
-} from "./chunk-A32PUWYE.js";
+} from "./chunk-UDRJKA3P.js";
 import {
   parseXmlPart
-} from "./chunk-7PYDVQPB.js";
+} from "./chunk-YWP62BAZ.js";
 import {
   OfficeError
-} from "./chunk-KM2SMMXZ.js";
+} from "./chunk-VJQ5OWS5.js";
 
 // packages/safe-bash-presentation-engine/src/tables.ts
 import { SaxesParser } from "saxes";

package/dist/safe-bash/command-chunks/{chunk-EBKKYRQJ.js → chunk-JSW6YH6T.js}

@@ -3,29 +3,29 @@ import {
   readShapePath,
   shapePathXml,
   validateShapePath
-} from "./chunk-R6X63VAO.js";
+} from "./chunk-BSLXS4PE.js";
 import {
   addShape,
   nodeFor,
   selected,
   validateSelection
-} from "./chunk-YW7WU7W2.js";
+} from "./chunk-4HJEZGYN.js";
 import {
   validateShapeOptions
-} from "./chunk-NZF56C25.js";
+} from "./chunk-64L57DEI.js";
 import {
   Length
-} from "./chunk-B6XTAKKQ.js";
+} from "./chunk-GNVAW6NL.js";
 import {
   loadShared,
   required
-} from "./chunk-A32PUWYE.js";
+} from "./chunk-UDRJKA3P.js";
 import {
   SelectionError
-} from "./chunk-3W3HLPCX.js";
+} from "./chunk-SKF6PGA5.js";
 import {
   OfficeError
-} from "./chunk-KM2SMMXZ.js";
+} from "./chunk-VJQ5OWS5.js";
 
 // packages/safe-bash-presentation-engine/src/shape-path-operations.ts
 function optionsFor(options, adding = false) {

package/dist/safe-bash/command-chunks/{chunk-YJ5IA5YQ.js → chunk-K576GZED.js}

@@ -1,15 +1,15 @@
 import {
   extendedPattern
-} from "./chunk-F5QYUK2E.js";
+} from "./chunk-UWIDPTOB.js";
 import {
   describe
-} from "./chunk-VWRHPDCD.js";
+} from "./chunk-ZIDESNHW.js";
 import {
   JqError,
   JqLimitError,
   object,
   put
-} from "./chunk-5VO534FR.js";
+} from "./chunk-3K5FCRUG.js";
 import {
   utf8ByteLength
 } from "./chunk-KK2T6Z7J.js";