@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,353 @@
+import {
+  CancellationError,
+  DocumentBudget,
+  DocumentError,
+  InputTypeError,
+  InvalidValueError,
+  ResourceLimitError,
+  documentXmlCache,
+  reservedWorkTurn
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/package-xml.ts
+import { parseXmlSteps, XmlLimitError } from "@poe-platform/safe-fs/xml";
+
+// packages/safe-bash-docx-engine/src/media-type.ts
+function parseMediaType(value, mode = "essence") {
+  let at = 0;
+  const invalid = () => {
+    throw new InvalidPackageError("Invalid OPC media type.");
+  };
+  const token = () => {
+    const start = at;
+    while (at < value.length) {
+      const char = value[at];
+      if (!(char >= "A" && char <= "Z" || char >= "a" && char <= "z" || char >= "0" && char <= "9" || "!#$%&'*+-.^_`|~".includes(char))) break;
+      at++;
+    }
+    if (at === start) invalid();
+    return value.slice(start, at);
+  };
+  token();
+  if (value[at++] !== "/") invalid();
+  token();
+  const essence = value.slice(0, at).toLowerCase();
+  const parameters = at < value.length;
+  const identity = [];
+  while (at < value.length) {
+    while (value[at] === " " || value[at] === "	") at++;
+    if (value[at++] !== ";") invalid();
+    while (value[at] === " " || value[at] === "	") at++;
+    const name = token().toLowerCase();
+    if (value[at++] !== "=") invalid();
+    let parameter;
+    if (value[at] !== '"') parameter = token();
+    else {
+      at++;
+      parameter = "";
+      let closed = false;
+      while (at < value.length) {
+        let char = value[at++];
+        const code = char.charCodeAt(0);
+        if (char === '"') {
+          closed = true;
+          break;
+        }
+        if (char === "\\") {
+          const escaped = value.charCodeAt(at);
+          if (!(escaped === 9 || escaped >= 32 && escaped <= 126 || escaped >= 160 && escaped <= 255)) invalid();
+          char = value[at++];
+        } else if (!(code === 9 || code === 32 || code === 33 || code >= 35 && code <= 91 || code >= 93 && code <= 126 || code >= 160 && code <= 255)) invalid();
+        if (mode === "identity") parameter += char;
+      }
+      if (!closed) invalid();
+    }
+    if (mode === "identity") identity.push([name, name === "charset" || essence === "message/external-body" && name === "access-type" ? parameter.toLowerCase() : parameter]);
+  }
+  if (parameters && ["core-properties+xml", "digital-signature-certificate", "digital-signature-origin", "digital-signature-xmlsignature+xml", "relationships+xml"].some((type) => essence === "application/vnd.openxmlformats-package." + type))
+    throw new InvalidPackageError("OPC-specific media types cannot have parameters.");
+  return mode === "identity" ? JSON.stringify([essence, identity.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)]) : essence;
+}
+
+// packages/safe-bash-docx-engine/src/package-xml.ts
+function isXmlContentType(contentType) {
+  const type = parseMediaType(contentType);
+  return type === "application/xml" || type === "text/xml" || type.endsWith("+xml");
+}
+var InvalidPackageError = class extends DocumentError {
+  constructor(message, part, location = "/", diagnosticCode = "package-structure") {
+    super(message);
+    this.part = part;
+    this.location = location;
+    this.diagnosticCode = diagnosticCode;
+  }
+  part;
+  location;
+  diagnosticCode;
+};
+var InvalidXmlError = class extends DocumentError {
+  code = "invalid-xml";
+};
+var UnsupportedProfileError = class extends DocumentError {
+  code = "unsupported-profile";
+};
+function documentXmlSettings(options, budget = new DocumentBudget()) {
+  if (!options || typeof options !== "object" || Array.isArray(options))
+    throw new InvalidValueError("Expected an XML limits object.");
+  const limits = {
+    maxBytes: budget.limits.xmlPartBytes,
+    maxDepth: budget.limits.xmlDepth,
+    maxNodes: budget.limits.xmlNodes,
+    maxContentNodes: budget.limits.xmlNodes,
+    maxAttributes: budget.limits.xmlNodes,
+    maxAttributesPerElement: Infinity,
+    maxNamespaces: Infinity,
+    maxTextLength: budget.limits.xmlPartBytes,
+    maxWork: budget.limits.work
+  };
+  for (const [key, value] of Object.entries(options)) {
+    if (!Object.hasOwn(limits, key)) throw new InvalidValueError("Unknown XML limit.");
+    if (value === void 0) continue;
+    if (typeof value !== "number" || value !== Infinity && !Number.isSafeInteger(value) || value < 1)
+      throw new InvalidValueError("XML limits must be positive safe integers.");
+    limits[key] = value;
+  }
+  return limits;
+}
+function* documentXmlSteps(input, options, budget, reservations) {
+  if (!(input instanceof Uint8Array)) throw new InputTypeError("Expected XML bytes.");
+  const limits = documentXmlSettings(options, budget);
+  if (input.byteLength > limits.maxBytes || input.byteLength > limits.maxWork)
+    throw new ResourceLimitError("XML byte or work limit exceeded.");
+  budget.charge("retainedBytes", input.byteLength * 16);
+  reservations.retainedBytes += input.byteLength * 16;
+  const bytes = new Uint8Array(input);
+  const encoding = bytes[0] === 255 && bytes[1] === 254 ? "UTF-16LE" : bytes[0] === 254 && bytes[1] === 255 ? "UTF-16BE" : "UTF-8";
+  const bom = encoding !== "UTF-8" || bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191;
+  try {
+    const decoder = new TextDecoder(encoding, { fatal: true, ignoreBOM: true });
+    const chunks = [];
+    for (let offset = 0; offset < bytes.length; offset += 4096) {
+      yield Math.min(4096, bytes.length - offset);
+      chunks.push(decoder.decode(bytes.subarray(offset, offset + 4096), { stream: true }));
+    }
+    chunks.push(decoder.decode());
+    const remaining = budget.limits.xmlNodes - budget.usage.xmlNodes;
+    if (remaining < 1) throw new ResourceLimitError("XML node limit exceeded.");
+    const parserLimits = {
+      ...limits,
+      maxNodes: Math.min(limits.maxNodes, remaining),
+      maxContentNodes: Math.min(limits.maxContentNodes, remaining),
+      maxAttributes: Math.min(limits.maxAttributes, remaining)
+    };
+    const parser = parseXmlSteps(chunks.join(""), {
+      ...Object.fromEntries(Object.entries(parserLimits).filter(([, value]) => value !== Infinity)),
+      expectedEncoding: encoding,
+      onElement: () => {
+        budget.charge("xmlNodes", 1);
+        reservations.xmlNodes++;
+      }
+    });
+    let work = bytes.length;
+    try {
+      while (true) {
+        const result = parser.next();
+        if (result.done) {
+          const stack = [result.value];
+          while (stack.length) {
+            const element = stack.pop();
+            if (element.attributes.length) {
+              budget.charge("xmlNodes", element.attributes.length);
+              reservations.xmlNodes += element.attributes.length;
+            }
+            const lists = [element.content];
+            if (element.prolog) lists.push(element.prolog);
+            if (element.epilog) lists.push(element.epilog);
+            for (const content of lists) {
+              for (const node of content) {
+                if (++work > limits.maxWork) throw new ResourceLimitError("XML work limit exceeded.");
+                if (node.kind === "element") {
+                  if (node.attributes.length || node.content.length || node.prolog?.length || node.epilog?.length) stack.push(node);
+                } else {
+                  budget.charge("xmlNodes", 1);
+                  reservations.xmlNodes++;
+                }
+                yield 1;
+              }
+            }
+          }
+          return { bytes, encoding, bom, root: result.value };
+        }
+        if (result.value > limits.maxWork - work) throw new ResourceLimitError("XML work limit exceeded.");
+        work += result.value;
+        yield result.value;
+      }
+    } finally {
+      parser.return(void 0);
+    }
+  } catch (error) {
+    if (error instanceof ResourceLimitError || error instanceof CancellationError) throw error;
+    if (error instanceof XmlLimitError) throw new ResourceLimitError("XML structural or text limit exceeded.");
+    throw new InvalidXmlError("Malformed, unsupported encoding or prohibited document XML.");
+  }
+}
+function cachedDocumentXml(input, options, budget, cooperative = false) {
+  const entries = budget[documentXmlCache].entries;
+  if (!entries) return {};
+  if (!(input instanceof Uint8Array)) throw new InputTypeError("Expected XML bytes.");
+  const limits = documentXmlSettings(options, budget);
+  budget.check("work", 0);
+  if (input.length > limits.maxBytes || input.length > limits.maxWork)
+    throw new ResourceLimitError("XML byte or work limit exceeded.");
+  budget.charge("work", input.length);
+  let hash = 2166136261;
+  for (let index = 0; index < input.length; index++) hash = Math.imul(hash ^ input[index], 16777619) >>> 0;
+  const key = `${JSON.stringify({ ...limits, maxNodes: 0, maxBytes: 0 })}:${input.length}:${hash}`;
+  for (const candidate of entries.get(key) ?? []) {
+    budget.charge("work", input.length * 2);
+    let equal = candidate.document.bytes.length === candidate.source.length;
+    for (let index = 0; equal && index < input.length; index++)
+      equal = candidate.source[index] === input[index] && candidate.document.bytes[index] === candidate.source[index];
+    if (equal) {
+      if (candidate.elements > limits.maxNodes)
+        throw new ResourceLimitError("XML structural or text limit exceeded.");
+      const replay = candidate.replay ?? (candidate.maxNodes !== limits.maxNodes || candidate.maxBytes !== limits.maxBytes ? candidate.parseCost : void 0);
+      if (replay) {
+        budget.charge("retainedBytes", replay.retainedBytes);
+        if (!cooperative) budget.charge("work", replay.work);
+        budget.charge("xmlNodes", replay.xmlNodes);
+      }
+      return { key, document: candidate.document, ...cooperative && replay ? { replayWork: replay.work } : {} };
+    }
+  }
+  if (budget[documentXmlCache].staged?.has(input)) return { key, maxNodes: limits.maxNodes, maxBytes: limits.maxBytes, staged: true };
+  return budget[documentXmlCache].admitted?.has(input) ? { key, maxNodes: limits.maxNodes, maxBytes: limits.maxBytes } : {};
+}
+function retainDocumentXml(key, document, budget, reservations, maxNodes, maxBytes, staged = false) {
+  if (key !== void 0) {
+    const beforeRetention = budget.usage;
+    const parseCost = Object.freeze({ ...reservations });
+    const entries = budget[documentXmlCache].entries;
+    budget.charge("retainedBytes", key.length * 2 + 136 + document.bytes.length);
+    budget.charge("work", document.bytes.length);
+    const namespaces = /* @__PURE__ */ new Map();
+    const pending = [document.root];
+    let elements = 0;
+    while (pending.length) {
+      const node = pending.pop();
+      budget.charge("work", 1);
+      if (node.kind === "element") {
+        elements++;
+        let view = namespaces.get(node.namespaces);
+        if (!view) {
+          budget.charge("retainedBytes", 128 + node.namespaces.size * 64);
+          const owned = Object.freeze(new Map(node.namespaces));
+          view = new Proxy(owned, {
+            get(target, name, receiver) {
+              if (name === "set" || name === "delete" || name === "clear") return void 0;
+              if (name === "size") return target.size;
+              if (name === "forEach") return (callback, thisArg) => {
+                if (typeof callback !== "function") throw new InputTypeError("Expected a namespace callback.");
+                for (const [prefix, uri] of target) callback.call(thisArg, uri, prefix, receiver);
+              };
+              if (["get", "has", "keys", "values", "entries", Symbol.iterator].includes(name))
+                return Reflect.get(target, name, target).bind(target);
+              return Reflect.get(target, name, receiver);
+            }
+          });
+          namespaces.set(node.namespaces, view);
+        }
+        node.namespaces = view;
+        for (const attribute of node.attributes) Object.freeze(attribute);
+        Object.freeze(node.content);
+        Object.freeze(node.children);
+        Object.freeze(node.attributes);
+        if (node.prolog) Object.freeze(node.prolog);
+        if (node.epilog) Object.freeze(node.epilog);
+        budget.charge("retainedBytes", (node.content.length + (node.prolog?.length ?? 0) + (node.epilog?.length ?? 0)) * 8);
+        for (const child of node.content) pending.push(child);
+        if (node.prolog) for (const child of node.prolog) pending.push(child);
+        if (node.epilog) for (const child of node.epilog) pending.push(child);
+      }
+      Object.freeze(node);
+    }
+    Object.freeze(document);
+    budget.charge("retainedBytes", 64);
+    (budget[documentXmlCache].immutableRoots ??= /* @__PURE__ */ new WeakSet()).add(document.root);
+    const bucket = entries.get(key) ?? [];
+    const usage = budget.usage;
+    bucket.push({ document, source: new Uint8Array(document.bytes), maxNodes, maxBytes, elements, parseCost, ...staged ? { replay: {
+      xmlNodes: parseCost.xmlNodes + usage.xmlNodes - beforeRetention.xmlNodes,
+      work: parseCost.work + usage.work - beforeRetention.work,
+      retainedBytes: parseCost.retainedBytes + usage.retainedBytes - beforeRetention.retainedBytes
+    } } : {} });
+    entries.set(key, bucket);
+  }
+  return document;
+}
+function parseDocumentXml(input, options = {}, budget = new DocumentBudget()) {
+  const cached = cachedDocumentXml(input, options, budget);
+  if (cached.document) return cached.document;
+  const reservations = { xmlNodes: 0, work: 0, retainedBytes: 0 };
+  const parser = documentXmlSteps(input, options, budget, reservations);
+  try {
+    while (true) {
+      const step = parser.next();
+      if (step.done) return retainDocumentXml(cached.key, step.value, budget, reservations, cached.maxNodes, cached.maxBytes, cached.staged);
+      budget.charge("work", step.value);
+      reservations.work += step.value;
+    }
+  } finally {
+    parser.return(void 0);
+  }
+}
+async function parseDocumentXmlAsync(input, options = {}, budget = new DocumentBudget()) {
+  const cached = cachedDocumentXml(input, options, budget, true);
+  if (cached.document) {
+    if (cached.replayWork !== void 0) await budget.checkpoint(cached.replayWork);
+    return cached.document;
+  }
+  const reservations = { xmlNodes: 0, work: 0, retainedBytes: 0 };
+  const parser = documentXmlSteps(input, options, budget, reservations);
+  try {
+    while (true) {
+      const step = parser.next();
+      if (step.done) return retainDocumentXml(cached.key, step.value, budget, reservations, cached.maxNodes, cached.maxBytes, cached.staged);
+      budget.charge("work", step.value);
+      const pending = budget[reservedWorkTurn](step.value);
+      if (pending) await pending;
+      reservations.work += step.value;
+    }
+  } finally {
+    parser.return(void 0);
+  }
+}
+function xml(bytes, visit, elementOnly = false, budget = new DocumentBudget(), parsed) {
+  const root = parsed ?? parseDocumentXml(bytes, {}, budget).root;
+  const stack = [{ tag: root, depth: 1 }];
+  while (stack.length) {
+    budget.charge("work", 1);
+    const { tag, depth } = stack.pop();
+    if (elementOnly) {
+      for (const char of tag.text) {
+        if (!" 	\r\n".includes(char))
+          throw new InvalidPackageError("Unexpected package metadata text.");
+      }
+    }
+    visit(tag, depth);
+    for (let index = tag.children.length - 1; index >= 0; index--)
+      stack.push({ tag: tag.children[index], depth: depth + 1 });
+  }
+}
+
+export {
+  parseMediaType,
+  isXmlContentType,
+  InvalidPackageError,
+  InvalidXmlError,
+  UnsupportedProfileError,
+  documentXmlSettings,
+  parseDocumentXml,
+  parseDocumentXmlAsync,
+  xml
+};

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

@@ -0,0 +1,240 @@
+import {
+  readTextBodies,
+  validateTextReadingOptions
+} from "./chunk-XP6BHGZ6.js";
+import {
+  loadShared
+} from "./chunk-RAXJVM4U.js";
+import {
+  SelectionError
+} from "./chunk-CKEODJVT.js";
+import {
+  protectedEquationNodes
+} from "./chunk-5DFZAJHL.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/text-replacement.ts
+function authored(value, maximum) {
+  if (typeof value !== "string")
+    throw new OfficeError("invalid-value", "Expected literal text.", "usage");
+  if (value.length > maximum)
+    throw new OfficeError("resource-limit", "Literal text exceeds XML limits.", "usage");
+  for (const character of value) {
+    const point = character.codePointAt(0);
+    if (point < 32 && ![9, 10, 13].includes(point) || point >= 55296 && point <= 57343 || point === 65534 || point === 65535)
+      throw new OfficeError(
+        "invalid-value",
+        "Literal text must contain valid XML Unicode scalars.",
+        "usage"
+      );
+  }
+}
+async function replacePresentationText(input, options, context) {
+  if (!options || typeof options !== "object" || Array.isArray(options) || Object.keys(options).some(
+    (key) => ![
+      "style",
+      "find",
+      "with",
+      "first",
+      "all",
+      "occurrence",
+      "allowEmpty",
+      "scope",
+      "select",
+      "shape"
+    ].includes(key)
+  ) || options.first !== void 0 && options.first !== true || options.all !== void 0 && options.all !== true || options.occurrence !== void 0 && (!Number.isSafeInteger(options.occurrence) || options.occurrence < 1) || options.allowEmpty !== void 0 && typeof options.allowEmpty !== "boolean" || [options.first, options.all, options.occurrence].filter((value) => value !== void 0).length !== 1)
+    throw new OfficeError(
+      "invalid-value",
+      "Exactly one explicit text match cardinality is required.",
+      "usage"
+    );
+  if (options.style !== void 0 && (!options.style || typeof options.style !== "object" || Array.isArray(options.style) || Object.keys(options.style).length === 0 || Object.entries(options.style).some(
+    ([key, value]) => !["bold", "italic"].includes(key) || typeof value !== "boolean"
+  )))
+    throw new OfficeError(
+      "invalid-value",
+      "Replacement style accepts only boolean bold and italic.",
+      "usage"
+    );
+  authored(options.find, context.xmlLimits.maxBytes);
+  authored(options.with, context.xmlLimits.maxBytes);
+  if (!options.find) throw new OfficeError("invalid-value", "Find text cannot be empty.", "usage");
+  const reading = {
+    ...options.scope === void 0 ? {} : { scope: options.scope },
+    ...options.select === void 0 ? {} : { select: options.select },
+    ...options.shape === void 0 ? {} : { shape: options.shape }
+  };
+  validateTextReadingOptions(reading);
+  const state = await loadShared(input, context);
+  const bodies = await readTextBodies(state.source, reading, context).catch((error) => {
+    if (options.allowEmpty && options.select?.token === void 0 && error instanceof SelectionError && error.code === "missing-selection")
+      return [];
+    throw error;
+  });
+  const edits = /* @__PURE__ */ new Map();
+  const locations = [];
+  let matches = 0, affected = 0;
+  for (const body of bodies) {
+    context.signal?.throwIfAborted();
+    let changed = false;
+    const opaqueInlines = protectedEquationNodes(body.document.root);
+    const values = edits.get(body.part)?.values ?? /* @__PURE__ */ new Map();
+    for (const [paragraphIndex, paragraph] of body.paragraphs.entries()) {
+      let range = [];
+      const flush = () => {
+        const text = range.map((run) => run.text).join("");
+        let start = 0;
+        const replacements = [];
+        for (; ; ) {
+          context.signal?.throwIfAborted();
+          const found = text.indexOf(options.find, start);
+          if (found < 0) break;
+          matches++;
+          if (options.all || matches === (options.occurrence ?? 1))
+            replacements.push({ start: found, end: found + options.find.length });
+          start = found + options.find.length;
+        }
+        if (replacements.length) {
+          const outputLength = text.length + replacements.length * (options.with.length - options.find.length);
+          if (!Number.isSafeInteger(outputLength) || outputLength > context.xmlLimits.maxBytes)
+            throw new OfficeError(
+              "resource-limit",
+              "Replacement text exceeds XML limits.",
+              "serialize"
+            );
+          affected += replacements.length;
+          changed = true;
+          let offset = 0, replacementIndex = 0;
+          for (const run of range) {
+            const end = offset + run.text.length;
+            let cursor = offset;
+            const pieces = [];
+            while (replacementIndex < replacements.length && replacements[replacementIndex].end <= offset)
+              replacementIndex++;
+            for (let i = replacementIndex; i < replacements.length; i++) {
+              const match = replacements[i];
+              if (match.start >= end) break;
+              const prefix = text.slice(cursor, Math.max(offset, match.start));
+              if (prefix) pieces.push({ text: prefix, replacement: false });
+              if (match.start >= offset && options.with)
+                pieces.push({ text: options.with, replacement: true });
+              cursor = Math.min(end, match.end);
+            }
+            const suffix = text.slice(cursor, end);
+            if (suffix) pieces.push({ text: suffix, replacement: false });
+            if (pieces.map((piece) => piece.text).join("") !== run.text || options.style && pieces.some((piece) => piece.replacement))
+              values.set(run.node, pieces);
+            offset = end;
+          }
+        }
+        range = [];
+      };
+      let inlineIndex = 0;
+      let previousPosition = -1;
+      for (const node of paragraph.inlines) {
+        const position = paragraph.node.children.indexOf(node);
+        if (position !== previousPosition + 1 || position < 0) flush();
+        previousPosition = position;
+        const drawing = node.name.namespace === state.a;
+        if (opaqueInlines.has(node)) {
+          flush();
+          if (drawing && ["r", "fld", "br"].includes(node.name.localName)) inlineIndex++;
+          continue;
+        }
+        if (drawing && node.name.localName === "r") {
+          const inline = body.segment.paragraphs[paragraphIndex].inlines[inlineIndex++];
+          const textNodes = node.children.filter(
+            (child) => child.name.namespace === state.a && child.name.localName === "t"
+          );
+          if (textNodes.length !== 1 || textNodes[0].children.length)
+            throw new OfficeError(
+              "unsupported-edit",
+              "Text replacement requires one simple text value per run.",
+              "validate-intent"
+            );
+          range.push({ node: textNodes[0], text: inline.kind === "run" ? inline.text : "" });
+        } else {
+          flush();
+          if (drawing && ["fld", "br"].includes(node.name.localName)) inlineIndex++;
+        }
+      }
+      flush();
+    }
+    if (changed) {
+      edits.set(body.part, { document: body.document, values });
+      if (!locations.some(
+        (location) => JSON.stringify(location) === JSON.stringify(body.segment.location)
+      ))
+        locations.push(body.segment.location);
+    }
+  }
+  if (!affected) {
+    if (!options.allowEmpty) throw new SelectionError("missing-selection");
+    return { bytes: state.source, affected: 0, locations: [] };
+  }
+  for (const [part, edit] of edits) {
+    const paths = [];
+    const visit = (node, path) => {
+      const pieces = edit.values.get(node);
+      if (pieces !== void 0) paths.push({ path, pieces });
+      node.children.forEach((child, index) => visit(child, [...path, index]));
+    };
+    visit(edit.document.root, []);
+    let document = edit.document;
+    for (const { path, pieces } of paths.reverse()) {
+      let parent = document.root;
+      for (const index of path.slice(0, -1)) parent = parent.children[index];
+      const node = parent.children[path.at(-1)];
+      if (!options.style || !pieces.some((piece) => piece.replacement)) {
+        document = document.setText(node, pieces.map((piece) => piece.text).join(""));
+        continue;
+      }
+      const run = parent;
+      const standalone = document.markup(run, true);
+      const fragments = pieces.map((piece) => {
+        let clone = parseXmlPart(new TextEncoder().encode(standalone), context.xmlLimits);
+        const text = clone.root.children.find(
+          (child) => child.name.localName === "t" && child.name.namespace === state.a
+        );
+        clone = clone.setText(text, piece.text);
+        if (piece.replacement) {
+          const name = { namespace: state.a, localName: "rPr" };
+          clone = clone.merge(clone.root, {
+            children: {
+              sequence: [name, { namespace: state.a, localName: "t" }],
+              upsert: [
+                {
+                  name,
+                  merge: {
+                    attributes: Object.entries(options.style).map(([key, value]) => ({
+                      namespace: "",
+                      localName: key === "bold" ? "b" : "i",
+                      value: value ? "1" : "0"
+                    }))
+                  }
+                }
+              ]
+            }
+          });
+        }
+        return clone.markup(clone.root);
+      });
+      let paragraph = document.root;
+      for (const index of path.slice(0, -2)) paragraph = paragraph.children[index];
+      document = document.spliceChildren(paragraph, path.at(-2), 1, fragments);
+    }
+    state.save(part, document);
+  }
+  const result = await state.finish(state.main, []);
+  return { bytes: result.bytes, affected, locations };
+}
+
+export {
+  replacePresentationText
+};