@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,1677 @@
+import {
+  acquireDocumentModelInput
+} from "./chunk-ZXKOMB24.js";
+import {
+  PackURI
+} from "./chunk-S6PPBBXX.js";
+import {
+  createPropertyPart
+} from "./chunk-W32KW66B.js";
+import {
+  inlineImageRun
+} from "./chunk-WVESNAND.js";
+import {
+  Image,
+  copyImageForOwner,
+  modelVfsResolver
+} from "./chunk-A7EMM3SB.js";
+import {
+  contextData,
+  modelContext
+} from "./chunk-2W54TAGI.js";
+import {
+  createDocumentArchive,
+  originalModelDefaults
+} from "./chunk-XH6DXJHX.js";
+import {
+  styleAllocationIds
+} from "./chunk-MQFXMBGD.js";
+import {
+  UnsupportedEmbeddedFontMutationError,
+  embeddedFontState
+} from "./chunk-WOZCIRJ5.js";
+import {
+  assertLiveCommentExtensionPartPreserved
+} from "./chunk-IFNLDOJ4.js";
+import {
+  retainedRelationshipTargets
+} from "./chunk-4LXDJES2.js";
+import {
+  SemanticValidationError,
+  validateDocumentArchive
+} from "./chunk-3SEQG5JH.js";
+import {
+  PublicationError
+} from "./chunk-JGGRMERW.js";
+import {
+  DocumentPackage,
+  documentTypes,
+  readDocumentArchive
+} from "./chunk-GLPIFP7N.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  activeXmlChildren,
+  editActiveRelationshipXml,
+  runElementOpen,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  corePropertyKeys,
+  corePropertyNamespace,
+  normalizePropertyDate,
+  readCorePropertyDate,
+  readPropertyNodes,
+  serializePropertyScalar
+} from "./chunk-VEUQWV2V.js";
+import {
+  collapseRelationshipScalar,
+  relationshipXmlIds,
+  relationshipXmlRows
+} from "./chunk-2PSVE7I5.js";
+import {
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  snapshotSequence,
+  validateDocxValue
+} from "./chunk-R4TYL2G6.js";
+import {
+  compatibilityProfileForPart
+} from "./chunk-GZ2N24A2.js";
+import {
+  BoundsError,
+  MissingKeyError,
+  OwnershipError,
+  StaleHandleError
+} from "./chunk-OBK24KGM.js";
+import {
+  asciiKey,
+  normalizePartName,
+  relativePartTarget
+} from "./chunk-WAKYUXVQ.js";
+import {
+  isXmlContentType,
+  parseDocumentXml,
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+import {
+  InputTypeError,
+  InvalidValueError,
+  ResourceLimitError,
+  archiveSettings
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/xml-element-view.ts
+var replaceXmlScalar = /* @__PURE__ */ Symbol("replace-xml-scalar");
+function expanded(node) {
+  return Object.freeze({ namespaceURI: node.namespace, localName: node.localName });
+}
+function markup(node, budget, depth = 1) {
+  budget.check("xmlDepth", depth);
+  budget.charge("work", 1);
+  if (node.kind === "text") return xmlValue(node.text);
+  if (node.kind === "comment") return `<!--${node.text}-->`;
+  if (node.kind === "processingInstruction") return `<?${node.target}${node.data ? " " + node.data : ""}?>`;
+  if (node.kind !== "element") throw new InputTypeError("Expected a structured XML element.");
+  const namespaces = /* @__PURE__ */ new Map();
+  const qualify = (name, attribute = false) => {
+    if (!name.namespaceURI) return name.localName;
+    if (name.namespaceURI === "http://www.w3.org/2000/xmlns/") throw new UnsupportedEditError("Namespace declarations are not mutable attributes.");
+    const prefix = name.namespaceURI === "http://www.w3.org/XML/1998/namespace" ? "xml" : name.namespaceURI === "http://purl.org/dc/terms/" ? "dcterms" : [...namespaces].find(([, uri]) => uri === name.namespaceURI)?.[0] ?? `x${namespaces.size}`;
+    namespaces.set(prefix, name.namespaceURI);
+    if (attribute && name.localName === "xmlns") throw new UnsupportedEditError("Namespace declarations are not mutable attributes.");
+    return `${prefix}:${name.localName}`;
+  };
+  const tag = qualify(node.name);
+  const attributes = (node.attributes ?? []).map((attribute) => ` ${qualify(attribute.name, true)}="${xmlValue(attribute.value)}"`).join("");
+  const declarations = [...namespaces].filter(([prefix]) => prefix !== "xml").map(([prefix, uri]) => ` xmlns:${prefix}="${xmlValue(uri)}"`).join("");
+  const children = (node.children ?? []).map((child) => markup(child, budget, depth + 1)).join("");
+  budget.charge("retainedBytes", (tag.length + attributes.length + declarations.length + children.length) * 2);
+  return `<${tag}${node.name.namespaceURI ? "" : ' xmlns=""'}${declarations}${attributes}>${children}</${tag}>`;
+}
+var XmlViewStore = class {
+  constructor(binding) {
+    this.binding = binding;
+  }
+  binding;
+  paths = /* @__PURE__ */ new Map();
+  source;
+  read() {
+    this.binding.budget.check("work", 0);
+    const xml = this.binding.read(), root = this.binding.resolve(xml);
+    const source = xml.sourceXml(root);
+    if (this.source !== void 0 && source !== this.source) {
+      for (const [view, path] of this.paths) if (path?.length) this.paths.set(view, null);
+    }
+    this.source = source;
+    return { xml, root };
+  }
+  node(view) {
+    const { xml, root } = this.read(), path = this.paths.get(view);
+    if (!path) throw new StaleHandleError("The XML view is detached.");
+    let node = root;
+    for (const index of path) {
+      this.binding.budget.charge("work", 1);
+      const child = node.children[index];
+      if (!child) throw new StaleHandleError("The XML view is detached.");
+      node = child;
+    }
+    return { xml, node };
+  }
+  view(path) {
+    this.binding.budget.charge("retainedBytes", 128 + path.length * 8);
+    const view = new XmlElementView(this);
+    this.paths.set(view, path);
+    return view;
+  }
+  change(action) {
+    this.read();
+    this.binding.change((xml2) => action(xml2, this.binding.resolve(xml2)));
+    const xml = this.binding.read();
+    this.source = xml.sourceXml(this.binding.resolve(xml));
+  }
+  shift(parent, index, remove) {
+    for (const [view, path] of this.paths) {
+      if (!path || path.length <= parent.length || !parent.every((value, offset) => path[offset] === value)) continue;
+      const position = path[parent.length];
+      if (remove && position === index) this.paths.set(view, null);
+      else if (position >= index) this.paths.set(view, [...path.slice(0, parent.length), position + (remove ? -1 : 1), ...path.slice(parent.length + 1)]);
+    }
+  }
+};
+var XmlElementView = class {
+  #store;
+  constructor(store) {
+    this.#store = store;
+    Object.freeze(this);
+  }
+  get tag() {
+    return expanded(this.#store.node(this).node);
+  }
+  get localName() {
+    return this.tag.localName;
+  }
+  get namespace() {
+    return this.tag.namespaceURI;
+  }
+  get attributes() {
+    const attributes = this.#store.node(this).node.attributes;
+    this.#store.binding.budget.charge("retainedBytes", attributes.length * 128);
+    return new Map(attributes.filter((attribute) => attribute.namespace !== "http://www.w3.org/2000/xmlns/").map((attribute) => [expanded(attribute), attribute.value]));
+  }
+  get children() {
+    const { node } = this.#store.node(this), path = this.#store.paths.get(this);
+    return snapshotSequence(node.children.map((_, index) => this.#store.view([...path, index])));
+  }
+  get text() {
+    const { node } = this.#store.node(this);
+    let text = "";
+    for (const token of node.content) {
+      if (token.kind !== "text" && token.kind !== "cdata") break;
+      text += token.text;
+    }
+    return text || null;
+  }
+  set text(value) {
+    if (value !== null && typeof value !== "string") throw new InputTypeError("Expected XML text or null.");
+    this.#store.node(this);
+    const path = this.#store.paths.get(this);
+    this.#store.change((xml, root) => xml.setLeadingText(this.resolve(root, path), value));
+  }
+  [replaceXmlScalar](value) {
+    if (typeof value !== "string") throw new InputTypeError("Expected scalar XML text.");
+    this.#store.node(this);
+    const path = this.#store.paths.get(this);
+    this.#store.change((xml, root) => xml.replaceScalarText(this.resolve(root, path), value));
+  }
+  get tail() {
+    const { xml, node } = this.#store.node(this);
+    const stack = [xml.root];
+    let content = xml.root.epilog ?? [], index = 0;
+    while (stack.length) {
+      const parent = stack.pop();
+      this.#store.binding.budget.charge("work", 1);
+      if (parent.children.includes(node)) {
+        content = parent.content;
+        index = content.indexOf(node) + 1;
+        break;
+      }
+      for (const child of parent.children) stack.push(child);
+    }
+    let text = "";
+    for (; index < content.length; index++) {
+      const token = content[index];
+      if (token.kind !== "text" && token.kind !== "cdata") break;
+      text += token.text;
+    }
+    return text || null;
+  }
+  set tail(value) {
+    if (value !== null && typeof value !== "string") throw new InputTypeError("Expected XML tail or null.");
+    this.#store.node(this);
+    const path = this.#store.paths.get(this);
+    this.#store.change((xml, root) => xml.setElementTail(this.resolve(root, path), value));
+  }
+  set_attribute(name, value) {
+    if (!validateDocxValue("ExpandedName", name) || value !== null && typeof value !== "string") throw new InputTypeError("Expected an expanded XML attribute and string or null.");
+    this.#store.node(this);
+    const path = this.#store.paths.get(this);
+    this.#store.change((xml, root) => xml.setQualifiedAttribute(this.resolve(root, path), { namespace: name.namespaceURI, localName: name.localName }, value));
+  }
+  insert(index, node) {
+    const { node: parent } = this.#store.node(this), path = this.#store.paths.get(this);
+    if (!Number.isSafeInteger(index) || index < 0 || index > parent.children.length) throw new BoundsError("XML child index is out of range.");
+    if (!validateDocxValue("XmlNodeInput", node)) throw new InputTypeError("Expected an original structured XML node.");
+    const source = markup(node, this.#store.binding.budget);
+    this.#store.change((xml, root) => {
+      const parent2 = this.resolve(root, path);
+      xml.insertChildren(parent2, source, parent2.children[index]);
+    });
+    this.#store.binding.inserted?.(parent, node, index);
+    if (node.kind !== "element") return this;
+    this.#store.shift(path, index, false);
+    return this.#store.view([...path, index]);
+  }
+  remove() {
+    const { xml, node } = this.#store.node(this), path = this.#store.paths.get(this);
+    if (!path.length && this.#store.binding.removeRoot) {
+      this.#store.binding.removeRoot();
+      for (const view of this.#store.paths.keys()) this.#store.paths.set(view, null);
+      return;
+    }
+    const parentPath = path.slice(0, -1), parent = path.length ? this.resolve(this.#store.binding.resolve(xml), parentPath) : void 0;
+    this.#store.change((editor, root) => editor.replaceElement(this.resolve(root, path), ""));
+    this.#store.binding.removed?.(parent, node);
+    if (!path.length) {
+      for (const view of this.#store.paths.keys()) this.#store.paths.set(view, null);
+    } else this.#store.shift(parentPath, path.at(-1), true);
+  }
+  serialize() {
+    const { xml, node } = this.#store.node(this);
+    const source = runElementOpen(node) + xml.sourceXml(node, /* @__PURE__ */ new Map(), true) + `</${node.name}>`;
+    const bytes = new TextEncoder().encode(source);
+    this.#store.binding.budget.check("serializedOutput", bytes.length);
+    this.#store.binding.budget.charge("retainedBytes", bytes.length);
+    return bytes;
+  }
+  resolve(root, path) {
+    let node = root;
+    for (const index of path) {
+      const child = node.children[index];
+      if (!child) throw new StaleHandleError("The XML view is detached.");
+      node = child;
+    }
+    return node;
+  }
+};
+function bindXmlElementView(binding) {
+  const store = new XmlViewStore(binding);
+  return store.view([]);
+}
+
+// packages/safe-bash-docx-engine/src/model-admission.ts
+async function admitDocumentModel(input, context) {
+  const captured = modelContext(context);
+  const { template, ...rest } = captured;
+  if (template !== void 0 && input != null)
+    throw new InputTypeError("Supply document input or a context template, not both.");
+  const settings = template === void 0 ? captured : modelContext(rest);
+  let source;
+  if (input != null && !(input instanceof Uint8Array)) {
+    const record = contextData(input);
+    if (Object.hasOwn(record, "path")) {
+      contextData(input, ["path", "capability"]);
+      const resolver = modelVfsResolver(record.path, record.capability, settings);
+      const path = record.path, filesystem = resolver.filesystem;
+      input = { path, capability: record.capability };
+      source = { path, ...filesystem ? { filesystem, input: { path, stat: { ...await filesystem.lstat(path, { signal: settings.signal }) } } } : {} };
+    }
+  }
+  const archive = input != null ? await readDocumentArchive(await acquireDocumentModelInput(input, settings), settings) : await createDocumentArchive(
+    template === void 0 ? {
+      ...settings.timestamp === void 0 ? {} : { timestamp: settings.timestamp.toISOString() },
+      author: settings.author
+    } : { template },
+    settings
+  );
+  if (source?.input && source.filesystem) {
+    const current = await source.filesystem.lstat(source.path, { signal: settings.signal });
+    if (["identityScope", "ino", "dev", "type", "revision", "size", "mode", "nlink", "mtimeMs", "ctimeMs"].some((key) => current[key] !== source.input.stat[key]))
+      throw new PublicationError("conflict", "Input changed during admission.");
+  }
+  return { archive, settings, source };
+}
+
+// packages/safe-bash-docx-engine/src/package-view.ts
+var relNamespace = "http://schemas.openxmlformats.org/package/2006/relationships";
+var relContentType = "application/vnd.openxmlformats-package.relationships+xml";
+var packageRegister = /* @__PURE__ */ Symbol("register");
+var packagePart = /* @__PURE__ */ Symbol("part");
+var packageStyleAllocationIds = /* @__PURE__ */ Symbol("style-allocation-ids");
+var packageMetadata = /* @__PURE__ */ Symbol("metadata");
+var packageRelationships = /* @__PURE__ */ Symbol("relationships");
+var packageEdges = /* @__PURE__ */ Symbol("edges");
+var packageRelationshipXml = /* @__PURE__ */ Symbol("relationshipXml");
+var packageEditRelationships = /* @__PURE__ */ Symbol("editRelationships");
+var packageNextRelationshipId = /* @__PURE__ */ Symbol("nextRelationshipId");
+var packageBindXml = /* @__PURE__ */ Symbol("bindXml");
+var packageReadXml = /* @__PURE__ */ Symbol("read-xml");
+var packageRename = /* @__PURE__ */ Symbol("rename");
+var packageValidate = /* @__PURE__ */ Symbol("validate");
+var packageAdmitPart = /* @__PURE__ */ Symbol("admit-part");
+var packageNumbering = /* @__PURE__ */ Symbol("numbering");
+var packageCreateNative = /* @__PURE__ */ Symbol("create-native");
+var packageModel = /* @__PURE__ */ Symbol("model");
+var packageBindStyles = /* @__PURE__ */ Symbol("bind-styles");
+var packageCore = /* @__PURE__ */ Symbol("core-properties");
+var coreRead = /* @__PURE__ */ Symbol("core-read");
+var coreWrite = /* @__PURE__ */ Symbol("core-write");
+var packageImage = /* @__PURE__ */ Symbol("image");
+var packageImages = /* @__PURE__ */ Symbol("images");
+var packageAdmitImages = /* @__PURE__ */ Symbol("admit-images");
+var packageBindImage = /* @__PURE__ */ Symbol("bind-image");
+var packageOwnerCheckpoint = /* @__PURE__ */ Symbol("owner-checkpoint");
+var packageLoadImage = /* @__PURE__ */ Symbol("load-image");
+var packageStoryImage = /* @__PURE__ */ Symbol("story-image");
+var partNames = /* @__PURE__ */ new WeakMap();
+var validateNativePartType = /* @__PURE__ */ Symbol("validate-native-part-type");
+var invalidateRelationshipViews = /* @__PURE__ */ Symbol("invalidate-relationship-views");
+function relationshipName(owner) {
+  if (owner === "/") return "_rels/.rels";
+  const uri = new PackURI(owner);
+  return uri.rels_uri.membername;
+}
+var PackageView = class {
+  #binding;
+  #parts = /* @__PURE__ */ new Map();
+  #relationships = /* @__PURE__ */ new Map();
+  #revision = 0;
+  #admitting;
+  #cached;
+  #imageParts;
+  #images = /* @__PURE__ */ new Map();
+  #xmlReads = /* @__PURE__ */ new WeakMap();
+  constructor(binding) {
+    this.#binding = binding;
+  }
+  static async open(input, context) {
+    const settings = modelContext(context);
+    if (input == null) throw new InputTypeError("Expected explicit package input.");
+    if (settings.template !== void 0) throw new InputTypeError("A context template conflicts with package input.");
+    const admitted = await admitDocumentModel(input, settings);
+    const { ModelStore } = await import("./model-store-JUFU3RSW.js");
+    const store = new ModelStore(admitted.archive, admitted.settings, admitted.archive.mainPart, admitted.source);
+    store.package.after_unmarshal();
+    return store.package;
+  }
+  get revision() {
+    return this.#revision;
+  }
+  [packageModel](part) {
+    this[packageMetadata](part);
+    if (!this.#binding.model) throw new UnsupportedEditError("This package does not have a live document model binding.");
+    return this.#binding.model;
+  }
+  [packageOwnerCheckpoint]() {
+    const parts = new Map(this.#parts), relationships = new Map(this.#relationships), images = new Map(this.#images), revision = this.#revision;
+    const names = new Map([...parts.values()].map((part) => [part, partNames.get(part)]));
+    return () => {
+      for (const part of this.#parts.values()) if (!names.has(part)) partNames.delete(part);
+      this.#parts.clear();
+      for (const [key, part] of parts) this.#parts.set(key, part);
+      for (const [part, name] of names) partNames.set(part, name);
+      this.#relationships.clear();
+      for (const [key, value] of relationships) this.#relationships.set(key, value);
+      this.#images.clear();
+      for (const [key, image] of images) this.#images.set(key, image);
+      this.#revision = revision;
+      this.#cached = void 0;
+    };
+  }
+  current() {
+    const settings = archiveSettings(this.#binding.context);
+    settings.budget.check("work", 0);
+    const version = `${this.#revision}:${this.#binding.version()}`;
+    if (!this.#cached || this.#cached.version !== version) {
+      const archive = this.#binding.snapshot();
+      this.#cached = { version, archive, graph: new DocumentPackage(archive, settings.limits, settings.budget) };
+    }
+    return this.#cached;
+  }
+  relationshipMember(owner) {
+    const { archive, graph } = this.current();
+    const key = asciiKey("/" + relationshipName(owner));
+    archiveSettings(this.#binding.context).budget.charge("work", graph.parts.length + archive.members.length);
+    const part = graph.parts.find((part2) => asciiKey(part2.partname) === key);
+    return part && archive.members.find((member) => member.name === part.name);
+  }
+  [packageRegister](part, name) {
+    name = normalizePartName(name);
+    if (this.#parts.has(asciiKey(name))) throw new InvalidValueError("The part already has an owner view.");
+    const metadata = this.#admitting && asciiKey(this.#admitting.partname) === asciiKey(name) ? this.#admitting : this.current().graph.getPart(name);
+    if (part instanceof XmlPartView) XmlPartView[validateNativePartType](part, metadata.content_type);
+    partNames.set(part, name);
+    this.#parts.set(asciiKey(name), part);
+  }
+  [packagePart](name, metadata = this.current().graph.getPart(name)) {
+    const key = asciiKey(metadata.partname);
+    let part = this.#parts.get(key);
+    if (!part) {
+      const type = parseMediaType(metadata.content_type);
+      part = type.startsWith("image/") ? new ImagePartView(this, metadata.partname) : type === "application/vnd.openxmlformats-package.core-properties+xml" ? new CorePropertiesPartView(this, metadata.partname) : Object.values(documentTypes).includes(type) ? new DocumentPartView(this, metadata.partname) : type === "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml" ? new NumberingPart(this, metadata.partname) : type === "application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml" ? new HeaderPart(this, metadata.partname) : type === "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml" ? new FooterPart(this, metadata.partname) : type === "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml" ? new CommentsPart(this, metadata.partname) : type === "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml" ? new SettingsPart(this, metadata.partname) : type === "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml" ? new StylesPart(this, metadata.partname) : isXmlContentType(type) ? new XmlPartView(this, metadata.partname) : new PartView(this, metadata.partname);
+    }
+    return part;
+  }
+  [packageMetadata](part) {
+    if (part.package !== this) throw new OwnershipError("Expected a part owned by this package.");
+    if (!partNames.has(part)) throw new StaleHandleError("The part owner is detached.");
+    const metadata = this.current().graph.getPart(partNames.get(part));
+    const budget = archiveSettings(this.#binding.context).budget;
+    budget.charge("retainedBytes", metadata.bytes.length);
+    budget.charge("work", metadata.bytes.length);
+    return { ...metadata, bytes: new Uint8Array(metadata.bytes), modified: new Date(metadata.modified.getTime()) };
+  }
+  [packageStyleAllocationIds]() {
+    const budget = archiveSettings(this.#binding.context).budget;
+    return styleAllocationIds(this.current().graph.parts, budget);
+  }
+  get parts() {
+    return snapshotSequence([...this.iter_parts()]);
+  }
+  *iter_parts() {
+    for (const part of this.current().graph.iterParts()) yield this[packagePart](part.partname);
+  }
+  *iter_rels() {
+    const visited = /* @__PURE__ */ new Set(), stack = ["/"];
+    while (stack.length) {
+      const owner = stack.pop();
+      if (visited.has(asciiKey(owner))) continue;
+      visited.add(asciiKey(owner));
+      const edges = [...this[packageRelationships](owner).values()];
+      for (const edge of edges) yield edge;
+      for (const edge of edges.slice().reverse()) if (!edge.is_external) stack.push(edge.target_part.partname.toString());
+    }
+  }
+  get rels() {
+    return this[packageRelationships]("/");
+  }
+  get image_parts() {
+    return this.#imageParts ??= new ImageParts(this);
+  }
+  [packageImages]() {
+    return this.current().graph.parts.filter((part) => asciiKey(part.content_type).startsWith("image/")).map((part) => this[packagePart](part.partname));
+  }
+  [packageImage](part) {
+    const image = this.#images.get(this[packageMetadata](part).partname);
+    if (!image) throw new UnsupportedEditError("This image part has no admitted bounded raster characterization.");
+    return image;
+  }
+  [packageBindImage](part, image) {
+    if (!(part instanceof ImagePartView) || !(image instanceof Image)) throw new InputTypeError("Expected an owned image part and characterized image.");
+    const metadata = this[packageMetadata](part), bytes = image.blob;
+    if (parseMediaType(metadata.content_type) !== image.content_type || metadata.bytes.length !== bytes.length || !metadata.bytes.every((byte, i) => byte === bytes[i]))
+      throw new InvalidValueError("Image characterization conflicts with the owned part bytes.");
+    this.#images.set(metadata.partname, image);
+  }
+  async [packageAdmitImages]() {
+    for (const part of this[packageImages]()) {
+      const type = parseMediaType(part.content_type);
+      if (!["image/png", "image/jpeg", "image/gif", "image/bmp", "image/tiff"].includes(type)) continue;
+      try {
+        const image = await Image.from_blob(part.blob, this.#binding.context);
+        if (image.content_type === type) this.#images.set(part.partname.toString(), image);
+      } catch (error) {
+        if (!(error instanceof UnsupportedEditError)) throw error;
+      }
+    }
+  }
+  async [packageLoadImage](name, contentType, bytes) {
+    this.#binding.writable();
+    const revision = this.#revision, ownerVersion = this.#binding.version();
+    const image = bytes instanceof Image ? await Image[copyImageForOwner](bytes, this.#binding.context) : await Image.from_blob(bytes, this.#binding.context);
+    if (revision !== this.#revision || ownerVersion !== this.#binding.version()) throw new PublicationError("conflict", "Package changed during image admission.");
+    if (typeof contentType !== "string" || image.content_type !== parseMediaType(contentType)) throw new InvalidValueError("Image part content type conflicts with its byte signature.");
+    const part = this[packageAdmitPart](name, contentType, image.blob);
+    this.#images.set(part.partname.toString(), image);
+    return part;
+  }
+  async get_or_add_image_part(input) {
+    this.#binding.writable();
+    const revision = this.#revision, ownerVersion = this.#binding.version();
+    const image = await Image.from_file(input, this.#binding.context);
+    if (revision !== this.#revision || ownerVersion !== this.#binding.version()) throw new PublicationError("conflict", "Package changed during image admission.");
+    const bytes = image.blob;
+    for (const part2 of this[packageImages]()) {
+      const candidate = part2.blob;
+      if (candidate.length === bytes.length && candidate.every((value, index) => value === bytes[index])) return part2;
+    }
+    const name = this.next_partname(`/word/media/image%d.${image.ext}`);
+    const part = this[packageAdmitPart](name, image.content_type, bytes);
+    this.#images.set(part.partname.toString(), image);
+    return part;
+  }
+  async [packageStoryImage](owner, input, prepare) {
+    this.#binding.writable();
+    const metadata = this[packageMetadata](owner);
+    const { budget } = archiveSettings(this.#binding.context);
+    const namespace = parseDocumentXml(metadata.bytes, {}, budget).root.namespace;
+    const dialect = Object.values(documentDialects).find((dialect2) => dialect2.w === namespace);
+    if (!dialect) throw new InputTypeError("Expected an admitted native story owner.");
+    const revision = this.#revision, ownerVersion = this.#binding.version();
+    const image = await Image.from_file(input, this.#binding.context);
+    if (revision !== this.#revision || ownerVersion !== this.#binding.version())
+      throw new PublicationError("conflict", "Package changed during story image admission.");
+    const restore = this[packageOwnerCheckpoint]();
+    try {
+      const bytes = image.blob, reltype = `${dialect.r}/image`, { graph } = this.current();
+      for (const candidate of this[packageImages]()) {
+        const existing = candidate.blob;
+        if (existing.length !== bytes.length || !existing.every((value, index) => value === bytes[index])) continue;
+        const retained = candidate.image;
+        const edge = graph.relationships(metadata.partname).find((edge2) => !edge2.is_external && edge2.reltype === reltype && asciiKey(edge2.target_part.partname) === asciiKey(candidate.partname.toString()));
+        const id2 = edge?.rId ?? graph.allocateRelationshipId(metadata.partname);
+        const fragment2 = prepare?.(id2, retained);
+        if (!edge) owner.load_rel(reltype, candidate, id2);
+        return Object.freeze([id2, retained, fragment2]);
+      }
+      const name = graph.allocatePartName(metadata.partname.slice(0, metadata.partname.lastIndexOf("/") + 1) + "media/image", `.${image.ext}`);
+      const id = graph.allocateRelationshipId(metadata.partname);
+      const fragment = prepare?.(id, image);
+      this[packageAdmitPart](name, image.content_type, bytes, { owner, reltype, rId: id });
+      this.#images.set(name, image);
+      return Object.freeze([id, image, fragment]);
+    } catch (error) {
+      restore();
+      throw error;
+    }
+  }
+  get core_properties() {
+    const edges = [...this.rels.values()].filter((edge) => edge.reltype === "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties");
+    if (edges.length > 1 || edges[0]?.is_external) throw new InvalidValueError("Expected one owned core-properties part.");
+    let part;
+    if (edges.length) part = edges[0].target_part;
+    else {
+      this.#binding.writable();
+      const { archive, graph } = this.current();
+      const root = this.main_document_part.element.tag;
+      const dialect = root.namespaceURI === documentDialects.strict.w ? "strict" : "transitional";
+      const created = createPropertyPart({ ...archive, package: graph, dialect }, "core", archiveSettings(this.#binding.context).budget);
+      const context = this.#binding.context;
+      const timestamp = context.timestamp;
+      if (!(timestamp instanceof Date) || !Number.isFinite(Date.prototype.getTime.call(timestamp))) throw new InputTypeError("Expected admitted core-property metadata.");
+      const modified = new Date(Math.floor(Date.prototype.getTime.call(timestamp) / 1e3) * 1e3).toISOString();
+      const metadata = new TextEncoder().encode(`<cp:coreProperties xmlns:cp="${corePropertyNamespace}" 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:title>Document</dc:title><cp:lastModifiedBy>${xmlValue(context.author ?? "")}</cp:lastModifiedBy><cp:revision>1</cp:revision><dcterms:modified xsi:type="dcterms:W3CDTF">${modified}</dcterms:modified></cp:coreProperties>`);
+      created.archive = { ...created.archive, members: created.archive.members.map((member) => member.name === created.name.slice(1) ? { ...member, bytes: metadata } : member) };
+      this.commit(created.archive);
+      part = this[packagePart](created.name);
+    }
+    if (!(part instanceof CorePropertiesPartView)) throw new InvalidValueError("Core-properties relationship has an incompatible target.");
+    return part.core_properties;
+  }
+  [packageCore](part) {
+    return new CoreProperties(part, archiveSettings(this.#binding.context).budget);
+  }
+  [packageAdmitPart](name, content_type, input, relationship) {
+    this.#binding.writable();
+    if (!(input instanceof Uint8Array) || typeof content_type !== "string" || !content_type) throw new InputTypeError("Expected owned part bytes and a content type.");
+    name = normalizePartName(name instanceof PackURI ? name.toString() : name);
+    const { archive, graph } = this.current(), settings = archiveSettings(this.#binding.context);
+    if (graph.parts.some((part) => asciiKey(part.partname) === asciiKey(name))) throw new InvalidValueError("The part name is already occupied.");
+    if (input.length > settings.limits.maxEntryBytes) throw new ResourceLimitError("Part bytes exceed the admitted ceiling.");
+    settings.budget.charge("retainedBytes", input.length);
+    settings.budget.charge("work", input.length);
+    const bytes = new Uint8Array(input), types = archive.members.find((member) => asciiKey(member.name) === "[content_types].xml");
+    if (isXmlContentType(content_type)) new DocumentXmlEditor(bytes, {}, void 0, settings.budget);
+    const xml = new DocumentXmlEditor(types.bytes, {}, void 0, settings.budget);
+    let overrides = `<Override xmlns="http://schemas.openxmlformats.org/package/2006/content-types" PartName="${xmlValue(name)}" ContentType="${xmlValue(content_type)}"/>`;
+    const members = [...archive.members];
+    if (relationship) {
+      const owner = this[packageMetadata](relationship.owner).partname;
+      const relName = relationshipName(owner);
+      const existing = this.relationshipMember(owner);
+      if (!existing) {
+        settings.budget.charge("insertedNodes", 1);
+        overrides += `<Override xmlns="http://schemas.openxmlformats.org/package/2006/content-types" PartName="/${xmlValue(relName)}" ContentType="${relContentType}"/>`;
+      }
+      const relXml = new DocumentXmlEditor(existing?.bytes ?? new TextEncoder().encode(`<Relationships xmlns="${relNamespace}"/>`), {}, void 0, settings.budget);
+      relXml.insertChildren(relXml.root, `<Relationship xmlns="${relNamespace}" Id="${relationship.rId ?? graph.allocateRelationshipId(owner)}" Type="${xmlValue(relationship.reltype)}" Target="${xmlValue(relativePartTarget(owner, name))}"/>`);
+      const member = { name: relName, bytes: relXml.serialize(), directory: false, modified: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z") };
+      if (existing) members[members.indexOf(existing)] = { ...existing, bytes: member.bytes };
+      else members.push(member);
+    }
+    xml.insertChildren(xml.root, overrides);
+    members[members.indexOf(types)] = { ...types, bytes: xml.serialize() };
+    members.push({ name: name.slice(1), bytes, directory: false, modified: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z") });
+    const restore = this[packageOwnerCheckpoint]();
+    try {
+      this.#admitting = { partname: name, content_type };
+      let part;
+      try {
+        part = this[packagePart](name, this.#admitting);
+      } finally {
+        this.#admitting = void 0;
+      }
+      this.commit({ ...archive, members });
+      return part;
+    } catch (error) {
+      restore();
+      throw error;
+    }
+  }
+  [packageCreateNative](kind, relationship) {
+    this.#binding.writable();
+    const restore = this[packageOwnerCheckpoint]();
+    try {
+      const owner = relationship?.owner ?? this.main_document_part, root = owner.element.tag;
+      const { graph } = this.current(), { budget } = archiveSettings(this.#binding.context);
+      const tag = { header: "hdr", footer: "ftr", comments: "comments", settings: "settings", styles: "styles" }[kind];
+      const content = kind === "header" || kind === "footer" ? "<w:p/>" : kind === "styles" ? originalModelDefaults(root.namespaceURI) : "";
+      const base = owner.partname.toString();
+      const name = graph.allocatePartName(base.slice(0, base.lastIndexOf("/") + 1) + kind, ".xml");
+      const bytes = new TextEncoder().encode(`<w:${tag} xmlns:w="${root.namespaceURI}">${content}</w:${tag}>`);
+      const parsed = parseDocumentXml(bytes, {}, budget);
+      let nodes = 0;
+      const pending = [parsed.root];
+      while (pending.length) {
+        const node = pending.pop();
+        nodes++;
+        pending.push(...node.children);
+      }
+      budget.charge("insertedNodes", nodes);
+      const dialect = Object.values(documentDialects).find((dialect2) => dialect2.w === root.namespaceURI);
+      return this[packageAdmitPart](
+        name,
+        `application/vnd.openxmlformats-officedocument.wordprocessingml.${kind}+xml`,
+        bytes,
+        relationship ? { owner, rId: relationship.rId, reltype: `${dialect.r}/${kind}` } : void 0
+      );
+    } catch (error) {
+      restore();
+      throw error;
+    }
+  }
+  [packageNumbering](owner) {
+    const metadata = this[packageMetadata](owner), { graph } = this.current();
+    const { budget } = archiveSettings(this.#binding.context);
+    const root = parseDocumentXml(metadata.bytes, {}, budget).root;
+    const dialect = Object.values(documentDialects).find((dialect2) => dialect2.w === root.namespace);
+    if (!dialect || root.localName !== "document") throw new InvalidValueError("Expected a document numbering owner.");
+    const reltype = `${dialect.r}/numbering`;
+    const edges = graph.relationships(metadata.partname).filter((edge) => edge.reltype === reltype);
+    if (edges.length > 1 || edges[0]?.is_external) throw new InvalidValueError("Expected one internal numbering relationship.");
+    if (edges[0]) {
+      const part = this[packagePart](edges[0].target_part.partname);
+      if (!(part instanceof NumberingPart) || part.element.localName !== "numbering" || part.element.namespace !== dialect.w)
+        throw new InvalidValueError("Numbering ownership has an incompatible target.");
+      return part;
+    }
+    this.#binding.writable();
+    const name = graph.allocatePartName(metadata.partname.slice(0, metadata.partname.lastIndexOf("/") + 1) + "numbering", ".xml");
+    budget.charge("insertedNodes", 1);
+    return this[packageAdmitPart](
+      name,
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml",
+      new TextEncoder().encode(`<w:numbering xmlns:w="${dialect.w}"/>`),
+      { owner, reltype }
+    );
+  }
+  get main_document_part() {
+    const edges = [...this.rels.values()].filter((edge) => Object.values(documentDialects).some((dialect) => edge.reltype === `${dialect.r}/officeDocument`) && !edge.is_external);
+    if (edges.length !== 1 || !(edges[0].target_part instanceof DocumentPartView)) throw new InvalidValueError("Expected one XML document part.");
+    return edges[0].target_part;
+  }
+  [packageRelationships](owner) {
+    const key = owner === "/" ? "/" : asciiKey(this.current().graph.getPart(owner).partname);
+    let rels = this.#relationships.get(key);
+    if (!rels) {
+      rels = new Relationships(this, owner === "/" ? null : this[packagePart](owner));
+      this.#relationships.set(key, rels);
+    }
+    return rels;
+  }
+  [packageEdges](owner) {
+    return this.current().graph.relationships(owner ? this[packageMetadata](owner).partname : "/");
+  }
+  [packageRelationshipXml](owner) {
+    const bytes = this.relationshipMember(owner ? this[packageMetadata](owner).partname : "/")?.bytes ?? new TextEncoder().encode(`<Relationships xmlns="${relNamespace}"/>`);
+    const budget = archiveSettings(this.#binding.context).budget;
+    budget.charge("work", bytes.length);
+    budget.charge("retainedBytes", bytes.length);
+    const document = parseDocumentXml(bytes, {}, budget);
+    return new TextDecoder(document.encoding, { fatal: true }).decode(bytes);
+  }
+  [packageNextRelationshipId](owner) {
+    const member = this.relationshipMember(owner ? this[packageMetadata](owner).partname : "/");
+    const { budget } = archiveSettings(this.#binding.context);
+    const ids = member ? relationshipXmlIds(parseDocumentXml(member.bytes, {}, budget).root, budget) : /* @__PURE__ */ new Set();
+    let ordinal = 1;
+    while (ids.has(`rId${ordinal}`)) {
+      budget.charge("work", 1);
+      ordinal++;
+    }
+    return `rId${ordinal}`;
+  }
+  [packageEditRelationships](owner, rows, removeUnsharedPart) {
+    this.#binding.writable();
+    const { archive } = this.current(), settings = archiveSettings(this.#binding.context);
+    const name = relationshipName(owner ? this[packageMetadata](owner).partname : "/");
+    const existing = this.relationshipMember(owner ? this[packageMetadata](owner).partname : "/");
+    let bytes = existing?.bytes ?? new TextEncoder().encode(`<Relationships xmlns="${relNamespace}"/>`);
+    const previous = this[packageEdges](owner);
+    const pending = new Map(rows.map((row) => [row.rId, row]));
+    if (pending.size !== rows.length) throw new InvalidValueError("Duplicate relationship IDs.");
+    const removed = new Set(previous.filter((row) => !pending.has(row.rId)).map((row) => row.rId));
+    if (owner && removed.size) {
+      const metadata = this[packageMetadata](owner);
+      if (isXmlContentType(metadata.content_type)) {
+        const stack = [parseDocumentXml(metadata.bytes, {}, settings.budget).root];
+        while (stack.length) {
+          const node = stack.pop();
+          settings.budget.charge("work", 1 + node.attributes.length + node.children.length);
+          for (const attribute of node.attributes) {
+            const reference = attribute.namespace === documentDialects.transitional.r || attribute.namespace === documentDialects.strict.r || attribute.namespace === "urn:schemas-microsoft-com:office:office" && attribute.localName === "relid";
+            if (reference && removed.has(attribute.value))
+              throw new UnsupportedEditError("An XML reference still requires the relationship.");
+          }
+          settings.budget.charge("retainedBytes", node.children.length * 8);
+          for (const child of node.children) stack.push(child);
+        }
+      }
+    }
+    for (const row of previous) {
+      const replacement = pending.get(row.rId);
+      const changes = {};
+      if (replacement) {
+        if (replacement.reltype !== row.reltype) changes.Type = replacement.reltype;
+        if (replacement.target_ref !== row.target_ref) changes.Target = replacement.target_ref;
+        if (replacement.is_external !== row.is_external) changes.TargetMode = replacement.is_external ? "External" : null;
+      }
+      if (!replacement || Object.keys(changes).length) {
+        const xml = new DocumentXmlEditor(bytes, {}, void 0, settings.budget);
+        const node = relationshipXmlRows(xml.root, settings.budget).find((node2) => node2.rId === row.rId).element;
+        xml[editActiveRelationshipXml](node, replacement ? changes : null);
+        bytes = xml.serialize();
+      }
+      pending.delete(row.rId);
+    }
+    for (const row of pending.values()) {
+      const xml = new DocumentXmlEditor(bytes, {}, void 0, settings.budget);
+      xml.insertChildren(xml.root, `<Relationship xmlns="${relNamespace}" Id="${xmlValue(row.rId)}" Type="${xmlValue(row.reltype)}" Target="${xmlValue(row.target_ref)}"${row.is_external ? ' TargetMode="External"' : ""}/>`);
+      bytes = xml.serialize();
+    }
+    let members = archive.members.map((member) => member === existing ? { ...member, bytes } : member);
+    if (!existing) members.push({ name, bytes, directory: false, modified: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z") });
+    const deleted = /* @__PURE__ */ new Set();
+    if (removeUnsharedPart) {
+      const metadata = this[packageMetadata](removeUnsharedPart), graph = this.current().graph;
+      const excluded = [...removed].map((id) => ({ owner: owner ? this[packageMetadata](owner).partname : "/", id }));
+      if (!retainedRelationshipTargets(graph, settings.budget, excluded).has(asciiKey(metadata.partname))) {
+        deleted.add(asciiKey(metadata.partname));
+        const deletedNames = /* @__PURE__ */ new Set([metadata.name]);
+        const outgoing = this.relationshipMember(metadata.partname);
+        if (outgoing) {
+          deleted.add(asciiKey(normalizePartName("/" + outgoing.name)));
+          deletedNames.add(outgoing.name);
+        }
+        const types = members.find((member) => asciiKey(member.name) === "[content_types].xml");
+        const xml = new DocumentXmlEditor(types.bytes, {}, void 0, settings.budget);
+        for (const node of [...xml.root.children]) {
+          const partname = node.attributes.find((attribute) => !attribute.namespace && attribute.localName === "PartName")?.value;
+          if (partname && deleted.has(asciiKey(normalizePartName(partname)))) xml.replaceElement(node, "");
+        }
+        members = members.filter((member) => !deletedNames.has(member.name)).map((member) => member === types ? { ...member, bytes: xml.serialize() } : member);
+      }
+    }
+    this.commit({ ...archive, members });
+    this.#relationships.get(owner ? asciiKey(owner.partname.toString()) : "/")?.[invalidateRelationshipViews](removed);
+    for (const key of deleted) {
+      const part = this.#parts.get(key);
+      if (part) partNames.delete(part);
+      this.#parts.delete(key);
+      this.#relationships.delete(key);
+    }
+  }
+  [packageBindXml](part) {
+    return bindXmlElementView({
+      budget: archiveSettings(this.#binding.context).budget,
+      read: () => {
+        const metadata = this[packageMetadata](part);
+        return new DocumentXmlEditor(metadata.bytes, {}, compatibilityProfileForPart(metadata.partname), archiveSettings(this.#binding.context).budget);
+      },
+      resolve: (xml) => xml.root,
+      change: (action) => {
+        this.#binding.writable();
+        const metadata = this[packageMetadata](part), { archive, graph } = this.current();
+        const { budget, limits } = archiveSettings(this.#binding.context);
+        const xml = new DocumentXmlEditor(metadata.bytes, {}, compatibilityProfileForPart(metadata.partname), budget);
+        action(xml);
+        const bytes = xml.serialize();
+        assertLiveCommentExtensionPartPreserved(graph, metadata, bytes, budget);
+        const candidate = { ...archive, members: archive.members.map((member) => member.name === metadata.name ? { ...member, bytes } : member) };
+        if (parseMediaType(metadata.content_type) === "application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml" && embeddedFontState(graph, budget) !== embeddedFontState(new DocumentPackage(candidate, limits, budget), budget))
+          throw new UnsupportedEmbeddedFontMutationError();
+        this.commit(candidate);
+      }
+    });
+  }
+  [packageReadXml](part) {
+    if (part.package !== this) throw new OwnershipError("Expected a part owned by this package.");
+    const name = partNames.get(part);
+    if (!name) throw new StaleHandleError("The part owner is detached.");
+    const metadata = this.current().graph.getPart(name), budget = archiveSettings(this.#binding.context).budget;
+    let xml = this.#xmlReads.get(metadata);
+    if (!xml) {
+      xml = new DocumentXmlEditor(metadata.bytes, {}, void 0, budget);
+      this.#xmlReads.set(metadata, xml);
+    }
+    return { xml, budget };
+  }
+  commit(archive, rename) {
+    const { budget, limits } = archiveSettings(this.#binding.context);
+    if (archive.members.length > limits.maxMembers) throw new ResourceLimitError("Package member count exceeds the admitted ceiling.");
+    let total = 0;
+    for (const member of archive.members) {
+      if (member.bytes.length > limits.maxEntryBytes) throw new ResourceLimitError("Part bytes exceed the admitted ceiling.");
+      if (member.name.length + 1 > limits.maxPathBytes || new TextEncoder().encode(member.name).length > limits.maxPathBytes || member.name.split("/").filter(Boolean).length > limits.maxDepth) throw new ResourceLimitError("Part path exceeds the admitted ceiling.");
+      total += member.bytes.length;
+      if (total > limits.maxTotalBytes) throw new ResourceLimitError("Package bytes exceed the admitted ceiling.");
+    }
+    new DocumentPackage(archive, limits, budget);
+    const report = validateDocumentArchive(archive, {}, budget);
+    if (!report.valid) throw new SemanticValidationError(report.diagnostics);
+    this.#binding.stage(archive, rename);
+    this.#revision++;
+    this.#cached = void 0;
+  }
+  [packageRename](part, name) {
+    this.#binding.writable();
+    const metadata = this[packageMetadata](part), from = metadata.partname, to = normalizePartName(name instanceof PackURI ? name.toString() : name);
+    if (from === to) return;
+    const { archive, graph } = this.current(), settings = archiveSettings(this.#binding.context);
+    if (graph.parts.some((existing) => asciiKey(existing.partname) === asciiKey(to))) throw new InvalidValueError("The part name is already occupied.");
+    const replacements = /* @__PURE__ */ new Map();
+    const ownedRelationships = this.relationshipMember(from);
+    const renamedParts = /* @__PURE__ */ new Map([[asciiKey(from), to]]);
+    if (ownedRelationships) renamedParts.set(asciiKey(normalizePartName("/" + ownedRelationships.name)), "/" + relationshipName(to));
+    const types = archive.members.find((member) => asciiKey(member.name) === "[content_types].xml");
+    const typeEditor = new DocumentXmlEditor(types.bytes, {}, void 0, settings.budget);
+    let override = false;
+    for (const node of typeEditor.root.children) {
+      const value = node.attributes.find((attribute) => attribute.localName === "PartName")?.value;
+      if (value === void 0) continue;
+      const destination = renamedParts.get(asciiKey(normalizePartName(value)));
+      if (destination) {
+        typeEditor.setAttribute(node, "PartName", destination);
+        if (destination === to) override = true;
+      }
+    }
+    if (!override) typeEditor.insertChildren(typeEditor.root, `<Override xmlns="http://schemas.openxmlformats.org/package/2006/content-types" PartName="${xmlValue(to)}" ContentType="${xmlValue(metadata.content_type)}"/>`);
+    replacements.set(types.name, typeEditor.serialize());
+    for (const owner of ["/", ...graph.parts.filter((part2) => asciiKey(part2.content_type) !== relContentType).map((part2) => part2.partname)]) {
+      const edges = graph.relationships(owner), member = this.relationshipMember(owner);
+      if (!member || !edges.some((edge) => !edge.is_external && (owner === from || edge.target_part.partname === from))) continue;
+      const xml = new DocumentXmlEditor(member.bytes, {}, void 0, settings.budget);
+      for (const { element: node, rId } of relationshipXmlRows(xml.root, settings.budget)) {
+        const edge = edges.find((edge2) => edge2.rId === rId);
+        if (!edge || edge.is_external || owner !== from && edge.target_part.partname !== from) continue;
+        const target = relativePartTarget(owner === from ? to : owner, edge.target_part.partname === from ? to : edge.target_part.partname) + (edge.fragment === null ? "" : "#" + edge.fragment);
+        xml[editActiveRelationshipXml](node, { Target: target });
+      }
+      replacements.set(member.name, xml.serialize());
+    }
+    const members = archive.members.map((member) => ({
+      ...member,
+      name: member.name === metadata.name ? to.slice(1) : member === ownedRelationships ? relationshipName(to) : member.name,
+      bytes: replacements.get(member.name) ?? member.bytes
+    }));
+    this.commit({ ...archive, members }, { from, to });
+    this.#parts.delete(asciiKey(from));
+    this.#parts.set(asciiKey(to), part);
+    partNames.set(part, to);
+    const image = this.#images.get(from);
+    if (image) {
+      this.#images.delete(from);
+      this.#images.set(to, image);
+    }
+    const rels = this.#relationships.get(asciiKey(from));
+    if (rels) {
+      this.#relationships.delete(asciiKey(from));
+      this.#relationships.set(asciiKey(to), rels);
+    }
+  }
+  part_related_by(reltype) {
+    return this.rels.part_with_reltype(reltype);
+  }
+  relate_to(part, reltype) {
+    return this.rels.get_or_add(reltype, part).rId;
+  }
+  load_rel(reltype, target, rId, is_external = false) {
+    this.rels.add_relationship(reltype, target, rId, is_external);
+  }
+  next_partname(template) {
+    if (typeof template !== "string" || template.split("%d").length !== 2) throw new InputTypeError("Expected one numbered part-name placeholder.");
+    const [prefix, suffix] = template.split("%d");
+    return new PackURI(this.current().graph.allocatePartName(prefix, suffix));
+  }
+  after_unmarshal() {
+    this[packageValidate]();
+    this.#cached = void 0;
+    void this.current();
+  }
+  [packageValidate]() {
+    const report = validateDocumentArchive(this.#binding.snapshot(), {}, archiveSettings(this.#binding.context).budget);
+    if (!report.valid) throw new SemanticValidationError(report.diagnostics);
+  }
+  async save(output, options) {
+    this.#binding.writable();
+    this[packageValidate]();
+    await this.#binding.save(output, options);
+  }
+};
+var PartView = class {
+  #package;
+  constructor(owner, name) {
+    this.#package = owner;
+    owner[packageRegister](this, name);
+  }
+  static async load(partname, content_type, blob, owner) {
+    if (!(owner instanceof PackageView)) throw new InputTypeError("Expected an admitted owner package.");
+    return owner[packageAdmitPart](partname, content_type, blob);
+  }
+  get package() {
+    return this.#package;
+  }
+  get partname() {
+    const name = partNames.get(this);
+    if (!name) throw new StaleHandleError("The part owner is detached.");
+    return new PackURI(name);
+  }
+  set partname(value) {
+    this.#package[packageRename](this, value);
+  }
+  get content_type() {
+    return this.#package[packageMetadata](this).content_type;
+  }
+  get blob() {
+    const bytes = this.#package[packageMetadata](this).bytes;
+    return new Uint8Array(bytes);
+  }
+  get rels() {
+    return this.#package[packageRelationships](this.partname.toString());
+  }
+  get related_parts() {
+    return this.rels.related_parts;
+  }
+  part_related_by(reltype) {
+    return this.rels.part_with_reltype(reltype);
+  }
+  relate_to(target, reltype, is_external = false) {
+    return is_external ? this.rels.get_or_add_ext_rel(reltype, target) : this.rels.get_or_add(reltype, target).rId;
+  }
+  load_rel(reltype, target, rId, is_external = false) {
+    this.rels.add_relationship(reltype, target, rId, is_external);
+  }
+  drop_rel(rId) {
+    this.rels.delete(rId);
+  }
+  target_ref(rId) {
+    return this.rels.at(rId).target_ref;
+  }
+  before_marshal() {
+    this.#package[packageValidate]();
+  }
+  after_unmarshal() {
+    this.#package[packageMetadata](this);
+    this.#package[packageValidate]();
+  }
+};
+var XmlPartView = class extends PartView {
+  static nativeTypes = void 0;
+  static [validateNativePartType](part, contentType) {
+    const type = parseMediaType(contentType);
+    for (const owner of [StoryPart, HeaderPart, FooterPart, CommentsPart, SettingsPart, StylesPart, DocumentPartView, NumberingPart, CorePropertiesPartView]) {
+      if (part instanceof owner && owner.nativeTypes && !owner.nativeTypes.includes(type))
+        throw new InputTypeError("The native part view does not match the admitted content type.");
+    }
+  }
+  #element;
+  static async load(partname, content_type, blob, owner) {
+    if (!(owner instanceof PackageView) || !isXmlContentType(content_type)) throw new InputTypeError("Expected an admitted XML owner package and content type.");
+    if (this.nativeTypes && !this.nativeTypes.includes(parseMediaType(content_type)))
+      throw new InputTypeError("The content type does not match the native part role.");
+    return owner[packageAdmitPart](partname, content_type, blob);
+  }
+  get element() {
+    return this.#element ??= this.package[packageBindXml](this);
+  }
+  get part() {
+    this.package[packageMetadata](this);
+    return this;
+  }
+};
+var StoryPart = class extends XmlPartView {
+  static async load(partname, content_type, blob, owner) {
+    if (!(owner instanceof PackageView) || typeof content_type !== "string" || !this.nativeTypes.includes(parseMediaType(content_type)))
+      throw new InputTypeError("Expected an admitted owner and a native story content type.");
+    return owner[packageAdmitPart](partname, content_type, blob);
+  }
+  get next_id() {
+    const { xml, budget } = this.package[packageReadXml](this);
+    let maximum = 0;
+    budget.charge("retainedBytes", 8);
+    const pending = [xml.root];
+    while (pending.length) {
+      const node = pending.pop();
+      budget.charge("work", 1 + node.attributes.length + node.children.length);
+      for (const attribute of node.attributes) {
+        if (attribute.namespace || attribute.localName !== "id" || !attribute.value.length) continue;
+        budget.charge("work", attribute.value.length * 2);
+        let decimal = true;
+        for (const char of attribute.value) if (char < "0" || char > "9") {
+          decimal = false;
+          break;
+        }
+        if (!decimal) continue;
+        const value = Number(attribute.value);
+        if (!Number.isSafeInteger(value) || value >= Number.MAX_SAFE_INTEGER)
+          throw new ResourceLimitError("The story identifier range is exhausted.");
+        maximum = Math.max(maximum, value);
+      }
+      if (node.children.length) budget.charge("retainedBytes", node.children.length * 8);
+      for (const child of node.children) pending.push(child);
+    }
+    return maximum + 1;
+  }
+  get_style(style_id, style_type) {
+    return this.package[packageModel](this).withStyleDefinitions((styles) => {
+      const style = styles.get_by_id(style_id, style_type);
+      if (!style) throw new MissingKeyError("The requested style type has no default definition.");
+      return style;
+    }, this.partname.toString());
+  }
+  get_style_id(style_or_name, style_type) {
+    return this.package[packageModel](this).withStyleDefinitions((styles) => styles.get_style_id(style_or_name, style_type), this.partname.toString());
+  }
+  async get_or_add_image(input) {
+    this.package[packageMetadata](this);
+    const [id, image] = await this.package[packageStoryImage](this, input);
+    return snapshotSequence([id, image]);
+  }
+  async new_pic_inline(input, width, height) {
+    const { budget, xml: ownerXml } = this.package[packageReadXml](this);
+    const dialect = Object.values(documentDialects).find((dialect2) => dialect2.w === ownerXml.root.namespace);
+    if (!dialect) throw new InputTypeError("Expected an admitted native story owner.");
+    const result = await this.package[packageStoryImage](this, input, (id, image) => {
+      const [cx, cy] = image.scaled_dimensions(width, height), drawingId = this.next_id;
+      if (drawingId > 4294967295) throw new ResourceLimitError("The drawing identifier range is exhausted.");
+      const markup2 = inlineImageRun(dialect, drawingId, id, { width: cx.emu, height: cy.emu, crop: "" }, { filename: image.filename }).run;
+      budget.charge("retainedBytes", markup2.length * 3);
+      let xml = new DocumentXmlEditor(new TextEncoder().encode(markup2), {}, void 0, budget);
+      const resolve = (document) => {
+        const drawing = document.root.children.find((node) => node.namespace === dialect.w && node.localName === "drawing");
+        const inline = drawing?.children.find((node) => node.namespace === dialect.wp && node.localName === "inline");
+        if (!inline) throw new StaleHandleError("The detached picture fragment is no longer available.");
+        return inline;
+      };
+      return bindXmlElementView({
+        budget,
+        read: () => {
+          this.package[packageMetadata](this);
+          return xml;
+        },
+        resolve,
+        change: (action) => {
+          this.package[packageMetadata](this);
+          const candidate = new DocumentXmlEditor(xml.serialize(), {}, void 0, budget);
+          action(candidate);
+          xml = new DocumentXmlEditor(candidate.serialize(), {}, void 0, budget);
+        }
+      });
+    });
+    return result[2];
+  }
+  static nativeTypes = [
+    ...Object.values(documentTypes),
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"
+  ];
+};
+var HeaderPart = class extends StoryPart {
+  static new(owner) {
+    if (!(owner instanceof PackageView)) throw new InputTypeError("Expected an admitted owner package.");
+    return owner[packageCreateNative]("header");
+  }
+  static nativeTypes = ["application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml"];
+};
+var FooterPart = class extends StoryPart {
+  static new(owner) {
+    if (!(owner instanceof PackageView)) throw new InputTypeError("Expected an admitted owner package.");
+    return owner[packageCreateNative]("footer");
+  }
+  static nativeTypes = ["application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml"];
+};
+var CommentsPart = class extends StoryPart {
+  static async load(partname, content_type, blob, owner) {
+    if (!(owner instanceof PackageView) || typeof content_type !== "string" || !this.nativeTypes.includes(parseMediaType(content_type)))
+      throw new InputTypeError("Expected an admitted owner and the native part content type.");
+    return owner[packageAdmitPart](partname, content_type, blob);
+  }
+  #comments;
+  get comments() {
+    const model = this.package[packageModel](this);
+    if (this.#comments) {
+      try {
+        model.node(this.#comments.ref);
+        return this.#comments;
+      } catch (error) {
+        if (!(error instanceof StaleHandleError)) throw error;
+      }
+    }
+    return this.#comments = model.nativeComments(this);
+  }
+  static default(owner) {
+    if (!(owner instanceof PackageView)) throw new InputTypeError("Expected an admitted owner package.");
+    return owner[packageCreateNative]("comments");
+  }
+  static nativeTypes = ["application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"];
+};
+var SettingsPart = class extends XmlPartView {
+  static async load(partname, content_type, blob, owner) {
+    if (!(owner instanceof PackageView) || typeof content_type !== "string" || !this.nativeTypes.includes(parseMediaType(content_type)))
+      throw new InputTypeError("Expected an admitted owner and the native part content type.");
+    return owner[packageAdmitPart](partname, content_type, blob);
+  }
+  #settings;
+  get settings() {
+    return this.#settings ??= this.package[packageModel](this).nativeSettings(this);
+  }
+  static default(owner) {
+    if (!(owner instanceof PackageView)) throw new InputTypeError("Expected an admitted owner package.");
+    return owner[packageCreateNative]("settings");
+  }
+  static nativeTypes = ["application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml"];
+};
+var StylesPart = class extends XmlPartView {
+  static async load(partname, content_type, blob, owner) {
+    if (!(owner instanceof PackageView) || typeof content_type !== "string" || !this.nativeTypes.includes(parseMediaType(content_type)))
+      throw new InputTypeError("Expected an admitted owner and the native part content type.");
+    return owner[packageAdmitPart](partname, content_type, blob);
+  }
+  #styles;
+  #styleElement;
+  [packageBindStyles](styles, element) {
+    if (this.#styles) throw new InvalidValueError("The styles part already has a live binding.");
+    this.#styles = styles;
+    this.#styleElement = element;
+  }
+  get styles() {
+    return this.#styles ?? this.package[packageModel](this).nativeStyles(this);
+  }
+  get element() {
+    return this.#styleElement ? this.#styleElement() : super.element;
+  }
+  static default(owner) {
+    if (!(owner instanceof PackageView)) throw new InputTypeError("Expected an admitted owner package.");
+    return owner[packageCreateNative]("styles");
+  }
+  static nativeTypes = ["application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"];
+};
+var DocumentPartView = class extends StoryPart {
+  async save(output, options) {
+    this.package[packageMetadata](this);
+    await this.package.save(output, options);
+  }
+  static nativeTypes = Object.values(documentTypes);
+  get document() {
+    return this.package[packageModel](this).nativeDocument(this);
+  }
+  get comments() {
+    return this.document.comments;
+  }
+  get settings() {
+    return this.document.settings;
+  }
+  get styles() {
+    return this.package[packageModel](this).stylesForDocument(this.partname.toString());
+  }
+  get inline_shapes() {
+    return this.document.inline_shapes;
+  }
+  get core_properties() {
+    this.package[packageMetadata](this);
+    return this.package.core_properties;
+  }
+  add_header_part() {
+    const rId = this.package[packageNextRelationshipId](this);
+    const part = this.package[packageCreateNative]("header", { owner: this, rId });
+    return snapshotSequence([part, rId]);
+  }
+  add_footer_part() {
+    const rId = this.package[packageNextRelationshipId](this);
+    const part = this.package[packageCreateNative]("footer", { owner: this, rId });
+    return snapshotSequence([part, rId]);
+  }
+  header_part(rId) {
+    const edge = this.rels.at(rId), dialect = Object.values(documentDialects).find((dialect2) => dialect2.w === this.element.namespace);
+    if (edge.is_external || edge.reltype !== `${dialect.r}/header` || !(edge.target_part instanceof HeaderPart))
+      throw new InvalidValueError("Expected an owned native header relationship.");
+    return edge.target_part;
+  }
+  footer_part(rId) {
+    const edge = this.rels.at(rId), dialect = Object.values(documentDialects).find((dialect2) => dialect2.w === this.element.namespace);
+    if (edge.is_external || edge.reltype !== `${dialect.r}/footer` || !(edge.target_part instanceof FooterPart))
+      throw new InvalidValueError("Expected an owned native footer relationship.");
+    return edge.target_part;
+  }
+  drop_header_part(rId) {
+    const part = this.header_part(rId), rows = this.package[packageEdges](this).filter((row) => row.rId !== rId);
+    this.package[packageEditRelationships](this, rows, part);
+  }
+  static async load(partname, content_type, blob, owner) {
+    if (typeof content_type !== "string" || !Object.values(documentTypes).includes(parseMediaType(content_type))) throw new InputTypeError("Expected a macro-free document or template content type.");
+    return await super.load(partname, content_type, blob, owner);
+  }
+  get numbering_part() {
+    return this.package[packageNumbering](this);
+  }
+};
+var NumberingPart = class extends XmlPartView {
+  static nativeTypes = ["application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"];
+  #definitions;
+  static async load(partname, content_type, blob, owner) {
+    if (typeof content_type !== "string" || parseMediaType(content_type) !== "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml") throw new InputTypeError("Expected the numbering content type.");
+    return await super.load(partname, content_type, blob, owner);
+  }
+  static new(owner) {
+    if (!(owner instanceof PackageView)) throw new InputTypeError("Expected an admitted owner package.");
+    owner[packageValidate]();
+    return owner[packageNumbering](owner.main_document_part);
+  }
+  get numbering_definitions() {
+    if (this.package[packageReadXml](this).xml.root.localName !== "numbering") throw new InvalidValueError("Expected an owned numbering root.");
+    return this.#definitions ??= new _NumberingDefinitions(this);
+  }
+};
+var _NumberingDefinitions = class {
+  constructor(owner) {
+    this.owner = owner;
+  }
+  owner;
+  get length() {
+    const { xml, budget } = this.owner.package[packageReadXml](this.owner), root = xml.root;
+    if (root.localName !== "numbering" || root.namespace !== documentDialects.transitional.w && root.namespace !== documentDialects.strict.w)
+      throw new InvalidValueError("Expected an owned numbering root.");
+    let count = 0;
+    for (const node of activeXmlChildren(xml, budget)(root)) {
+      budget.charge("work", 1);
+      if (node.namespace === root.namespace && node.localName === "num") count++;
+    }
+    return count;
+  }
+};
+var CorePropertiesPartView = class _CorePropertiesPartView extends XmlPartView {
+  static nativeTypes = ["application/vnd.openxmlformats-package.core-properties+xml"];
+  static default(owner) {
+    if (!(owner instanceof PackageView)) throw new InputTypeError("Expected an admitted owner package.");
+    const part = owner.core_properties.part;
+    if (!(part instanceof _CorePropertiesPartView)) throw new InvalidValueError("Expected an owned core-properties part.");
+    return part;
+  }
+  static async load(partname, content_type, blob, owner) {
+    if (typeof content_type !== "string" || asciiKey(content_type) !== "application/vnd.openxmlformats-package.core-properties+xml") throw new InputTypeError("Expected the core-properties content type.");
+    return await super.load(partname, content_type, blob, owner);
+  }
+  #properties;
+  get core_properties() {
+    return this.#properties ??= this.package[packageCore](this);
+  }
+};
+var ImagePartView = class extends PartView {
+  static async load(partname, content_type, blob, owner) {
+    if (!(owner instanceof PackageView)) throw new InputTypeError("Expected an admitted owner package.");
+    return owner[packageLoadImage](partname, content_type, blob);
+  }
+  static async from_image(image, partname, owner) {
+    if (!(image instanceof Image) || !(owner instanceof PackageView)) throw new InputTypeError("Expected an admitted image and owner package.");
+    return owner[packageLoadImage](partname, image.content_type, image);
+  }
+  get image() {
+    return this.package[packageImage](this);
+  }
+  get filename() {
+    return this.image.filename;
+  }
+  get sha1() {
+    return this.image.sha1;
+  }
+  get default_cx() {
+    return this.image.width;
+  }
+  get default_cy() {
+    return this.image.height;
+  }
+};
+var ImageParts = class {
+  #package;
+  constructor(owner) {
+    this.#package = owner;
+  }
+  get length() {
+    return this.#package[packageImages]().length;
+  }
+  [Symbol.iterator]() {
+    return this.#package[packageImages]()[Symbol.iterator]();
+  }
+  has(item) {
+    return this.#package[packageImages]().includes(item);
+  }
+  append(item) {
+    if (!(item instanceof ImagePartView)) throw new InputTypeError("Expected an image part.");
+    if (item.package !== this.#package) throw new OwnershipError("Expected an image part owned by this package.");
+    this.#package[packageMetadata](item);
+  }
+  async get_or_add_image_part(input) {
+    const part = await this.#package.get_or_add_image_part(input);
+    if (!this.has(part)) throw new InvalidValueError("Image admission lost collection ownership.");
+    return part;
+  }
+};
+var coreStrings = ["title", "subject", "author", "keywords", "comments", "last_modified_by", "category", "content_status", "identifier", "language", "version"];
+var coreDates = ["created", "modified", "last_printed"];
+function coreKey(name) {
+  return { last_modified_by: "lastModifiedBy", content_status: "contentStatus", last_printed: "lastPrinted" }[name] ?? name;
+}
+var CoreProperties = class {
+  #part;
+  #budget;
+  constructor(part, budget) {
+    this.#part = part;
+    this.#budget = budget;
+  }
+  get part() {
+    return this.#part;
+  }
+  get element() {
+    return this.#part.element;
+  }
+  [coreRead](name) {
+    const xml = new DocumentXmlEditor(this.#part.blob, {}, void 0, this.#budget), key = coreKey(name), declaration = corePropertyKeys[key];
+    const properties = readPropertyNodes(xml.root, "core", "transitional", this.#budget);
+    const value = properties.find((property) => property.name === key);
+    if (declaration.type === "integer") {
+      return typeof value?.value?.value === "number" ? value.value.value : 0;
+    }
+    if (declaration.type === "date") return value?.valueContent ? readCorePropertyDate(value.valueContent.filter((node) => node.kind === "text" || node.kind === "cdata").map((node) => node.text).join(""), key) : null;
+    return typeof value?.value?.value === "string" ? value.value.value : "";
+  }
+  [coreWrite](name, value) {
+    const declaration = corePropertyKeys[coreKey(name)];
+    let text;
+    if (declaration.type === "string") {
+      if (typeof value !== "string" || !validateDocxValue("string", value)) throw new InputTypeError("Expected a core-property string.");
+      if ([...value].length > 255) throw new InvalidValueError("Core-property strings exceed 255 scalar values.");
+      text = value;
+    } else if (declaration.type === "integer") {
+      if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) throw new InvalidValueError("Expected a positive safe revision.");
+      text = serializePropertyScalar(value, "revision");
+    } else {
+      if (!(value instanceof Date) || !Number.isFinite(Date.prototype.getTime.call(value))) throw new InputTypeError("Expected a valid explicit UTC Date.");
+      text = normalizePropertyDate(new Date(Math.floor(Date.prototype.getTime.call(value) / 1e3) * 1e3).toISOString());
+      if (coreKey(name) === "lastPrinted" && text.slice(0, 4) === "0000") throw new InvalidValueError("XML dateTime properties require a nonzero native year.");
+    }
+    const view = this.#part.element;
+    const matching = view.children.filter((node) => node.tag.namespaceURI === declaration.namespace && node.tag.localName === declaration.localName);
+    if (matching.length > 1) throw new InvalidValueError("Core property is ambiguous.");
+    if (matching.length) matching[0][replaceXmlScalar](text);
+    else view.insert(view.children.length, {
+      kind: "element",
+      name: { namespaceURI: declaration.namespace, localName: declaration.localName },
+      ...declaration.type === "date" && declaration.namespace !== corePropertyNamespace ? { attributes: [{ name: { namespaceURI: "http://www.w3.org/2001/XMLSchema-instance", localName: "type" }, value: "dcterms:W3CDTF" }] } : {},
+      children: [{ kind: "text", text }]
+    });
+  }
+};
+for (const name of [...coreStrings, ...coreDates, "revision"]) Object.defineProperty(CoreProperties.prototype, name, {
+  get() {
+    return this[coreRead](name);
+  },
+  set(value) {
+    this[coreWrite](name, value);
+  },
+  enumerable: true
+});
+var RelationshipView = class {
+  #collection;
+  #id;
+  #token;
+  constructor(collection, id, token) {
+    this.#collection = collection;
+    this.#id = id;
+    this.#token = token;
+    Object.freeze(this);
+  }
+  belongs(collection) {
+    return this.#collection === collection;
+  }
+  belongsPackage(owner) {
+    return this.#collection.package === owner;
+  }
+  row() {
+    return this.#collection.row(this.#id, this.#token);
+  }
+  get rId() {
+    return this.row().rId;
+  }
+  get reltype() {
+    return this.row().reltype;
+  }
+  get target_ref() {
+    return this.row().target_ref;
+  }
+  get is_external() {
+    return this.row().is_external;
+  }
+  get target_part() {
+    const row = this.row();
+    if (row.is_external) throw new InvalidValueError("External relationships have no owned target part.");
+    return this.#collection.package[packagePart](row.target_part.partname);
+  }
+};
+var Relationships = class {
+  #package;
+  #owner;
+  #views = /* @__PURE__ */ new Map();
+  constructor(ownerPackage, owner) {
+    this.#package = ownerPackage;
+    this.#owner = owner;
+  }
+  get package() {
+    return this.#package;
+  }
+  [invalidateRelationshipViews](ids) {
+    for (const id of ids) this.#views.delete(id);
+  }
+  rows() {
+    return this.#package[packageEdges](this.#owner);
+  }
+  row(id, token) {
+    const row = this.rows().find((row2) => row2.rId === id);
+    if (!row || this.#views.get(id)?.token !== token) throw new StaleHandleError("The relationship view is detached.");
+    return row;
+  }
+  view(row) {
+    let record = this.#views.get(row.rId);
+    if (!record) {
+      const token = {};
+      record = { token, view: new RelationshipView(this, row.rId, token) };
+      this.#views.set(row.rId, record);
+    }
+    return record.view;
+  }
+  get length() {
+    return this.rows().length;
+  }
+  has(id) {
+    if (typeof id !== "string") throw new InputTypeError("Expected a relationship ID.");
+    return this.rows().some((row) => row.rId === id);
+  }
+  get(id, defaultValue = null) {
+    if (typeof id !== "string") throw new InputTypeError("Expected a relationship ID.");
+    if (defaultValue !== null && !(defaultValue instanceof RelationshipView)) throw new InputTypeError("Expected a relationship default or null.");
+    const row = this.rows().find((row2) => row2.rId === id);
+    return row ? this.view(row) : defaultValue;
+  }
+  at(id) {
+    const view = this.get(id);
+    if (!view) throw new MissingKeyError("Relationship ID was not found.");
+    return view;
+  }
+  *keys() {
+    for (const row of this.rows()) yield row.rId;
+  }
+  *values() {
+    for (const row of this.rows()) yield this.view(row);
+  }
+  *items() {
+    for (const row of this.rows()) yield snapshotSequence([row.rId, this.view(row)]);
+  }
+  [Symbol.iterator]() {
+    return this.keys();
+  }
+  get related_parts() {
+    return new Map([...this.values()].filter((edge) => !edge.is_external).map((edge) => [edge.rId, edge.target_part]));
+  }
+  get xml() {
+    return this.#package[packageRelationshipXml](this.#owner);
+  }
+  add_relationship(reltype, target, rId, is_external = false) {
+    if (typeof reltype !== "string" || typeof rId !== "string" || !rId || typeof is_external !== "boolean") throw new InputTypeError("Expected relationship metadata.");
+    reltype = collapseRelationshipScalar(reltype);
+    rId = collapseRelationshipScalar(rId);
+    if (this.has(rId)) throw new InvalidValueError("Relationship ID is already occupied.");
+    let target_ref;
+    if (is_external) {
+      if (typeof target !== "string") throw new InputTypeError("Expected an inert external target string.");
+      target_ref = collapseRelationshipScalar(target);
+    } else {
+      if (!(target instanceof PartView)) throw new InputTypeError("Expected a target part.");
+      if (target.package !== this.#package) throw new OwnershipError("Expected a target owned by this package.");
+      target_ref = relativePartTarget(this.#owner?.partname.toString() ?? "/", target.partname.toString());
+    }
+    this.#package[packageEditRelationships](this.#owner, [...this.rows(), { rId, reltype, target_ref, is_external }]);
+    return this.at(rId);
+  }
+  get_or_add(reltype, target_part) {
+    if (typeof reltype !== "string") throw new InputTypeError("Expected a relationship type.");
+    reltype = collapseRelationshipScalar(reltype);
+    if (!(target_part instanceof PartView)) throw new InputTypeError("Expected a target part.");
+    if (target_part.package !== this.#package) throw new OwnershipError("Expected an owned target part.");
+    const found = [...this.values()].find((row) => !row.is_external && row.reltype === reltype && row.target_part === target_part);
+    return found ?? this.add_relationship(reltype, target_part, this.#package[packageNextRelationshipId](this.#owner));
+  }
+  get_or_add_ext_rel(reltype, target_ref) {
+    if (typeof reltype !== "string" || typeof target_ref !== "string") throw new InputTypeError("Expected relationship URI strings.");
+    reltype = collapseRelationshipScalar(reltype);
+    target_ref = collapseRelationshipScalar(target_ref);
+    const found = [...this.values()].find((row) => row.is_external && row.reltype === reltype && row.target_ref === target_ref);
+    return found?.rId ?? this.add_relationship(reltype, target_ref, this.#package[packageNextRelationshipId](this.#owner), true).rId;
+  }
+  part_with_reltype(reltype) {
+    if (typeof reltype !== "string") throw new InputTypeError("Expected a relationship type.");
+    const rows = [...this.values()].filter((row) => row.reltype === reltype && !row.is_external);
+    if (!rows.length) throw new MissingKeyError("Relationship type was not found.");
+    if (rows.length !== 1) throw new InvalidValueError("Relationship type is ambiguous.");
+    return rows[0].target_part;
+  }
+  delete(id) {
+    this.at(id);
+    this.#package[packageEditRelationships](this.#owner, this.rows().filter((row) => row.rId !== id));
+    this.#views.delete(id);
+  }
+  clear() {
+    this.#package[packageEditRelationships](this.#owner, []);
+    this.#views.clear();
+  }
+  set(id, value) {
+    this.#package[packageEditRelationships](this.#owner, this.assignedRows([[id, value]]));
+  }
+  assignedRows(entries) {
+    if (entries == null || typeof entries === "string" || typeof entries[Symbol.iterator] !== "function") throw new InputTypeError("Expected iterable relationship entries.");
+    const replacements = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      if (!Array.isArray(entry) || entry.length !== 2) throw new InputTypeError("Expected a relationship key and value pair.");
+      const [id, value] = entry;
+      if (!(value instanceof RelationshipView) || typeof id !== "string" || id !== value.rId || replacements.has(id)) throw new InputTypeError("Expected matching relationship entries.");
+      if (!value.belongsPackage(this.#package)) throw new OwnershipError("Expected same-package relationship entries.");
+      let target_ref = value.target_ref;
+      if (!value.is_external && !value.belongs(this)) {
+        const hash = target_ref.indexOf("#");
+        target_ref = relativePartTarget(this.#owner?.partname.toString() ?? "/", value.target_part.partname.toString()) + (hash < 0 ? "" : target_ref.slice(hash));
+      }
+      replacements.set(id, { rId: id, reltype: value.reltype, is_external: value.is_external, target_ref });
+    }
+    const rows = this.rows().map((row) => replacements.get(row.rId) ?? row);
+    for (const [id, row] of replacements) if (!rows.some((existing) => existing.rId === id)) rows.push(row);
+    return rows;
+  }
+  update(entries) {
+    this.#package[packageEditRelationships](this.#owner, this.assignedRows(entries));
+  }
+  setdefault(id, value) {
+    if (!(value instanceof RelationshipView)) throw new InputTypeError("Expected a relationship default.");
+    const existing = this.get(id);
+    if (existing) return existing;
+    this.update([[id, value]]);
+    return this.at(id);
+  }
+  pop(id, fallback) {
+    if (fallback !== void 0 && fallback !== null && !(fallback instanceof RelationshipView)) throw new InputTypeError("Expected a relationship default or null.");
+    const found = this.get(id);
+    if (!found) {
+      if (fallback !== void 0) return fallback;
+      throw new MissingKeyError("Relationship ID was not found.");
+    }
+    this.delete(id);
+    return found;
+  }
+  popitem() {
+    const id = [...this.keys()].at(-1);
+    if (id === void 0) throw new MissingKeyError("Relationship collection is empty.");
+    return snapshotSequence([id, this.pop(id)]);
+  }
+  copy() {
+    return new Map(this.items());
+  }
+};
+
+export {
+  XmlElementView,
+  bindXmlElementView,
+  admitDocumentModel,
+  packagePart,
+  packageStyleAllocationIds,
+  packageBindStyles,
+  packageAdmitImages,
+  packageBindImage,
+  packageOwnerCheckpoint,
+  PackageView,
+  PartView,
+  XmlPartView,
+  StoryPart,
+  HeaderPart,
+  FooterPart,
+  CommentsPart,
+  SettingsPart,
+  StylesPart,
+  DocumentPartView,
+  NumberingPart,
+  _NumberingDefinitions,
+  CorePropertiesPartView,
+  ImagePartView,
+  ImageParts,
+  CoreProperties,
+  RelationshipView,
+  Relationships
+};