@poe-platform/safe-bash 0.1.818 → 0.1.819

package/dist/safe-bash/command-chunks/{chunk-QWX5IERU.js → chunk-OMD45J52.js}

@@ -1,51 +1,55 @@
 import {
   stageRetainedArchive
-} from "./chunk-BSTABZIK.js";
+} from "./chunk-3LMUKOP2.js";
 import {
   openPackageArchive
-} from "./chunk-FJLSYX5P.js";
+} from "./chunk-ITJDLFPW.js";
+import {
+  openRetainedPresentationIndex
+} from "./chunk-LZHFVNEV.js";
 import {
-  openRetainedPresentationIndex,
   stageRetainedOutput,
   streamJson
-} from "./chunk-3ZGO24WG.js";
+} from "./chunk-R36PDP3L.js";
 import {
   writePackageArchive
-} from "./chunk-TG2RVQLP.js";
+} from "./chunk-5KWEZV5H.js";
 import {
   SelectionError
-} from "./chunk-3W3HLPCX.js";
+} from "./chunk-SKF6PGA5.js";
 import {
   readPackage
-} from "./chunk-Q65GWGQR.js";
-import {
-  readBinary
-} from "./chunk-FAU2KL6I.js";
+} from "./chunk-KVTZJBLM.js";
 import {
   openRetainedPresentationValidation,
   validatePresentation
-} from "./chunk-N6VNHC3B.js";
+} from "./chunk-SKDJCMGI.js";
+import {
+  dialects
+} from "./chunk-P3LHQOX7.js";
 import {
-  dialects,
   openRetainedContentTypes,
   openRetainedRelationshipGraph
-} from "./chunk-6KJDTKE4.js";
+} from "./chunk-O4H7HPMP.js";
 import {
   parseXmlPart
-} from "./chunk-7PYDVQPB.js";
+} from "./chunk-YWP62BAZ.js";
 import {
   readRelationshipGraph
-} from "./chunk-4YFTJS5U.js";
+} from "./chunk-QMXOKYMJ.js";
 import {
   parseContentTypes
-} from "./chunk-XFIDOCYH.js";
+} from "./chunk-6ZHNKHQQ.js";
 import {
   packageUri,
   partName
-} from "./chunk-MOUCMZZP.js";
+} from "./chunk-PZVFNPRC.js";
+import {
+  readBinary
+} from "./chunk-S5MBHFLB.js";
 import {
   PackageNotFoundError
-} from "./chunk-G3FK5VVG.js";
+} from "./chunk-HTBUIRTH.js";
 import {
   OfficeError,
   RetainedValues,
@@ -55,7 +59,7 @@ import {
   openRetainedXml,
   openRetainedXmlDocument,
   resolveOfficeResources
-} from "./chunk-KM2SMMXZ.js";
+} from "./chunk-VJQ5OWS5.js";
 
 // packages/safe-bash-presentation-engine/src/xml-replacement-rules.ts
 var xmlReplacementSequences = {

package/dist/safe-bash/command-chunks/{chunk-AXI7VMLG.js → chunk-OOYVZAWL.js}

@@ -2,44 +2,9 @@ import {
   normalizeEncoding,
   pythonCodecAliases
 } from "./chunk-ZERCTWUI.js";
-
-// packages/safe-bash-csv-engine/src/codepage-table.ts
-var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-function decodeBase64Latin1(encoded) {
-  let out = "", buffer = 0, bits = 0;
-  for (let i = 0; i < encoded.length; i++) {
-    const ch = encoded[i];
-    if (ch === "=") break;
-    const value = alphabet.indexOf(ch);
-    if (value < 0) continue;
-    buffer = buffer << 6 | value;
-    bits += 6;
-    if (bits >= 8) {
-      bits -= 8;
-      out += String.fromCharCode(buffer >>> bits & 255);
-    }
-  }
-  return out;
-}
-function encodeBase64Latin1(bytes) {
-  let out = "";
-  for (let i = 0; i < bytes.length; i += 3) {
-    const b0 = bytes.charCodeAt(i) & 255, has1 = i + 1 < bytes.length, has2 = i + 2 < bytes.length;
-    const b1 = has1 ? bytes.charCodeAt(i + 1) & 255 : 0, b2 = has2 ? bytes.charCodeAt(i + 2) & 255 : 0;
-    const triplet = b0 << 16 | b1 << 8 | b2;
-    out += alphabet[triplet >>> 18 & 63] + alphabet[triplet >>> 12 & 63] + (has1 ? alphabet[triplet >>> 6 & 63] : "=") + (has2 ? alphabet[triplet & 63] : "=");
-  }
-  return out;
-}
-function unpackCodepage(encoded) {
-  const bytes = decodeBase64Latin1(encoded), offset = bytes.length === 256 ? 128 : 0;
-  const values = Array.from({ length: offset }, (_, byte) => byte);
-  for (let i = 0; i < bytes.length; i += 2) {
-    const point = bytes.charCodeAt(i) | bytes.charCodeAt(i + 1) << 8;
-    values.push(point === 65535 ? -1 : point);
-  }
-  return Object.freeze(values);
-}
+import {
+  unpackCodepage
+} from "./chunk-HNEWGADJ.js";
 
 // packages/safe-bash-csv-engine/src/python-codepages.ts
 var dbfCodepages = Object.freeze({
@@ -118,9 +83,6 @@ var pythonSingleByteCodepages = Object.freeze({
 });
 
 export {
-  decodeBase64Latin1,
-  encodeBase64Latin1,
-  unpackCodepage,
   dbfCodepages,
   PythonTextDecodeError,
   decodePythonSingleByte,

package/dist/safe-bash/command-chunks/{chunk-GNORF6RY.js → chunk-OPKLIF5P.js}

@@ -1,21 +1,21 @@
 import {
   inspectDocumentObjects
-} from "./chunk-TTVJJZOM.js";
+} from "./chunk-EBMKGNKF.js";
 import {
   editDocumentLinks,
   inspectDocumentLinks
-} from "./chunk-GZNX5SS4.js";
+} from "./chunk-EIZFAUUD.js";
 import {
   editDocumentProperties,
   inspectDocumentProperties
-} from "./chunk-MN7EEK6Y.js";
+} from "./chunk-ZUOID3FA.js";
 import {
   editDocumentRevisionDecisions
-} from "./chunk-QCN7MRRU.js";
+} from "./chunk-772WNCU6.js";
 import {
   editDocumentComments,
   inspectDocumentComments
-} from "./chunk-37KBCKDF.js";
+} from "./chunk-QCCRQU44.js";
 import {
   assertOutsideFields,
   parseFields
@@ -26,20 +26,20 @@ import {
 import {
   retainedRelationshipTargets
 } from "./chunk-UIX3CASN.js";
-import {
-  measurePackageResourceSerialization
-} from "./chunk-ETN25WCR.js";
-import {
-  validateDocxInvocation
-} from "./chunk-BDGNKRY4.js";
 import {
   assertDocumentEditable,
   publishDocumentArchive
-} from "./chunk-LTWX23FS.js";
+} from "./chunk-QQ7ORF2D.js";
+import {
+  measurePackageResourceSerialization
+} from "./chunk-KD4JUF6R.js";
 import {
   DocumentPackage,
   readDocumentArchive
 } from "./chunk-5BUL25DF.js";
+import {
+  validateDocxInvocation
+} from "./chunk-BDGNKRY4.js";
 import {
   DocumentXmlEditor,
   UnsupportedEditError,

package/dist/safe-bash/command-chunks/{chunk-E3DF7RTE.js → chunk-OT75C5YS.js}

@@ -1,7 +1,7 @@
 import {
   indexValue,
   type
-} from "./chunk-VWRHPDCD.js";
+} from "./chunk-ZIDESNHW.js";
 import {
   JqError,
   JqLimitError,
@@ -9,7 +9,7 @@ import {
   isObject,
   put,
   remove
-} from "./chunk-5VO534FR.js";
+} from "./chunk-3K5FCRUG.js";
 import {
   isNumber,
   numberValue

package/dist/safe-bash/command-chunks/{chunk-X6KO7D6R.js → chunk-OVCSXD7N.js}

@@ -1,14 +1,14 @@
 import {
   noteAttribute,
   openNotes
-} from "./chunk-45GTHPL5.js";
+} from "./chunk-2V6EUWE3.js";
 import {
   assertOutsideFields,
   parseFields
 } from "./chunk-6EK76ERE.js";
 import {
   resolveDocxSelection
-} from "./chunk-MWVELMXZ.js";
+} from "./chunk-BFOVQUTF.js";
 import {
   paragraphTextRun,
   replaceParagraphContent
@@ -19,13 +19,13 @@ import {
 import {
   LocationIndex
 } from "./chunk-VSTAHYCV.js";
-import {
-  validateDocxInvocation
-} from "./chunk-BDGNKRY4.js";
 import {
   assertDocumentEditable,
   publishDocumentArchive
-} from "./chunk-LTWX23FS.js";
+} from "./chunk-QQ7ORF2D.js";
+import {
+  validateDocxInvocation
+} from "./chunk-BDGNKRY4.js";
 import {
   DocumentXmlEditor,
   UnsupportedEditError,

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

@@ -0,0 +1,371 @@
+import {
+  OfficeError,
+  RetainedValues,
+  equal,
+  literal,
+  resolveOfficeResources,
+  validateRetainedLocalName
+} from "./chunk-VJQ5OWS5.js";
+import {
+  ZipDirectoryIndex
+} from "./chunk-IOEUZ4EA.js";
+
+// packages/safe-bash-presentation-engine/src/retained-compatibility.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+var mc = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+var xml = "http://www.w3.org/XML/1998/namespace";
+var controls = ["Ignorable", "MustUnderstand", "ProcessContent", "PreserveElements", "PreserveAttributes"];
+var dialects = [
+  ["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");
+}
+async function openRetainedCompatibility(doc, understoodNamespaces, settings, opaqueElements = [], expandOpaque) {
+  if (!Array.isArray(understoodNamespaces) || understoodNamespaces.some((uri) => typeof uri !== "string" || !uri) || expandOpaque !== void 0 && typeof expandOpaque !== "function" || !Array.isArray(opaqueElements) || opaqueElements.some((name) => !name || typeof name.namespace !== "string" || typeof name.localName !== "string" || !name.localName))
+    throw new OfficeError("invalid-value", "Expected understood namespaces and opaque element names.", "usage");
+  const understood = ["", xml, mc, ...understoodNamespaces], opaque = opaqueElements.map((name) => ({ ...name }));
+  const context = resolveOfficeResources(settings), working = { ...settings.workingStorage }, cacheBytes = working.cacheBytes ?? 1024 * 1024;
+  if (!working.fs || typeof working.directory !== "string" || !working.directory.startsWith("/") || !Number.isSafeInteger(cacheBytes) || cacheBytes < 16384 || cacheBytes % 16384)
+    throw new OfficeError("invalid-value", "Explicit compatibility working storage and a valid cache budget are required.", "usage");
+  const signal = context.signal ?? new AbortController().signal, pages = new PagedStorage({ fs: working.fs, cwd: working.directory, env: {}, signal }, cacheBytes / 16384);
+  const index = new ZipDirectoryIndex(pages, { signal });
+  let closed = false, closing, firstAlternative = 0, lastAlternative = 0;
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Compatibility view is closed.", "parse");
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "parse");
+  };
+  const close = () => {
+    closed = true;
+    return closing ??= pages.close();
+  };
+  const failure = (error) => error instanceof OfficeError ? error : new OfficeError(signal.aborted ? "cancelled" : "io-failure", "Compatibility storage operation failed.", "parse");
+  const values = new RetainedValues(pages, check, signal);
+  async function row(pointer, length) {
+    check();
+    const bytes = await pages.read(pointer, length * 8), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return Array.from({ length }, (_, n) => view.getFloat64(n * 8, true));
+  }
+  async function write(pointer, data) {
+    check();
+    const bytes = new Uint8Array(data.length * 8), view = new DataView(bytes.buffer);
+    data.forEach((number, n) => view.setFloat64(n * 8, number, true));
+    await pages.write(pointer, bytes);
+  }
+  const local = (node, name) => equal(doc.raw(node.localName), literal(name));
+  const namespace = (node, uri) => equal(doc.namespace(node), literal(uri));
+  async function supported(source) {
+    for (const uri of understood) if (await equal(source(), literal(uri))) return true;
+    return false;
+  }
+  async function isOpaque(node) {
+    for (const name of opaque) if (await local(node, name.localName) && await namespace(node, name.namespace)) return true;
+    return false;
+  }
+  async function attribute(node, name, uri = mc) {
+    for await (const attr of doc.attributes(node)) if (await local(attr, name) && await namespace(attr, uri)) return attr;
+    return void 0;
+  }
+  async function* tokens(node) {
+    if (!node) return;
+    const range = await values.store(doc.text(node));
+    let start = 0, length = 0, position = range.start;
+    for await (const bytes of values.read(range)) for (const byte of bytes) {
+      if (byte === 9 || byte === 10 || byte === 13 || byte === 32) {
+        if (length) yield { start, length };
+        length = 0;
+      } else {
+        if (!length) start = position;
+        length++;
+      }
+      position++;
+    }
+    if (length) yield { start, length };
+  }
+  async function prefixUri(node, prefix) {
+    await validateRetainedLocalName(values.read(prefix));
+    const uri = await doc.resolveNamespace(node, () => values.read(prefix));
+    if (!uri) invalid();
+    const stored = await values.store(uri);
+    if (!stored.length || await equal(values.read(stored), literal(mc))) invalid();
+    return stored;
+  }
+  async function rule(scope, kind, key) {
+    for (let pointer = scope; pointer; pointer = (await row(pointer, 1))[0]) if (await values.find(`${kind}${pointer}`, key)) return true;
+    return false;
+  }
+  async function* expanded(uri, name) {
+    yield* uri();
+    yield* literal("\0");
+    yield* name();
+  }
+  async function process(scope, node) {
+    return await rule(scope, "p", () => expanded(() => doc.namespace(node), () => doc.raw(node.localName))) || await rule(scope, "p", () => expanded(() => doc.namespace(node), () => literal("*")));
+  }
+  async function rules2(node, inherited) {
+    const scope = pages.allocate(8);
+    await write(scope, [inherited]);
+    for await (const attr of doc.attributes(node)) if (await namespace(attr, mc)) {
+      let recognized = false;
+      for (const control of controls) if (await local(attr, control)) {
+        recognized = true;
+        break;
+      }
+      if (!recognized) invalid();
+    }
+    for await (const token of tokens(await attribute(node, "Ignorable"))) {
+      const uri = await prefixUri(node, token);
+      await values.insert(`i${scope}`, uri, uri);
+    }
+    for await (const token of tokens(await attribute(node, "MustUnderstand"))) await prefixUri(node, token);
+    for (const control of ["ProcessContent", "PreserveElements", "PreserveAttributes"]) for await (const token of tokens(await attribute(node, control))) {
+      let colon = -1, position = token.start;
+      for await (const bytes of values.read(token)) for (const byte of bytes) {
+        if (byte === 58) {
+          if (colon >= 0) invalid();
+          colon = position;
+        }
+        position++;
+      }
+      if (colon < 0) invalid();
+      const uri = await prefixUri(node, { start: token.start, length: colon - token.start }), name = { start: colon + 1, length: token.start + token.length - colon - 1 };
+      if (!await equal(values.read(name), literal("*"))) await validateRetainedLocalName(values.read(name));
+      if (!await rule(scope, "i", () => values.read(uri))) invalid();
+      if (control === "ProcessContent") {
+        const key = await values.store(expanded(() => values.read(uri), () => values.read(name)));
+        await values.insert(`p${scope}`, key, key);
+      }
+    }
+    return scope;
+  }
+  async function mustUnderstand(node) {
+    for await (const token of tokens(await attribute(node, "MustUnderstand"))) {
+      const uri = await prefixUri(node, token);
+      if (!await supported(() => values.read(uri))) unsupported();
+    }
+  }
+  async function wrapper(node, scope) {
+    for await (const attr of doc.attributes(node)) {
+      if (await namespace(attr, xml) || !await namespace(attr, "") && !await namespace(attr, mc) && !await rule(scope, "i", () => doc.namespace(attr))) invalid();
+      if (await namespace(attr, "") && !(await local(node, "Choice") && await local(attr, "Requires"))) invalid();
+    }
+  }
+  async function checkAttributes(node, scope) {
+    for await (const attr of doc.attributes(node)) if (!await namespace(attr, mc) && !await supported(() => doc.namespace(attr)) && !await rule(scope, "i", () => doc.namespace(attr))) unsupported();
+  }
+  async function append(node, parent, rawAttributes) {
+    const pointer = pages.allocate(5 /* Count */ * 8), data = new Array(5 /* Count */).fill(0), owner = await row(parent, 5 /* Count */);
+    data[0 /* Node */] = doc.reference(node);
+    data[4 /* RawAttributes */] = Number(rawAttributes);
+    await write(pointer, data);
+    if (owner[2 /* Last */]) await write(owner[2 /* Last */] + 3 /* Next */ * 8, [pointer]);
+    else owner[1 /* First */] = pointer;
+    owner[2 /* Last */] = pointer;
+    await write(parent, owner);
+    await index.set(String(data[0 /* Node */]), pointer);
+    return pointer;
+  }
+  async function viewRecord(node) {
+    check();
+    const pointer = await index.get(String(doc.reference(node)));
+    if (!pointer) throw new OfficeError("invalid-value", "Expected a processed XML element.", "usage");
+    return row(pointer, 5 /* Count */);
+  }
+  try {
+    const rootOutput = pages.allocate(5 /* Count */ * 8);
+    await write(rootOutput, new Array(5 /* Count */).fill(0));
+    let top = pages.allocate(40);
+    await write(top, [0, doc.reference(doc.root), 0, rootOutput, 0]);
+    while (top) {
+      const task = await row(top, 5);
+      top = task[0];
+      const node = await doc.node(task[1]), scope = await rules2(node, task[2]), branch = Boolean(task[4]);
+      let output = task[3];
+      if (await namespace(node, mc) && !branch) {
+        if (!await local(node, "AlternateContent")) invalid();
+        await wrapper(node, scope);
+        await mustUnderstand(node);
+        let selected = 0, fallback = false, choices = 0;
+        for await (const candidate of doc.children(node)) {
+          if (candidate.kind !== "element") continue;
+          const candidateScope = await rules2(candidate, scope);
+          if (!await namespace(candidate, mc)) {
+            if (!await rule(candidateScope, "i", () => doc.namespace(candidate))) invalid();
+            if (await supported(() => doc.namespace(candidate)) || await process(candidateScope, candidate)) unsupported();
+            continue;
+          }
+          await wrapper(candidate, candidateScope);
+          await checkAttributes(candidate, candidateScope);
+          if (await local(candidate, "Choice") && !fallback) {
+            choices++;
+            const requires = await attribute(candidate, "Requires", "");
+            if (!requires) invalid();
+            let count = 0, understood2 = true;
+            for await (const token of tokens(requires)) {
+              count++;
+              const uri = await prefixUri(candidate, token);
+              if (!await supported(() => values.read(uri))) understood2 = false;
+            }
+            if (!count) invalid();
+            if (!selected && understood2) selected = doc.reference(candidate);
+          } else if (await local(candidate, "Fallback") && !fallback && choices) {
+            fallback = true;
+            if (!selected) selected = doc.reference(candidate);
+          } else invalid();
+        }
+        if (!choices) invalid();
+        const alternative = pages.allocate(24);
+        await write(alternative, [0, doc.reference(node), selected]);
+        if (lastAlternative) await write(lastAlternative, [alternative]);
+        else firstAlternative = alternative;
+        lastAlternative = alternative;
+        if (selected) {
+          await mustUnderstand(await doc.node(selected));
+          const pointer = pages.allocate(40);
+          await write(pointer, [top, selected, scope, output, 1]);
+          top = pointer;
+        }
+        continue;
+      }
+      const opaqueNode = await isOpaque(node);
+      if (!branch) {
+        const known = await supported(() => doc.namespace(node));
+        if (!known && opaqueNode) {
+          await mustUnderstand(node);
+          await append(node, output, true);
+          continue;
+        }
+        if (!known) {
+          if (!await rule(scope, "i", () => doc.namespace(node))) unsupported();
+          if (!await process(scope, node)) continue;
+          for await (const attr of doc.attributes(node)) if (await namespace(attr, xml) && (await local(attr, "base") || await local(attr, "lang") || await local(attr, "space"))) invalid();
+          await mustUnderstand(node);
+        } else {
+          await mustUnderstand(node);
+          await checkAttributes(node, scope);
+          output = await append(node, output, false);
+        }
+      }
+      if (opaqueNode) {
+        const expand = await expandOpaque?.(node);
+        check();
+        if (!expand) continue;
+      }
+      let first = 0, last = 0;
+      for await (const child of doc.children(node)) if (child.kind === "element") {
+        const pointer = pages.allocate(40);
+        await write(pointer, [0, doc.reference(child), scope, output, 0]);
+        if (last) await write(last, [pointer]);
+        else first = pointer;
+        last = pointer;
+      }
+      if (last) {
+        await write(last, [top]);
+        top = first;
+      }
+    }
+    let dialect = null;
+    for (const [uri, kind] of dialects) if (await namespace(doc.root, uri)) {
+      dialect = kind;
+      break;
+    }
+    check();
+    return Object.freeze({
+      dialect,
+      close,
+      async *children(node) {
+        try {
+          for (let pointer = (await viewRecord(node))[1 /* First */]; pointer; ) {
+            const data = await row(pointer, 5 /* Count */);
+            yield await doc.node(data[0 /* Node */]);
+            pointer = data[3 /* Next */];
+          }
+        } catch (error) {
+          throw failure(error);
+        }
+      },
+      async *attributes(node) {
+        try {
+          const data = await viewRecord(node);
+          for await (const attr of doc.attributes(node)) {
+            check();
+            if (!await namespace(attr, mc) && (data[4 /* RawAttributes */] || await supported(() => doc.namespace(attr)))) yield attr;
+          }
+        } catch (error) {
+          throw failure(error);
+        }
+      },
+      async *alternatives() {
+        try {
+          check();
+          for (let pointer = firstAlternative; pointer; ) {
+            const data = await row(pointer, 3);
+            yield Object.freeze({ element: await doc.node(data[1]), selected: data[2] ? await doc.node(data[2]) : null });
+            pointer = data[0];
+          }
+        } catch (error) {
+          throw failure(error);
+        }
+      }
+    });
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw failure(error);
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/validation-schema.ts
+var rules = [
+  "main-part",
+  "content-types",
+  "relationship-targets",
+  "required-structure",
+  "slide-ids",
+  "shape-ids",
+  "master-layouts",
+  "note-associations",
+  "timing-references",
+  "connector-references"
+];
+var dialects2 = [
+  {
+    p: "http://schemas.openxmlformats.org/presentationml/2006/main",
+    a: "http://schemas.openxmlformats.org/drawingml/2006/main",
+    r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+  },
+  {
+    p: "http://purl.oclc.org/ooxml/presentationml/main",
+    a: "http://purl.oclc.org/ooxml/drawingml/main",
+    r: "http://purl.oclc.org/ooxml/officeDocument/relationships"
+  }
+];
+var types = new Map(
+  [
+    ["presentation.main", "presentation"],
+    ["template.main", "presentation"],
+    ["slideshow.main", "presentation"],
+    ["slide", "sld"],
+    ["slideMaster", "sldMaster"],
+    ["slideLayout", "sldLayout"],
+    ["notesSlide", "notes"],
+    ["notesMaster", "notesMaster"],
+    ["handoutMaster", "handoutMaster"]
+  ].map(([type, root]) => [
+    `application/vnd.openxmlformats-officedocument.presentationml.${type}+xml`.toLowerCase(),
+    root
+  ])
+);
+
+export {
+  openRetainedCompatibility,
+  rules,
+  dialects2 as dialects,
+  types
+};

package/dist/safe-bash/command-chunks/{chunk-M7DZ7COK.js → chunk-P3TV5GIG.js}

@@ -1,11 +1,11 @@
 import {
   editDocumentParagraphs,
   tableContainerWidth
-} from "./chunk-UBX5I5HY.js";
+} from "./chunk-CPCXE2TM.js";
 import {
   openDocumentLocations,
   resolveDocxSelection
-} from "./chunk-MWVELMXZ.js";
+} from "./chunk-BFOVQUTF.js";
 import {
   DocumentArchiveEditor
 } from "./chunk-GY2C555A.js";
@@ -18,16 +18,16 @@ import {
   LocationIndex,
   addressKey
 } from "./chunk-VSTAHYCV.js";
-import {
-  validateDocxInvocation
-} from "./chunk-BDGNKRY4.js";
 import {
   assertDocumentEditable,
   publishDocumentArchive
-} from "./chunk-LTWX23FS.js";
+} from "./chunk-QQ7ORF2D.js";
 import {
   DocumentPackage
 } from "./chunk-5BUL25DF.js";
+import {
+  validateDocxInvocation
+} from "./chunk-BDGNKRY4.js";
 import {
   UnsupportedEditError,
   activeXmlChildren,

package/dist/safe-bash/command-chunks/{chunk-CCNOZKAK.js → chunk-P5UFNPRE.js}

@@ -4,23 +4,23 @@ import {
 } from "./chunk-6EK76ERE.js";
 import {
   openDocumentLocations
-} from "./chunk-MWVELMXZ.js";
+} from "./chunk-BFOVQUTF.js";
 import {
   DocumentArchiveEditor
 } from "./chunk-GY2C555A.js";
 import {
   pathContains
 } from "./chunk-VSTAHYCV.js";
-import {
-  validateDocxInvocation
-} from "./chunk-BDGNKRY4.js";
 import {
   assertDocumentEditable,
   publishDocumentArchive
-} from "./chunk-LTWX23FS.js";
+} from "./chunk-QQ7ORF2D.js";
 import {
   DocumentPackage
 } from "./chunk-5BUL25DF.js";
+import {
+  validateDocxInvocation
+} from "./chunk-BDGNKRY4.js";
 import {
   UnsupportedEditError,
   activeXmlChildren,