@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,196 @@
+import {
+  addDocumentStylesPart,
+  styleAllocationIds
+} from "./chunk-MQFXMBGD.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  writeDocumentArchive
+} from "./chunk-3VETFXYR.js";
+import {
+  admittedXml,
+  readDocumentArchive
+} from "./chunk-GLPIFP7N.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  activeXmlChildren,
+  appendBodyBlocks,
+  pageGeometry,
+  renderContent,
+  renderTheme,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  validateDocxValue
+} from "./chunk-R4TYL2G6.js";
+import {
+  closedRecord
+} from "./chunk-LQOKYG3O.js";
+import {
+  parseDocumentXml
+} from "./chunk-MWAAMNAM.js";
+import {
+  InvalidValueError,
+  archiveSettings,
+  documentSession
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/default-model-styles.ts
+function originalModelDefaults(namespace) {
+  return `<w:docDefaults xmlns:w="${namespace}"/>` + [
+    ["paragraph", "Normal", "Normal"],
+    ["character", "DefaultParagraphFont", "Default Paragraph Font"],
+    ["table", "NormalTable", "Normal Table"],
+    ["numbering", "NoList", "No List"]
+  ].map(([type, id, name]) => `<w:style xmlns:w="${namespace}" w:type="${type}" w:default="1" w:styleId="${id}"><w:name w:val="${xmlValue(name)}"/></w:style>`).join("");
+}
+
+// packages/safe-bash-docx-engine/src/create.ts
+async function createDocumentArchive(options, context) {
+  const { budget } = archiveSettings(context);
+  closedRecord(options, ["kind", "dialect", "template", "content", "timestamp", "author"]);
+  if (options.kind !== void 0 && options.kind !== "docx" && options.kind !== "dotx" || options.dialect !== void 0 && options.dialect !== "strict" && options.dialect !== "transitional")
+    throw new InvalidValueError("Expected kind docx or dotx and dialect strict or transitional.");
+  if (options.content !== void 0 && !validateDocxValue("OriginalDocumentContentV1", options.content)) throw new InvalidValueError("Expected typed document content.");
+  if (options.timestamp !== void 0 && !validateDocxValue("UTC instant", options.timestamp)) throw new InvalidValueError("Expected a UTC timestamp.");
+  if (options.author !== void 0 && (!validateDocxValue("string", options.author) || [...options.author].length > 255)) throw new InvalidValueError("Expected a bounded author string.");
+  if (options.template !== void 0 && !(options.template instanceof Uint8Array)) throw new InvalidValueError("Expected supplied template bytes.");
+  options = { ...options };
+  const content = options.content === void 0 ? { version: 1, blocks: [] } : JSON.parse(JSON.stringify(options.content));
+  const contentBytes = new TextEncoder().encode(JSON.stringify(content)).length;
+  budget.check("xmlPartBytes", contentBytes);
+  budget.charge("retainedBytes", contentBytes * 4);
+  budget.charge("work", contentBytes);
+  const template = options.template === void 0 ? void 0 : await readDocumentArchive(options.template, { ...context, budget });
+  const kind = options.kind ?? template?.kind ?? "docx", dialect = options.dialect ?? template?.dialect ?? "transitional";
+  if (kind !== "docx" && kind !== "dotx" || dialect !== "strict" && dialect !== "transitional")
+    throw new InvalidValueError("Expected kind docx or dotx and dialect strict or transitional.");
+  const { w, r } = documentDialects[dialect];
+  if (template) {
+    if (kind !== template.kind || dialect !== template.dialect) throw new UnsupportedEditError("Creation must retain template kind and dialect.");
+    assertDocumentEditable(template, archiveSettings({ ...context, budget }));
+    return populateTemplate(template, content, options, { ...context, budget });
+  }
+  const geometry = pageGeometry(content.page);
+  const mainType = `application/vnd.openxmlformats-officedocument.wordprocessingml.${kind === "docx" ? "document" : "template"}.main+xml`;
+  const relationshipNamespace = "http://schemas.openxmlformats.org/package/2006/relationships";
+  const parts = [
+    ["[Content_Types].xml", `<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Override PartName="/word/document.xml" ContentType="${mainType}"/><Override PartName="/word/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/></Types>`],
+    ["_rels/.rels", `<Relationships xmlns="${relationshipNamespace}"><Relationship Id="rId1" Type="${r}/officeDocument" Target="word/document.xml"/></Relationships>`],
+    ["word/_rels/document.xml.rels", `<Relationships xmlns="${relationshipNamespace}"><Relationship Id="rId1" Type="${r}/styles" Target="styles.xml"/></Relationships>`],
+    ["word/document.xml", `<w:document xmlns:w="${w}"><w:body><w:p/><w:sectPr>${geometry.xml}</w:sectPr></w:body></w:document>`],
+    ["word/styles.xml", `<w:styles xmlns:w="${w}">${originalModelDefaults(w)}</w:styles>`]
+  ];
+  const rendered = renderContent(content, w, budget, parseDocumentXml(new TextEncoder().encode(parts[4][1])).root, geometry.width);
+  parts[3][1] = `<w:document xmlns:w="${w}"><w:body>${rendered.body || "<w:p/>"}<w:sectPr>${geometry.xml}</w:sectPr></w:body></w:document>`;
+  if (rendered.builtinOverrides?.size) {
+    for (const [id, rPr] of rendered.builtinOverrides) {
+      if (!rPr) continue;
+      parts[4][1] = parts[4][1].replace(`w:styleId="${id}"><w:name w:val="Normal"/></w:style>`, `w:styleId="${id}"><w:name w:val="Normal"/><w:rPr>${rPr}</w:rPr></w:style>`);
+    }
+  }
+  if (rendered.styles) parts[4][1] = parts[4][1].slice(0, -11) + rendered.styles + "</w:styles>";
+  if (content.theme) {
+    parts[0][1] = parts[0][1].slice(0, -8) + '<Override PartName="/word/theme/theme1.xml" ContentType="application/vnd.openxmlformats-officedocument.theme+xml"/></Types>';
+    parts[2][1] = parts[2][1].slice(0, -16) + `<Relationship Id="rId2" Type="${r}/theme" Target="theme/theme1.xml"/></Relationships>`;
+    parts.push(["word/theme/theme1.xml", renderTheme(content.theme, documentDialects[dialect].a)]);
+  }
+  if (options.timestamp !== void 0 || options.author !== void 0) {
+    const time = options.timestamp === void 0 ? "" : new Date(options.timestamp).toISOString().slice(0, 19) + "Z";
+    parts[0][1] = parts[0][1].slice(0, -8) + '<Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/></Types>';
+    parts[1][1] = parts[1][1].slice(0, -16) + '<Relationship Id="rId2" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="docProps/core.xml"/></Relationships>';
+    parts.push(["docProps/core.xml", `<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><dc:creator>${xmlValue(options.author ?? "")}</dc:creator>${time ? `<dcterms:created xsi:type="dcterms:W3CDTF">${time}</dcterms:created><dcterms:modified xsi:type="dcterms:W3CDTF">${time}</dcterms:modified>` : ""}</cp:coreProperties>`]);
+  }
+  budget.charge("retainedBytes", parts.reduce((sum, [name, xml]) => sum + (name.length + xml.length) * 3, 0));
+  const archive = {
+    comment: new Uint8Array(),
+    members: parts.map(([name, xml]) => ({
+      name,
+      bytes: new TextEncoder().encode(xml),
+      directory: false,
+      modified: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z")
+    }))
+  };
+  for (const member of archive.members) {
+    const remaining = budget.limits.insertedNodes - budget.usage.insertedNodes;
+    budget.check("insertedNodes", budget.usage.insertedNodes + 1);
+    const before = budget.usage.xmlNodes;
+    parseDocumentXml(member.bytes, {
+      maxNodes: Math.min(remaining, budget.limits.xmlNodes),
+      maxContentNodes: Math.min(remaining, budget.limits.xmlNodes)
+    }, budget);
+    budget.charge("insertedNodes", budget.usage.xmlNodes - before);
+  }
+  return admitCreated(archive, { ...context, budget });
+}
+async function admitCreated(archive, context) {
+  const { budget } = archiveSettings(context);
+  const chunks = [];
+  await writeDocumentArchive(archive, { async write(bytes2) {
+    chunks.push(bytes2);
+  } }, { order: "name", compression: "store" }, { ...context, budget });
+  const size = chunks.reduce((total, chunk) => total + chunk.length, 0);
+  budget.charge("retainedBytes", size);
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.length;
+  }
+  const { [documentSession]: ignoredSession, ...admissionContext } = context;
+  return readDocumentArchive(bytes, { ...admissionContext, budget });
+}
+async function populateTemplate(template, content, options, context) {
+  const { budget } = archiveSettings(context);
+  const { w, r } = documentDialects[template.dialect];
+  if (content.page || content.theme || options.timestamp !== void 0 || options.author !== void 0)
+    throw new UnsupportedEditError("Template creation retains existing page, theme and metadata settings.");
+  const main = template.members.find((member) => member.name === template.mainPart);
+  const editor = new DocumentXmlEditor(main.bytes, {}, void 0, budget);
+  const children = activeXmlChildren(editor, budget);
+  const bodies = children(editor.root).filter((child) => child.namespace === w && child.localName === "body");
+  if (bodies.length !== 1) throw new UnsupportedEditError("Template requires one active document body.");
+  const body = bodies[0];
+  const section = children(body).find((child) => child.namespace === w && child.localName === "sectPr");
+  const stylesEdge = template.package.relationships("/" + main.name).find((edge) => edge.reltype === `${r}/styles`);
+  const stylesMember = stylesEdge && !stylesEdge.is_external ? template.members.find((member) => member.name === stylesEdge.target_part.name) : void 0;
+  const stylesEditor = stylesMember ? new DocumentXmlEditor(stylesMember.bytes, {}, void 0, budget) : void 0;
+  const rendered = renderContent(content, w, budget, stylesEditor?.root, pageGeometry(void 0, section, w, children).width, styleAllocationIds(template.package.parts, budget, template[admittedXml]));
+  if (rendered.body) editor[appendBodyBlocks](body, rendered.body);
+  if (rendered.styles && stylesEditor) stylesEditor.insertChildren(stylesEditor.root, rendered.styles);
+  const archive = { ...template, members: template.members.map((member) => member === main ? { ...member, bytes: editor.serialize() } : member === stylesMember && rendered.styles ? { ...member, bytes: stylesEditor.serialize() } : member) };
+  if (rendered.styles && !stylesEditor) return admitCreated(addDocumentStylesPart(archive, template, rendered.styles, budget).archive, context);
+  return admitCreated(archive, context);
+}
+async function createDocument(options, publication, context) {
+  const { budget, limits } = archiveSettings(context);
+  closedRecord(publication, ["input", "output", "force", "dryRun", "json"]);
+  publication = { ...publication, ...publication.input ? { input: { path: publication.input.path, stat: { ...publication.input.stat } } } : {} };
+  const prospective = { version: 1, operation: "create", ok: true, data: {
+    changed: true,
+    changes: [],
+    dryRun: publication.dryRun ?? false,
+    output: publication.dryRun ? null : { path: publication.output ?? null, bytes: Math.min(limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) }
+  }, warnings: [], errors: [], affected: 1, locations: [] };
+  if (publication.output !== "-" || publication.dryRun) budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify(prospective) + "\n").length);
+  const archive = await createDocumentArchive(options, { ...context, budget });
+  const result = await publishDocumentArchive(archive, { ...publication, creation: true }, { ...context, budget, encoding: { order: "name", compression: "store" } });
+  return {
+    changed: true,
+    changes: [],
+    dryRun: publication.dryRun ?? false,
+    output: result.published.length ? { path: result.published[0].path, bytes: result.published[0].bytes, sha256: result.archiveSha256 } : null
+  };
+}
+
+export {
+  originalModelDefaults,
+  createDocumentArchive,
+  createDocument
+};

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

@@ -0,0 +1,6 @@
+// packages/safe-bash-command-node/src/commands/safejs/runtime.ts
+import { createSafeJsCommands } from "../../safe-bash-command-safejs/runtime.js";
+
+export {
+  createSafeJsCommands
+};

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

@@ -0,0 +1,227 @@
+import {
+  SelectionError,
+  readSelectionIndex
+} from "./chunk-CKEODJVT.js";
+import {
+  readPackage
+} from "./chunk-FRZ5P5AB.js";
+import {
+  readBinary
+} from "./chunk-TL3KDYEM.js";
+import {
+  equationOpaqueElements,
+  interpretCompatibility
+} from "./chunk-5DFZAJHL.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/text-reading.ts
+import { SaxesParser } from "saxes";
+var presentationNamespaces = [
+  "http://schemas.openxmlformats.org/presentationml/2006/main",
+  "http://purl.oclc.org/ooxml/presentationml/main"
+];
+var drawingNamespaces = [
+  "http://schemas.openxmlformats.org/drawingml/2006/main",
+  "http://purl.oclc.org/ooxml/drawingml/main"
+];
+var relationshipNamespaces = [
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+  "http://purl.oclc.org/ooxml/officeDocument/relationships"
+];
+var scopes = [
+  "slides",
+  "notes",
+  "layouts",
+  "masters",
+  "notes-master",
+  "handout-master"
+];
+function attr(element, name) {
+  return element.attributes.find((a) => a.name.namespace === "" && a.name.localName === name)?.value ?? null;
+}
+function validateTextReadingOptions(options) {
+  if (!options || typeof options !== "object" || Array.isArray(options) || Object.keys(options).some((key) => !["scope", "select", "shape"].includes(key)) || options.scope !== void 0 && !scopes.includes(options.scope) || options.shape !== void 0 && typeof options.shape !== "string")
+    throw new OfficeError("invalid-value", "Invalid text reading options.", "usage");
+  if (options.shape !== void 0 && (!options.shape || options.select?.kind !== "slide" || options.select.token !== void 0 || options.select.all))
+    throw new SelectionError("invalid-selection");
+}
+async function readPresentationText(input, options, context) {
+  const bodies = await readTextBodies(input, options, context);
+  const segments = bodies.map((body) => body.segment);
+  return {
+    text: segments.map((segment) => segment.text).join("\n"),
+    order: "structural",
+    segments
+  };
+}
+async function readTextBodies(input, options, context) {
+  validateTextReadingOptions(options);
+  const scope = options.scope ?? "slides";
+  const bytes = await readBinary(input, context, {
+    maxBytes: Math.min(context.limits.maxBytes, context.archiveLimits.maxArchiveBytes)
+  });
+  const index = await readSelectionIndex(bytes, context);
+  const reader = await readPackage(bytes, context);
+  const selected = options.select === void 0 ? void 0 : index.select(options.select);
+  if (selected?.some((item) => item.kind === "slide") && ["notes-master", "handout-master"].includes(scope))
+    throw new SelectionError("invalid-selection");
+  if (options.shape !== void 0 && selected?.length !== 1)
+    throw new SelectionError("invalid-selection");
+  const selectedSlides = selected?.filter((item) => item.kind === "slide") ?? index.slides;
+  if (selected?.some((item) => item.kind !== "slide" && item.scope !== scope))
+    throw new SelectionError("invalid-selection");
+  const target = (owner, type) => {
+    const matches = index.inventory.relationships.filter(
+      (edge) => edge.owner === owner && relationshipNamespaces.some((ns) => edge.type === `${ns}/${type}`)
+    );
+    if (matches.length > 1)
+      throw new OfficeError("invalid-opc", "Ambiguous text scope relationship.", "select");
+    return matches[0]?.targetPart ?? void 0;
+  };
+  const owners = /* @__PURE__ */ new Set();
+  for (const slide of selectedSlides) {
+    const layout = target(slide.part, "slideLayout");
+    const owner = scope === "slides" ? slide.part : scope === "notes" ? target(slide.part, "notesSlide") : scope === "layouts" ? layout : scope === "masters" && layout ? target(layout, "slideMaster") : void 0;
+    if (owner) owners.add(owner);
+  }
+  if (!selected && scope !== "slides" && scope !== "notes")
+    for (const part of index.parts.filter((part2) => part2.scope === scope)) owners.add(part.part);
+  if (selected) {
+    for (const item of selected) if (item.kind !== "slide") owners.add(item.part);
+  }
+  const named = options.shape === void 0 ? void 0 : index.objects.filter(
+    (item) => owners.has(item.part) && item.scope === scope && item.name === options.shape
+  );
+  if (named && named.length !== 1)
+    throw new SelectionError(
+      named.length ? "ambiguous-selection" : "missing-selection",
+      named.slice(0, 20).map((item) => item.location)
+    );
+  const bodies = [];
+  for (const owner of owners) {
+    const part = parseXmlPart(reader.get(owner), context.xmlLimits);
+    const view = interpretCompatibility(
+      part,
+      [...presentationNamespaces, ...drawingNamespaces, ...relationshipNamespaces],
+      [
+        ...equationOpaqueElements,
+        ...presentationNamespaces.map((namespace) => ({ namespace, localName: "ext" })),
+        ...drawingNamespaces.flatMap(
+          (namespace) => ["ext", "graphicData"].map((localName) => ({ namespace, localName }))
+        )
+      ],
+      (element) => drawingNamespaces.includes(element.name.namespace) && element.name.localName === "graphicData" && (drawingNamespaces.some((ns) => attr(element, "uri") === `${ns}/table`) || element.children.some(
+        (child) => drawingNamespaces.includes(child.name.namespace) && child.name.localName === "tbl"
+      ))
+    );
+    const is = (node, local, namespaces = presentationNamespaces) => node.name.localName === local && namespaces.includes(node.name.namespace);
+    const children = (node, local, namespaces = presentationNamespaces) => view.children(node).filter((child) => is(child, local, namespaces));
+    const characters = (node) => {
+      let value = "";
+      const parser = new SaxesParser();
+      parser.on("text", (text) => {
+        value += text;
+      });
+      parser.on("cdata", (text) => {
+        value += text;
+      });
+      parser.write(part.markup(node)).close();
+      return value;
+    };
+    const body = (node, location, cell) => {
+      const bodyChildren = (node2, local) => view.children(node2).filter((child) => is(child, local, drawingNamespaces));
+      const paragraphNodes = bodyChildren(node, "p");
+      const paragraphs = paragraphNodes.map((paragraph, index2) => {
+        const inlines = [];
+        for (const inline of view.children(paragraph)) {
+          if (is(inline, "br", drawingNamespaces)) inlines.push({ kind: "break", text: "\v" });
+          else if (is(inline, "r", drawingNamespaces) || is(inline, "fld", drawingNamespaces)) {
+            const text = bodyChildren(inline, "t").map(characters).join("");
+            inlines.push(
+              is(inline, "fld", drawingNamespaces) ? {
+                kind: "field",
+                cachedText: text,
+                fieldId: attr(inline, "id"),
+                fieldType: attr(inline, "type")
+              } : { kind: "run", text }
+            );
+          }
+        }
+        return {
+          index: index2,
+          coordinateSystem: "zero-based",
+          text: inlines.map((inline) => inline.kind === "field" ? inline.cachedText : inline.text).join(""),
+          inlines
+        };
+      });
+      bodies.push({
+        part: owner,
+        document: part,
+        node,
+        paragraphs: paragraphNodes.map((node2) => ({ node: node2, inlines: view.children(node2) })),
+        segment: {
+          location,
+          text: paragraphs.map((paragraph) => paragraph.text).join("\n"),
+          paragraphs,
+          ...cell ? { cell } : {}
+        }
+      });
+    };
+    const visit = (parent, inheritedSelection = false) => {
+      for (const shape of view.children(parent)) {
+        if (!presentationNamespaces.includes(shape.name.namespace) || !["sp", "cxnSp", "graphicFrame", "grpSp", "pic"].includes(shape.name.localName))
+          continue;
+        const nonVisual = view.children(shape).find(
+          (node) => presentationNamespaces.includes(node.name.namespace) && ["nvSpPr", "nvCxnSpPr", "nvGraphicFramePr", "nvGrpSpPr", "nvPicPr"].includes(
+            node.name.localName
+          )
+        );
+        const identity = nonVisual && children(nonVisual, "cNvPr")[0];
+        const object = identity && index.objects.find(
+          (item) => item.part === owner && Number(item.id) === Number(attr(identity, "id"))
+        );
+        if (!object)
+          throw new OfficeError("invalid-opc", "Missing text object identity.", "select");
+        const included = inheritedSelection || (named ? named[0].token === object.token : !selected || selected.some(
+          (item) => item.kind === "slide" || item.part === owner && (item.kind === "part" || item.id === object.id)
+        ));
+        if (is(shape, "grpSp")) {
+          visit(shape, included);
+          continue;
+        }
+        if (!included) continue;
+        for (const textBody of children(shape, "txBody")) body(textBody, object.location);
+        for (const graphic of children(shape, "graphic", drawingNamespaces))
+          for (const data of children(graphic, "graphicData", drawingNamespaces)) {
+            if (!data.children.some((node) => is(node, "tbl", drawingNamespaces)) && !drawingNamespaces.some((ns) => attr(data, "uri") === `${ns}/table`))
+              continue;
+            for (const table of children(data, "tbl", drawingNamespaces))
+              children(table, "tr", drawingNamespaces).forEach((row, rowIndex) => {
+                children(row, "tc", drawingNamespaces).forEach((cell, column) => {
+                  for (const textBody of children(cell, "txBody", drawingNamespaces))
+                    body(textBody, object.location, {
+                      coordinateSystem: "zero-based",
+                      row: rowIndex,
+                      column
+                    });
+                });
+              });
+          }
+      }
+    };
+    for (const common of children(part.root, "cSld"))
+      for (const tree of children(common, "spTree")) visit(tree);
+  }
+  return bodies;
+}
+
+export {
+  validateTextReadingOptions,
+  readPresentationText,
+  readTextBodies
+};

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

@@ -0,0 +1,142 @@
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/package-uri.ts
+function unsafeName() {
+  throw new OfficeError("unsafe-path", "Invalid package part name.", "index");
+}
+function unreserved(code) {
+  return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || "-._~".includes(String.fromCharCode(code));
+}
+function international(code) {
+  return code >= 160 && code <= 55295 || code >= 63744 && code <= 64975 || code >= 65008 && code <= 65519 || code >= 65536 && code <= 983037 && (code & 65535) <= 65533 && (code < 917504 || code >= 921600);
+}
+function partName(value, zipName) {
+  if (typeof value !== "string" || !value || !zipName && !value.startsWith("/")) unsafeName();
+  const source = zipName ? value : value.slice(1);
+  if (source === "[Content_Types].xml") return `/${source}`;
+  const segments = source.split("/");
+  const mapped = segments.map((segment) => {
+    if (!segment || segment.endsWith(".")) unsafeName();
+    let result = "";
+    for (let index = 0; index < segment.length; index++) {
+      const code = segment.codePointAt(index);
+      if (code === 37) {
+        let encoded = "";
+        do {
+          const hex = segment.slice(index + 1, index + 3);
+          if (hex.length !== 2 || [...hex].some((digit) => !"0123456789abcdefABCDEF".includes(digit)))
+            unsafeName();
+          const byte = Number.parseInt(hex, 16);
+          if (byte < 128) {
+            if (encoded) {
+              index--;
+              break;
+            }
+            if (byte < 32 || byte === 127 || byte === 47 || byte === 92 || unreserved(byte))
+              unsafeName();
+            result += `%${hex.toUpperCase()}`;
+            index += 2;
+            break;
+          }
+          encoded += `%${hex}`;
+          index += 3;
+          if (segment[index] !== "%") {
+            index--;
+            break;
+          }
+        } while (index < segment.length);
+        if (encoded) {
+          if (!zipName) unsafeName();
+          try {
+            const decoded = decodeURIComponent(encoded);
+            if ([...decoded].some((character) => !international(character.codePointAt(0))))
+              unsafeName();
+            result += decoded;
+          } catch {
+            unsafeName();
+          }
+        }
+      } else {
+        if (code < 128) {
+          if (!unreserved(code) && !"!$&'()*+,;=:@".includes(segment[index])) unsafeName();
+        } else if (zipName || !international(code)) {
+          unsafeName();
+        }
+        result += String.fromCodePoint(code);
+        if (code > 65535) index++;
+      }
+    }
+    return result;
+  });
+  return `/${mapped.join("/")}`;
+}
+function asciiKey(name) {
+  let result = "";
+  for (const character of name) {
+    const code = character.charCodeAt(0);
+    result += code >= 65 && code <= 90 ? String.fromCharCode(code + 32) : character;
+  }
+  return result;
+}
+function packageUri(value) {
+  const name = value === "/" ? "/" : partName(value, false);
+  const slash = name.lastIndexOf("/");
+  const filename = name.slice(slash + 1);
+  const dot = filename.lastIndexOf(".");
+  const ext = dot < 0 ? "" : filename.slice(dot + 1);
+  const stem = dot < 0 ? filename : filename.slice(0, dot);
+  let start = stem.length;
+  while (start > 0 && "0123456789".includes(stem[start - 1])) start--;
+  const idx = start === stem.length ? null : Number(stem.slice(start));
+  if (idx !== null && !Number.isSafeInteger(idx)) {
+    throw new OfficeError("invalid-value", "Part index exceeds the safe integer range.", "index");
+  }
+  return Object.freeze({
+    name,
+    key: asciiKey(name),
+    baseURI: name.slice(0, slash) || "/",
+    filename,
+    ext,
+    idx,
+    relsUri: `${name.slice(0, slash + 1)}_rels/${filename}.rels`
+  });
+}
+function resolvePartReference(baseURI, reference) {
+  const base = baseURI === "/" ? [] : partName(baseURI, false).slice(1).split("/");
+  if (typeof reference !== "string" || !reference || reference.startsWith("//")) unsafeName();
+  if (!reference.startsWith("/") && reference.split("/")[0].includes(":")) unsafeName();
+  const segments = reference.startsWith("/") ? [] : base;
+  const input = reference.startsWith("/") ? reference.slice(1) : reference;
+  for (const segment of input.split("/")) {
+    if (segment === ".") continue;
+    if (segment === "..") {
+      if (!segments.length) unsafeName();
+      segments.pop();
+    } else {
+      partName(`/${segment}`, false);
+      segments.push(segment);
+    }
+  }
+  if (input.endsWith("/.") || input.endsWith("/..") || input === "." || input === "..")
+    unsafeName();
+  return partName(`/${segments.join("/")}`, false);
+}
+function relativePartReference(target, baseURI) {
+  const destination = partName(target, false).slice(1).split("/");
+  const base = baseURI === "/" ? [] : partName(baseURI, false).slice(1).split("/");
+  let shared = 0;
+  while (shared < base.length && shared < destination.length - 1 && asciiKey(base[shared]) === asciiKey(destination[shared]))
+    shared++;
+  const value = [...base.slice(shared).map(() => ".."), ...destination.slice(shared)].join("/");
+  return value.split("/")[0].includes(":") ? `./${value}` : value;
+}
+
+export {
+  partName,
+  asciiKey,
+  packageUri,
+  resolvePartReference,
+  relativePartReference
+};