@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,215 @@
+import {
+  InvalidPackageError
+} from "./chunk-MWAAMNAM.js";
+import {
+  InputTypeError
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/relationship-type.ts
+function asciiLetter(char) {
+  return char >= "a" && char <= "z" || char >= "A" && char <= "Z";
+}
+function iriComponent(value, extra, query = false) {
+  for (let index = 0; index < value.length; index++) {
+    const char = value[index], point = value.codePointAt(index);
+    if (char === "%") {
+      if (index + 2 >= value.length || !"0123456789abcdefABCDEF".includes(value[index + 1]) || !"0123456789abcdefABCDEF".includes(value[index + 2])) return false;
+      index += 2;
+      continue;
+    }
+    if (asciiLetter(char) || char >= "0" && char <= "9" || "-._~!$&'()*+,;=".includes(char) || extra.includes(char)) continue;
+    const international = point >= 160 && point <= 55295 || point >= 63744 && point <= 64975 || point >= 65008 && point <= 65519 || point >= 65536 && point <= 983037 && (point & 65535) <= 65533 && !(point >= 917504 && point < 921600);
+    const privateQuery = query && (point >= 57344 && point <= 63743 || point >= 983040 && point <= 1048573 || point >= 1048576 && point <= 1114109);
+    if (!international && !privateQuery) return false;
+    if (point > 65535) index++;
+  }
+  return true;
+}
+function ipLiteral(value) {
+  const address = value.slice(1, -1);
+  if (address[0] === "v" || address[0] === "V") {
+    const dot = address.indexOf(".");
+    if (dot <= 1 || dot === address.length - 1) return false;
+    for (const char of address.slice(1, dot)) if (!"0123456789abcdefABCDEF".includes(char)) return false;
+    for (const char of address.slice(dot + 1)) if (!asciiLetter(char) && !(char >= "0" && char <= "9") && !"-._~!$&'()*+,;=:".includes(char)) return false;
+    return true;
+  }
+  for (const char of address) if (!"0123456789abcdefABCDEF:.".includes(char)) return false;
+  try {
+    return new URL(`http://${value}/`).hostname.startsWith("[");
+  } catch {
+    return false;
+  }
+}
+function iriAuthority(value) {
+  const at = value.lastIndexOf("@");
+  if (at >= 0) {
+    if (!iriComponent(value.slice(0, at), ":")) return false;
+    value = value.slice(at + 1);
+  }
+  let port;
+  if (value.startsWith("[")) {
+    const end = value.indexOf("]");
+    if (end < 0 || !ipLiteral(value.slice(0, end + 1))) return false;
+    const suffix = value.slice(end + 1);
+    if (suffix && !suffix.startsWith(":")) return false;
+    if (suffix) port = suffix.slice(1);
+  } else {
+    const colon = value.indexOf(":");
+    if (!iriComponent(colon < 0 ? value : value.slice(0, colon), "")) return false;
+    if (colon >= 0) port = value.slice(colon + 1);
+  }
+  if (port !== void 0) {
+    for (const char of port) if (char < "0" || char > "9") return false;
+  }
+  return true;
+}
+function isAbsoluteRelationshipType(value) {
+  const colon = value.indexOf(":");
+  if (colon < 1 || !asciiLetter(value[0])) return false;
+  for (const char of value.slice(1, colon)) if (!asciiLetter(char) && !(char >= "0" && char <= "9") && !"+.-".includes(char)) return false;
+  const query = value.indexOf("?", colon + 1), hierarchy = value.slice(colon + 1, query < 0 ? void 0 : query);
+  if (query >= 0 && !iriComponent(value.slice(query + 1), ":@/?", true)) return false;
+  if (hierarchy.startsWith("//")) {
+    const slash = hierarchy.indexOf("/", 2);
+    return iriAuthority(hierarchy.slice(2, slash < 0 ? void 0 : slash)) && (slash < 0 || iriComponent(hierarchy.slice(slash), ":@/"));
+  }
+  return iriComponent(hierarchy, ":@/");
+}
+function isRelationshipTargetReference(value) {
+  const hash = value.indexOf("#");
+  if (hash >= 0) {
+    if (!iriComponent(value.slice(hash + 1), ":@/?")) return false;
+    value = value.slice(0, hash);
+  }
+  const query = value.indexOf("?"), hierarchy = value.slice(0, query < 0 ? void 0 : query);
+  const colon = hierarchy.indexOf(":"), slash = hierarchy.indexOf("/");
+  if (colon >= 0 && (slash < 0 || colon < slash)) return isAbsoluteRelationshipType(value);
+  if (query >= 0 && !iriComponent(value.slice(query + 1), ":@/?", true)) return false;
+  if (hierarchy.startsWith("//")) {
+    const end = hierarchy.indexOf("/", 2);
+    return iriAuthority(hierarchy.slice(2, end < 0 ? void 0 : end)) && (end < 0 || iriComponent(hierarchy.slice(end), ":@/"));
+  }
+  return iriComponent(hierarchy, ":@/");
+}
+
+// packages/safe-bash-docx-engine/src/part-uri.ts
+function invalidPackage() {
+  throw new InvalidPackageError("Invalid document OPC container.");
+}
+function asciiKey(value) {
+  let result = "";
+  for (const char of value) result += char >= "A" && char <= "Z" ? char.toLowerCase() : char;
+  return result;
+}
+function relationshipOwner(name) {
+  if (asciiKey(name) === "/_rels/.rels") return "/";
+  const segments = name.split("/");
+  const filename = segments.pop();
+  if (asciiKey(segments.at(-1) ?? "") !== "_rels" || !asciiKey(filename).endsWith(".rels")) return null;
+  segments.pop();
+  return normalizePartName([...segments, filename.slice(0, -5)].join("/"));
+}
+function unreserved(char) {
+  return char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char >= "0" && char <= "9" || "-._~".includes(char);
+}
+function unicodeCharacter(char) {
+  const point = char.codePointAt(0);
+  return point >= 160 && point <= 55295 || point >= 63744 && point <= 64975 || point >= 65008 && point <= 65519 || point >= 65536 && point <= 983037 && (point & 65535) <= 65533 && !(point >= 917504 && point < 921600);
+}
+function segmentName(segment, target) {
+  let result = "";
+  for (let index = 0; index < segment.length; ) {
+    const char = String.fromCodePoint(segment.codePointAt(index));
+    if (char === "%") {
+      let encoded = "";
+      while (segment[index] === "%") {
+        const digits = segment.slice(index + 1, index + 3);
+        if (digits.length !== 2 || [...digits].some((digit) => !"0123456789abcdefABCDEF".includes(digit)))
+          invalidPackage();
+        encoded += `%${digits}`;
+        index += 3;
+      }
+      let decoded;
+      try {
+        decoded = decodeURIComponent(encoded);
+      } catch {
+        return invalidPackage();
+      }
+      for (const value of decoded) {
+        const point = value.codePointAt(0);
+        if (value === "/" || value === "\\" || point < 32 || point === 127) invalidPackage();
+        if (point >= 128) {
+          if (!unicodeCharacter(value)) invalidPackage();
+          result += value;
+        } else if (unreserved(value)) {
+          if (!target) invalidPackage();
+          result += value;
+        } else result += `%${point.toString(16).toUpperCase().padStart(2, "0")}`;
+      }
+    } else {
+      if (!unreserved(char) && !"!$&'()*+,;=:@".includes(char) && !unicodeCharacter(char))
+        invalidPackage();
+      result += char;
+      index += char.length;
+    }
+  }
+  if (!result || result.endsWith(".")) invalidPackage();
+  return result;
+}
+function normalizePartName(name) {
+  if (typeof name !== "string") throw new InputTypeError("Expected a part URI string.");
+  if (!name.startsWith("/")) invalidPackage();
+  return "/" + name.slice(1).split("/").map((segment) => segmentName(segment, false)).join("/");
+}
+function resolvePartTarget(owner, target) {
+  if (typeof target !== "string")
+    throw new InputTypeError("Expected a relationship target string.");
+  const source = owner === "/" ? "/" : normalizePartName(owner);
+  const hash = target.indexOf("#");
+  const path = hash < 0 ? target : target.slice(0, hash);
+  const fragment = hash < 0 ? null : target.slice(hash + 1);
+  if (path.startsWith("//") || path.includes("?") || !path.startsWith("/") && path.split("/")[0].includes(":"))
+    invalidPackage();
+  if (fragment !== null && !iriComponent(fragment, ":@/?")) invalidPackage();
+  if (!path) {
+    if (source === "/") invalidPackage();
+    return { partname: source, fragment };
+  }
+  const segments = path.startsWith("/") ? [] : source.slice(1).split("/").slice(0, -1);
+  for (const segment of (path.startsWith("/") ? path.slice(1) : path).split("/")) {
+    if (segment === ".") continue;
+    if (segment === "..") {
+      segments.pop();
+      continue;
+    }
+    segments.push(segmentName(segment, true));
+  }
+  if (path.endsWith("/.") || path.endsWith("/..")) invalidPackage();
+  return { partname: normalizePartName("/" + segments.join("/")), fragment };
+}
+function relativePartTarget(owner, target) {
+  const source = owner === "/" ? [] : normalizePartName(owner).slice(1).split("/").slice(0, -1);
+  const destination = normalizePartName(target).slice(1).split("/");
+  let shared = 0;
+  while (shared < source.length && shared < destination.length - 1 && asciiKey(source[shared]) === asciiKey(destination[shared]))
+    shared++;
+  const relative = [...source.slice(shared).map(() => ".."), ...destination.slice(shared)].join(
+    "/"
+  );
+  let encoded = "";
+  for (const char of relative)
+    encoded += char.codePointAt(0) >= 128 ? encodeURIComponent(char) : char;
+  return encoded.split("/")[0].includes(":") ? "./" + encoded : encoded;
+}
+
+export {
+  isAbsoluteRelationshipType,
+  isRelationshipTargetReference,
+  invalidPackage,
+  asciiKey,
+  relationshipOwner,
+  normalizePartName,
+  resolvePartTarget,
+  relativePartTarget
+};

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

@@ -0,0 +1,125 @@
+import {
+  reviewResourceDate
+} from "./chunk-NSM366N6.js";
+import {
+  openDocumentLocations,
+  resolveDocxSelection
+} from "./chunk-LHDB4QO5.js";
+import {
+  DocumentArchiveEditor
+} from "./chunk-MAHX3IW3.js";
+import {
+  incomingResourceReferences
+} from "./chunk-W6DV2CLS.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  pathContains
+} from "./chunk-IR6ZKAUH.js";
+import {
+  DocumentPackage
+} from "./chunk-GLPIFP7N.js";
+import {
+  revisionInfo
+} from "./chunk-YPVBU7QF.js";
+import {
+  storedIntegerIdentity
+} from "./chunk-VEUQWV2V.js";
+import {
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  SelectionError
+} from "./chunk-LQOKYG3O.js";
+import {
+  InvalidValueError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/revisions.ts
+async function inspectDocumentRevisions(input, options, context, projection = "snapshot") {
+  if (projection !== "snapshot" && projection !== "resource") throw new InvalidValueError("Expected a declared revision projection.");
+  const settings = archiveSettings(context);
+  const invocation = validateDocxInvocation({ operation: "revisions.list", inputs: ["document"], options }, settings.budget);
+  const opts = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((opts.limit ?? []).map((item) => [item.name, item.value])));
+  const document = await openDocumentLocations(input, { ...settings, budget });
+  const inventory = collectDocumentRevisions(document, { scope: "all-stories", ...opts }, budget);
+  if (projection === "snapshot") return inventory;
+  const graph = new DocumentPackage(document.snapshot(), settings.limits, budget);
+  const references = /* @__PURE__ */ new Map();
+  const items = inventory.items.map((revision) => {
+    budget.charge("retainedBytes", 1536);
+    const identity = storedIntegerIdentity(revision.id ?? void 0);
+    const revisionId = identity === void 0 ? NaN : Number(identity);
+    if (!Number.isFinite(revisionId) || !Number.isInteger(revisionId) || BigInt(revisionId).toString() !== identity)
+      throw new InvalidValueError("Resource details require an exact numeric revision identity.");
+    const part = revision.location.value.part;
+    if (!references.has(part)) references.set(part, incomingResourceReferences(graph, part, budget));
+    return {
+      kind: "revisions",
+      location: revision.location,
+      ...revision.name === null ? {} : { name: revision.name },
+      properties: [
+        { name: "id", type: "string", value: revision.id, writable: false, cached: false },
+        { name: "author", type: "string", value: revision.author, writable: false, cached: false },
+        { name: "timestamp", type: "date", value: reviewResourceDate(revision.timestamp), writable: false, cached: false },
+        { name: "stored_timestamp", type: "string", value: revision.timestamp, writable: false, cached: false },
+        ...["markup", "namespace", "name", "type", "support"].map((name) => ({ name, type: "string", value: revision[name], writable: false, cached: false }))
+      ],
+      references: references.get(part),
+      support: revision.support === "opaque" ? "preserve" : "read",
+      details: { kind: "revisions", revisionId, author: revision.author ?? "", timestamp: reviewResourceDate(revision.timestamp), type: revision.type }
+    };
+  });
+  const data = { items };
+  const size = new TextEncoder().encode(JSON.stringify(data)).length;
+  budget.check("serializedOutput", size);
+  budget.charge("retainedBytes", size);
+  return data;
+}
+function collectDocumentRevisions(document, opts, budget) {
+  const { revision, view = "all", select, ...scope } = opts;
+  const target = select === void 0 ? void 0 : document.resolve(select);
+  const selected = target?.kind === "annotation" ? [target] : resolveDocxSelection(document, { operation: "text.get", inputs: ["document"], options: { ...scope, ...select === void 0 ? {} : { select } } });
+  const editor = new DocumentArchiveEditor(document.snapshot(), {}, void 0, budget);
+  let items = [];
+  for (const location of document.list("annotation", { scope: "all-stories" })) {
+    budget.charge("work", selected.length + location.value.path.length);
+    if (!selected.some((s) => s.value.story === location.value.story && (pathContains(s.value.path, location.value.path) || pathContains(location.value.path, s.value.path)))) continue;
+    let node = editor.xml(location.value.part.slice(1)).root;
+    let omitted = false;
+    for (const i of location.value.path) {
+      node = node.children[i];
+      const ancestor = revisionInfo(node);
+      omitted ||= view === "final" && (ancestor?.type === "delete" || ancestor?.markup.startsWith("moveFrom") === true) || view === "original" && (ancestor?.type === "insert" || ancestor?.markup.startsWith("moveTo") === true);
+      if (node.localName === "tr" && (node.namespace === documentDialects.transitional.w || node.namespace === documentDialects.strict.w)) {
+        const properties = node.children.find((child) => child.namespace === node.namespace && child.localName === "trPr");
+        omitted ||= properties?.children.some((child) => child.namespace === node.namespace && (view === "final" && child.localName === "del" || view === "original" && child.localName === "ins")) === true;
+      }
+    }
+    if (omitted) continue;
+    const info = revisionInfo(node);
+    if (!info) continue;
+    budget.check("matches", items.length + 1);
+    budget.charge("retainedBytes", 512);
+    items.push({ ...info, location });
+  }
+  if (revision !== void 0) {
+    const item = items[revision - 1];
+    if (!item) throw new SelectionError("missing-selection");
+    items = [item];
+  }
+  if (target && !items.length) throw new SelectionError("missing-selection");
+  const result = { view, items };
+  const size = new TextEncoder().encode(JSON.stringify(result)).length;
+  budget.check("serializedOutput", size);
+  budget.charge("retainedBytes", size);
+  return result;
+}
+
+export {
+  inspectDocumentRevisions,
+  collectDocumentRevisions
+};

package/dist/safe-bash/command-chunks/{chunk-N2A7V3WY.js → chunk-WHNYT34N.js}

@@ -1,11 +1,11 @@
 import {
   renderOutput
-} from "./chunk-XFHUSZBM.js";
+} from "./chunk-KUGV3SSL.js";
 import {
   SafeJsCommandLimitError
-} from "./chunk-G3YO3JIN.js";
+} from "./chunk-ABH5FMMA.js";
 
-// packages/safe-bash-command-node/src/commands/safejs/io.ts
+// packages/safe-bash-command-safejs/src/io.ts
 import { byteLength, concatBytes, encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
 import { yieldTurn } from "../../safe-bash-contracts/yield.js";
 import { readBytes, writeBytes } from "../../safe-bash-contracts/index.js";

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

@@ -0,0 +1,169 @@
+import {
+  documentPartRole
+} from "./chunk-DXX2Z2QA.js";
+import {
+  UnsupportedEditError,
+  activeXmlChildren,
+  displayXml
+} from "./chunk-YPVBU7QF.js";
+import {
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  MarkupCompatibility,
+  compatibilityProfileForPart
+} from "./chunk-GZ2N24A2.js";
+import {
+  parseDocumentXml,
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+
+// packages/safe-bash-docx-engine/src/font-resources.ts
+var UnsupportedEmbeddedFontMutationError = class extends UnsupportedEditError {
+  constructor() {
+    super("Embedded font mutation is unsupported; preserve font definitions, obfuscation metadata and relationships.");
+  }
+};
+var embeddedNames = /* @__PURE__ */ new Set(["embedRegular", "embedBold", "embedItalic", "embedBoldItalic"]);
+var embeddedFontContentTypes = Object.freeze(["application/vnd.openxmlformats-officedocument.obfuscatedfont", "application/x-fontdata"]);
+function fontResourceRole(contentType, root) {
+  const type = parseMediaType(contentType);
+  for (const dialect of Object.values(documentDialects)) {
+    if (type === "application/vnd.openxmlformats-officedocument.theme+xml" && root.namespace === dialect.a && root.localName === "theme") return "theme";
+    if (root.namespace !== dialect.w) continue;
+    if (type === "application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml" && root.localName === "fonts") return "fontTable";
+    if (type === "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml" && root.localName === "styles") return "styles";
+  }
+  return null;
+}
+var attr = (node, name, namespace = "") => node?.attributes.find((a) => a.localName === name && a.namespace === namespace)?.value ?? null;
+var values = (node) => Object.fromEntries(node.attributes.filter((a) => a.namespace === node.namespace).map((a) => [a.localName, a.value]));
+function readFontResources(archive, roots, budget, compatibilityViews) {
+  const { w, a, r } = documentDialects[archive.dialect];
+  const graph = archive.package;
+  const themes = [], fontTables = [];
+  const languages = [], colorMappings = [];
+  const references = [];
+  const diagnostics = [];
+  const pending = [];
+  for (const [part, root] of roots) {
+    const type = graph.getPart(part).content_type, resourceRole = fontResourceRole(type, root), documentRole = documentPartRole(type, root);
+    const formatting = resourceRole === "styles" || documentRole === "story" || documentRole === "glossary" || documentRole === "settings";
+    if (resourceRole === null && !formatting) continue;
+    const view = compatibilityViews?.get(part) ?? new MarkupCompatibility(root, compatibilityProfileForPart(part), budget);
+    const selected = /* @__PURE__ */ new Map();
+    const projection = [...view.content];
+    while (projection.length) {
+      const item = projection.pop();
+      budget.charge("work", 1);
+      if (!("source" in item) || item.disposition !== "understood") continue;
+      budget.charge("retainedBytes", item.content.length * 8);
+      if (resourceRole === "theme" || resourceRole === "fontTable" || item.source.namespace === w && (["rFonts", "themeFontLang", "clrSchemeMapping"].includes(item.source.localName) || item.source.attributes.some((attribute) => attribute.namespace === w && ["themeColor", "themeFill"].includes(attribute.localName)))) {
+        budget.charge("retainedBytes", 96 + item.content.length * 8);
+        selected.set(item.source, item.content.filter((node) => "source" in node && node.disposition === "understood").map((node) => node.source));
+      }
+      for (const child2 of item.content) projection.push(child2);
+    }
+    const children = (node) => node ? selected.get(node) ?? [] : [];
+    const child = (node, name) => children(node).find((c) => c.namespace === node?.namespace && c.localName === name);
+    if (resourceRole === "theme") {
+      const elements = child(root, "themeElements"), scheme = child(elements, "fontScheme");
+      const colors = children(child(elements, "clrScheme")).filter((n) => n.namespace === a).flatMap((n) => children(n).filter((c) => c.namespace === a).map((c) => ({ slot: n.localName, kind: c.localName, value: attr(c, "val"), lastColor: attr(c, "lastClr") })));
+      const fonts = [];
+      for (const family of ["major", "minor"]) for (const node of children(child(scheme, family + "Font"))) {
+        budget.charge("work", 1);
+        if (node.namespace === a && ["latin", "ea", "cs", "font"].includes(node.localName)) fonts.push({ family, slot: node.localName, script: attr(node, "script"), typeface: attr(node, "typeface") });
+      }
+      themes.push({ part, name: attr(root, "name"), colors, fonts });
+    }
+    if (resourceRole === "fontTable") {
+      const edges = graph.relationships(part);
+      budget.charge("work", edges.length);
+      const bindings = new Map(edges.map((edge) => [edge.rId, edge]));
+      fontTables.push({ part, fonts: children(root).filter((n) => n.namespace === w && n.localName === "font").map((node) => ({
+        name: attr(node, "name", w),
+        alternateName: attr(child(node, "altName"), "val", w),
+        charset: attr(child(node, "charset"), "val", w),
+        family: attr(child(node, "family"), "val", w),
+        pitch: attr(child(node, "pitch"), "val", w),
+        embedded: children(node).filter((n) => n.namespace === w && embeddedNames.has(n.localName)).map((n) => {
+          const id = attr(n, "id", r), edge = id === null ? void 0 : bindings.get(id);
+          const valid = edge && !edge.is_external && edge.fragment === null && edge.reltype === `${r}/font` && embeddedFontContentTypes.includes(parseMediaType(edge.target_part.content_type));
+          if (!valid) diagnostics.push({ code: "invalid-font-reference", part, message: "Embedded font reference does not identify an internal font resource." });
+          return { kind: n.localName, id, fontKey: attr(n, "fontKey", w), subsetted: attr(n, "subsetted", w), target: valid ? edge.target_part.partname : null, status: valid ? "resolved" : "invalid-font-reference" };
+        })
+      })) });
+    }
+    const stack = [{ node: root, path: [] }];
+    while (stack.length) {
+      budget.charge("work", 1);
+      const { node, path } = stack.pop();
+      for (let i = node.children.length - 1; i >= 0; i--) stack.push({ node: node.children[i], path: [...path, i] });
+      if (!formatting || node.namespace !== w || !selected.has(node)) continue;
+      if (documentRole === "settings" && node.localName === "themeFontLang") languages.push({ part, values: values(node) });
+      if (documentRole === "settings" && node.localName === "clrSchemeMapping") colorMappings.push({ part, values: values(node) });
+      for (const attribute of node.attributes) {
+        if (attribute.namespace !== w) continue;
+        if (node.localName === "rFonts" && ["asciiTheme", "hAnsiTheme", "eastAsiaTheme", "cstheme"].includes(attribute.localName) || attribute.localName === "themeColor" || attribute.localName === "themeFill") pending.push({ part, path, attribute: attribute.localName, value: attribute.value });
+      }
+    }
+  }
+  const themeByPart = new Map(themes.map((t) => [t.part, t]));
+  const fontSlots = { Ascii: "latin", HAnsi: "latin", EastAsia: "ea", Bidi: "cs" };
+  const colorSlots = { dark1: "dk1", light1: "lt1", dark2: "dk2", light2: "lt2", accent1: "accent1", accent2: "accent2", accent3: "accent3", accent4: "accent4", accent5: "accent5", accent6: "accent6", hyperlink: "hlink", followedHyperlink: "folHlink" };
+  const defaultMapping = { background1: "light1", text1: "dark1", background2: "light2", text2: "dark2" };
+  const mappingNames = { background1: "bg1", text1: "t1", background2: "bg2", text2: "t2", hyperlink: "hyperlink", followedHyperlink: "followedHyperlink" };
+  const main = "/" + archive.mainPart;
+  const settingsEdges = graph.relationships(main).filter((e) => e.reltype === `${r}/settings` && !e.is_external);
+  const settingsParts = new Set(settingsEdges.map((e) => e.target_part.partname));
+  const mappings = colorMappings.filter((m) => settingsParts.has(m.part));
+  for (const ref of pending) {
+    budget.charge("work", 1);
+    const ownedEdges = graph.relationships(ref.part), mainEdges = graph.relationships(main);
+    budget.charge("work", ownedEdges.length + mainEdges.length);
+    const local = ownedEdges.filter((e) => e.reltype === `${r}/theme`);
+    const edges = local.length ? local : mainEdges.filter((e) => e.reltype === `${r}/theme`);
+    const edge = edges.length === 1 && !edges[0].is_external && edges[0].fragment === null ? edges[0] : void 0;
+    const theme = edge && parseMediaType(edge.target_part.content_type) === "application/vnd.openxmlformats-officedocument.theme+xml" ? themeByPart.get(edge.target_part.partname) : void 0;
+    budget.charge("work", (theme?.colors.length ?? 0) + (theme?.fonts.length ?? 0));
+    let slot, exists = false;
+    if (ref.attribute === "themeColor" || ref.attribute === "themeFill") {
+      const mappingKey = Object.hasOwn(mappingNames, ref.value) ? mappingNames[ref.value] : ref.value;
+      const mapped = mappings.length === 1 && Object.hasOwn(mappings[0].values, mappingKey) ? mappings[0].values[mappingKey] : void 0;
+      const key = mapped ?? (Object.hasOwn(defaultMapping, ref.value) ? defaultMapping[ref.value] : ref.value);
+      slot = (Object.hasOwn(colorSlots, ref.value) || Object.hasOwn(defaultMapping, ref.value)) && Object.hasOwn(colorSlots, key) ? colorSlots[key] : void 0;
+      exists = theme?.colors.filter((c) => c.slot === slot).length === 1;
+    } else {
+      const family = ref.value.startsWith("major") ? "major" : ref.value.startsWith("minor") ? "minor" : void 0;
+      const key = ref.value.slice(5);
+      slot = family && Object.hasOwn(fontSlots, key) ? fontSlots[key] : void 0;
+      exists = theme?.fonts.filter((f) => f.family === family && f.slot === slot).length === 1;
+    }
+    const status = !slot ? "invalid-theme-reference" : !theme ? "missing-theme" : !exists ? "missing-theme-slot" : "resolved";
+    references.push({ ...ref, resource: theme?.part ?? null, status });
+    if (status !== "resolved") diagnostics.push({ code: status, part: ref.part, message: "Stored theme reference cannot resolve to one supported package slot; no font or color is inferred." });
+  }
+  return { themes, fontTables, references, languages, colorMappings, diagnostics, availability: null, licensing: null, embeddedFontMutation: "unsupported" };
+}
+function embeddedFontState(graph, budget) {
+  const state = [];
+  for (const part of graph.parts) {
+    budget.charge("work", 1);
+    if (parseMediaType(part.content_type) === "application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml") {
+      const root = parseDocumentXml(part.bytes, {}, budget).root;
+      const children = activeXmlChildren(root, budget);
+      for (const font of children(root)) if (font.namespace === root.namespace && font.localName === "font" && children(font).some((n) => n.namespace === root.namespace && embeddedNames.has(n.localName))) state.push([part.partname, displayXml(font, budget, false)]);
+    }
+    if (part.content_type.toLowerCase() === "application/vnd.openxmlformats-package.relationships+xml") continue;
+    for (const edge of graph.relationships(part.partname)) if (Object.values(documentDialects).some((dialect) => edge.reltype === `${dialect.r}/font` || edge.reltype === `${dialect.r}/fontTable`)) state.push([part.partname, edge.rId, edge.reltype, edge.target_ref, edge.is_external]);
+  }
+  return JSON.stringify(state);
+}
+
+export {
+  UnsupportedEmbeddedFontMutationError,
+  embeddedFontContentTypes,
+  fontResourceRole,
+  readFontResources,
+  embeddedFontState
+};