@arbidocs/coedit 0.0.0-stage → 0.4.33

package/dist/encoding.js

@@ -0,0 +1,680 @@
+import * as Y from 'yjs';
+import { readOoxmlPart, validateExternalTarget, relsPartNameFor, writeOoxmlPackage, readOoxmlPackage } from '@docx-editor.dev/core/store';
+
+// src/encoding.ts
+
+// src/rich.ts
+var WML = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+var WRAPPERS = /* @__PURE__ */ new Set([
+  "ins",
+  "del",
+  "moveFrom",
+  "moveTo",
+  "hyperlink",
+  "smartTag",
+  "fldSimple",
+  "customXml",
+  "dir",
+  "bdo",
+  "sdtContent"
+]);
+var TEXT_ELEMENTS = /* @__PURE__ */ new Set(["t", "delText", "instrText"]);
+var isEl = (n) => typeof n !== "string";
+var isWml = (el, local) => el.ns === WML && el.local === local;
+function describe(el) {
+  const desc = { ns: el.ns, local: el.local, attrs: el.attrs, bindings: el.bindings };
+  if (el.prefix !== void 0) desc.prefix = el.prefix;
+  return desc;
+}
+function withChildren(desc, children, id) {
+  const el = {
+    ns: desc.ns,
+    local: desc.local,
+    attrs: desc.attrs,
+    bindings: desc.bindings,
+    children
+  };
+  if (desc.prefix !== void 0) el.prefix = desc.prefix;
+  if (id !== void 0) el._id = id;
+  return el;
+}
+var counter = 0;
+function newRunId() {
+  counter += 1;
+  return `${Math.random().toString(36).slice(2, 8)}${counter.toString(36)}`;
+}
+var Unrepresentable = class extends Error {
+};
+function fail() {
+  throw new Unrepresentable();
+}
+function encodeRun(run, wrappers, out) {
+  const children = run.children;
+  let rPr = null;
+  let start = 0;
+  const first = children[0];
+  if (first !== void 0 && isEl(first) && isWml(first, "rPr")) {
+    rPr = first;
+    start = 1;
+  }
+  const base = { r: rPr, ra: describe(run), ri: run._id ?? newRunId(), w: wrappers };
+  let produced = false;
+  for (let i = start; i < children.length; i++) {
+    const child = children[i];
+    if (!isEl(child)) fail();
+    const only = child.children[0];
+    if (child.ns === WML && TEXT_ELEMENTS.has(child.local) && child.children.length === 1 && typeof only === "string" && only.length > 0) {
+      const tx = describe(child);
+      for (let c = 0; c < only.length; c++) out.push({ v: only[c], a: { ...base, tx, k: null } });
+    } else {
+      out.push({ v: { x: child }, a: { ...base, tx: null, k: null } });
+    }
+    produced = true;
+  }
+  if (!produced)
+    out.push({
+      v: { x: { ns: WML, local: "e", attrs: [], bindings: [], children: [] } },
+      a: { ...base, tx: null, k: "e" }
+    });
+}
+function encodeInline(children, wrappers, out) {
+  for (const child of children) {
+    if (!isEl(child)) fail();
+    if (child.ns === WML && child.local === "r") {
+      encodeRun(child, wrappers, out);
+    } else if (child.ns === WML && WRAPPERS.has(child.local)) {
+      const before = out.length;
+      const desc = { ...describe(child), head: [], id: child._id ?? newRunId() };
+      let ok = true;
+      const inner = [];
+      try {
+        encodeInline(child.children, [...wrappers, desc], inner);
+      } catch (error) {
+        if (!(error instanceof Unrepresentable)) throw error;
+        ok = false;
+      }
+      if (ok && inner.length > 0) out.push(...inner);
+      else {
+        out.length = before;
+        out.push(atom(child, wrappers));
+      }
+    } else if (child.ns === WML && child.local === "sdt") {
+      const last = child.children[child.children.length - 1];
+      const head = child.children.slice(0, -1);
+      if (last !== void 0 && isEl(last) && isWml(last, "sdtContent") && head.every(isEl)) {
+        const before = out.length;
+        const sdt = {
+          ...describe(child),
+          head,
+          id: child._id ?? newRunId()
+        };
+        const content = { ...describe(last), head: [], id: last._id ?? newRunId() };
+        const inner = [];
+        let ok = true;
+        try {
+          encodeInline(last.children, [...wrappers, sdt, content], inner);
+        } catch (error) {
+          if (!(error instanceof Unrepresentable)) throw error;
+          ok = false;
+        }
+        if (ok && inner.length > 0) out.push(...inner);
+        else {
+          out.length = before;
+          out.push(atom(child, wrappers));
+        }
+      } else out.push(atom(child, wrappers));
+    } else {
+      out.push(atom(child, wrappers));
+    }
+  }
+}
+function atom(el, wrappers) {
+  return { v: { x: el }, a: { r: null, ra: null, ri: null, w: wrappers, tx: null, k: "a" } };
+}
+function encodeParagraph(children) {
+  const head = [];
+  let start = 0;
+  const first = children[0];
+  if (first !== void 0 && isEl(first) && isWml(first, "pPr")) {
+    head.push(first);
+    start = 1;
+  }
+  const units = [];
+  try {
+    encodeInline(children.slice(start), [], units);
+  } catch (error) {
+    if (error instanceof Unrepresentable) return null;
+    throw error;
+  }
+  return { head, units };
+}
+var same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function decodeRange(units, from, to, depth) {
+  const out = [];
+  let i = from;
+  while (i < to) {
+    const unit = units[i];
+    const { w } = unit.a;
+    if (w.length > depth) {
+      const wrapper = w[depth];
+      let j = i + 1;
+      while (j < to && units[j].a.w.length > depth && same(units[j].a.w[depth], wrapper)) j++;
+      out.push(
+        withChildren(wrapper, [...wrapper.head, ...decodeRange(units, i, j, depth + 1)], wrapper.id)
+      );
+      i = j;
+    } else if (unit.a.k === "a") {
+      out.push(unit.v.x);
+      i++;
+    } else {
+      let j = i + 1;
+      while (unit.a.k !== "e" && j < to && units[j].a.w.length === depth && units[j].a.k !== "a" && units[j].a.k !== "e" && units[j].a.ri === unit.a.ri && same(units[j].a.r, unit.a.r) && same(units[j].a.ra, unit.a.ra)) {
+        j++;
+      }
+      out.push(decodeRun(units, i, j));
+      i = j;
+    }
+  }
+  return out;
+}
+function decodeRun(units, from, to) {
+  const { r, ra } = units[from].a;
+  const children = [];
+  if (r) children.push(r);
+  let i = from;
+  while (i < to) {
+    const unit = units[i];
+    if (unit.a.k === "e") {
+      i++;
+    } else if (typeof unit.v === "string") {
+      let j = i + 1;
+      while (j < to && typeof units[j].v === "string" && same(units[j].a.tx, unit.a.tx)) j++;
+      let text = "";
+      for (let c = i; c < j; c++) text += units[c].v;
+      children.push(withChildren(unit.a.tx, [text]));
+      i = j;
+    } else {
+      children.push(unit.v.x);
+      i++;
+    }
+  }
+  return withChildren(ra, children, units[from].a.ri ?? void 0);
+}
+function decodeInline(units) {
+  return decodeRange(units, 0, units.length, 0);
+}
+var KEYS = ["r", "ra", "ri", "w", "tx", "k"];
+function toAttributes(a) {
+  const out = {};
+  for (const key of KEYS) {
+    const value = a[key];
+    if (value !== null && !(key === "w" && value.length === 0)) out[key] = value;
+  }
+  return out;
+}
+function fromAttributes(attributes) {
+  const a = attributes ?? {};
+  return {
+    r: a.r ?? null,
+    ra: a.ra ?? null,
+    ri: a.ri ?? null,
+    w: a.w ?? [],
+    tx: a.tx ?? null,
+    k: a.k ?? null
+  };
+}
+function readUnits(text) {
+  const units = [];
+  for (const op of text.toDelta()) {
+    const a = fromAttributes(op.attributes);
+    if (typeof op.insert === "string") {
+      for (let i = 0; i < op.insert.length; i++) units.push({ v: op.insert[i], a });
+    } else {
+      units.push({ v: op.insert, a });
+    }
+  }
+  return units;
+}
+var valueKeyOf = (u) => typeof u.v === "string" ? u.v : JSON.stringify(u.v);
+var attrsKeyOf = (u) => JSON.stringify(u.a);
+function attributeChange(from, to) {
+  const a = toAttributes(from);
+  const b = toAttributes(to);
+  const change = {};
+  for (const key of KEYS) {
+    if (JSON.stringify(a[key]) !== JSON.stringify(b[key])) change[key] = b[key] ?? null;
+  }
+  return change;
+}
+function pushRetain(delta, length, attributes) {
+  if (length === 0) return;
+  const last = delta[delta.length - 1];
+  const empty = !attributes || Object.keys(attributes).length === 0;
+  if (last && last.retain !== void 0 && !last.attributes && empty) {
+    last.retain += length;
+    return;
+  }
+  delta.push(empty ? { retain: length } : { retain: length, attributes });
+}
+function reformat(delta, previous, from, next, to, length) {
+  let i = 0;
+  while (i < length) {
+    const change = attributeChange(previous[from + i].a, next[to + i].a);
+    const key = JSON.stringify(change);
+    let j = i + 1;
+    while (j < length && JSON.stringify(attributeChange(previous[from + j].a, next[to + j].a)) === key) {
+      j++;
+    }
+    pushRetain(delta, j - i, change);
+    i = j;
+  }
+}
+function applyUnits(text, previous, next) {
+  let start = 0;
+  const limit = Math.min(previous.length, next.length);
+  while (start < limit && valueKeyOf(previous[start]) === valueKeyOf(next[start])) start++;
+  let endPrev = previous.length;
+  let endNext = next.length;
+  while (endPrev > start && endNext > start && valueKeyOf(previous[endPrev - 1]) === valueKeyOf(next[endNext - 1])) {
+    endPrev--;
+    endNext--;
+  }
+  const delta = [];
+  reformat(delta, previous, 0, next, 0, start);
+  if (endPrev > start) delta.push({ delete: endPrev - start });
+  let i = start;
+  while (i < endNext) {
+    const unit = next[i];
+    if (typeof unit.v !== "string") {
+      delta.push({ insert: unit.v, attributes: toAttributes(unit.a) });
+      i++;
+      continue;
+    }
+    let j = i + 1;
+    let chunk = unit.v;
+    const attributes = attrsKeyOf(unit);
+    while (j < endNext && typeof next[j].v === "string" && attrsKeyOf(next[j]) === attributes) {
+      chunk += next[j].v;
+      j++;
+    }
+    delta.push({ insert: chunk, attributes: toAttributes(unit.a) });
+    i = j;
+  }
+  reformat(delta, previous, endPrev, next, endNext, previous.length - endPrev);
+  if (delta.every((op) => op.retain !== void 0 && !op.attributes)) return;
+  text.applyDelta(delta, { sanitize: false });
+}
+function writeUnits(text, units) {
+  applyUnits(text, [], units);
+}
+
+// src/mirror.ts
+function isRichParagraph(map) {
+  return map.has("inline");
+}
+function isParagraphEl(el) {
+  return el.ns === WML && el.local === "p";
+}
+function fieldsOf(map, xml) {
+  map.set("ns", xml.ns);
+  map.set("local", xml.local);
+  if (xml.prefix !== void 0) map.set("prefix", xml.prefix);
+  const attrs = new Y.Array();
+  attrs.push(xml.attrs.map((a) => ({ ...a })));
+  map.set("attrs", attrs);
+  const bindings = new Y.Array();
+  bindings.push(xml.bindings.map((b) => ({ ...b })));
+  map.set("bindings", bindings);
+}
+function newText(value) {
+  const text = new Y.Text();
+  text.insert(0, value);
+  return text;
+}
+function createRichParagraph(xml, encoded) {
+  const map = new Y.Map();
+  fieldsOf(map, xml);
+  const children = new Y.Array();
+  children.push(encoded.head.map((el) => xmlToLive(el)));
+  map.set("children", children);
+  const inline = new Y.Text();
+  writeUnits(inline, encoded.units);
+  map.set("inline", inline);
+  return map;
+}
+function xmlToLive(xml) {
+  if (isParagraphEl(xml)) {
+    const encoded = encodeParagraph(xml.children);
+    if (encoded) return createRichParagraph(xml, encoded);
+  }
+  return xmlToGenericLive(xml);
+}
+function xmlToGenericLive(xml) {
+  const map = new Y.Map();
+  fieldsOf(map, xml);
+  const children = new Y.Array();
+  children.push(xml.children.map((c) => typeof c === "string" ? newText(c) : xmlToLive(c)));
+  map.set("children", children);
+  return map;
+}
+function liveToXml(map) {
+  const prefix = map.get("prefix");
+  const stored = map.get("children").toArray().map((child) => child instanceof Y.Text ? child.toString() : liveToXml(child));
+  const children = isRichParagraph(map) ? [...stored, ...decodeInline(readUnits(map.get("inline")))] : stored;
+  const xml = {
+    ns: map.get("ns"),
+    local: map.get("local"),
+    attrs: map.get("attrs").toArray().map((a) => ({ ...a })),
+    bindings: map.get("bindings").toArray().map((b) => ({ ...b })),
+    children
+  };
+  if (prefix !== void 0) xml.prefix = prefix;
+  return xml;
+}
+var escapeText = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var escapeAttr = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/\t/g, "&#9;").replace(/\n/g, "&#10;").replace(/\r/g, "&#13;");
+var qualified = (prefix, local) => prefix ? `${prefix}:${local}` : local;
+function serializeXml(el, scope) {
+  const inScope = new Map(scope);
+  for (const b of el.bindings) inScope.set(b.prefix, b.ns);
+  let out = `<${qualified(el.prefix, el.local)}`;
+  for (const b of el.bindings) {
+    out += b.prefix === "" ? ` xmlns="${escapeAttr(b.ns)}"` : ` xmlns:${b.prefix}="${escapeAttr(b.ns)}"`;
+  }
+  for (const a of el.attrs) {
+    let p = a.prefix;
+    if (a.ns !== "" && !p) {
+      for (const [candidate, uri] of inScope) {
+        if (candidate !== "" && uri === a.ns) {
+          p = candidate;
+          break;
+        }
+      }
+    }
+    out += ` ${qualified(p, a.local)}="${escapeAttr(a.value)}"`;
+  }
+  if (el.children.length === 0) return `${out}/>`;
+  out += ">";
+  for (const child of el.children) {
+    out += typeof child === "string" ? escapeText(child) : serializeXml(child, inScope);
+  }
+  return `${out}</${qualified(el.prefix, el.local)}>`;
+}
+function serializeLive(el, scope) {
+  if (isRichParagraph(el)) return serializeXml(liveToXml(el), scope);
+  const prefix = el.get("prefix");
+  const local = el.get("local");
+  const bindings = el.get("bindings").toArray();
+  const attrs = el.get("attrs").toArray();
+  const children = el.get("children").toArray();
+  const inScope = new Map(scope);
+  for (const b of bindings) inScope.set(b.prefix, b.ns);
+  let out = `<${qualified(prefix, local)}`;
+  for (const b of bindings) {
+    out += b.prefix === "" ? ` xmlns="${escapeAttr(b.ns)}"` : ` xmlns:${b.prefix}="${escapeAttr(b.ns)}"`;
+  }
+  for (const a of attrs) {
+    let p = a.prefix;
+    if (a.ns !== "" && !p) {
+      for (const [candidate, uri] of inScope) {
+        if (candidate !== "" && uri === a.ns) {
+          p = candidate;
+          break;
+        }
+      }
+    }
+    out += ` ${qualified(p, a.local)}="${escapeAttr(a.value)}"`;
+  }
+  if (children.length === 0) return `${out}/>`;
+  out += ">";
+  for (const child of children) {
+    out += child instanceof Y.Text ? escapeText(child.toString()) : serializeLive(child, inScope);
+  }
+  return `${out}</${qualified(prefix, local)}>`;
+}
+
+// src/encoding.ts
+var COLLAB_FORMAT = "arbi-docx/1";
+function isText(node) {
+  return node.kind === "textValue";
+}
+function canonicalToXml(node) {
+  if (isText(node)) return node.value;
+  const xml = {
+    ns: node.namespaceUri,
+    local: node.localName,
+    attrs: node.attributes.map((a) => {
+      const json = { ns: a.namespaceUri, local: a.localName, value: a.value };
+      if (a.prefix !== void 0) json.prefix = a.prefix;
+      return json;
+    }),
+    bindings: node.namespaceBindings.map((b) => ({ prefix: b.prefix, ns: b.namespaceUri })),
+    children: node.children.map(canonicalToXml)
+  };
+  if (node.prefix !== void 0) xml.prefix = node.prefix;
+  return xml;
+}
+function encodeElement(el) {
+  return xmlToLive(canonicalToXml(el));
+}
+function encodeText(value) {
+  return newText(value);
+}
+function bootstrap(doc, pkg) {
+  doc.transact(() => {
+    const meta = doc.getMap("meta");
+    meta.set("format", COLLAB_FORMAT);
+    meta.set("mainDocumentPart", pkg.mainDocumentPart);
+    const parts = doc.getMap("parts");
+    for (const [name, part] of pkg.parts) {
+      if (isRelsPart(name)) continue;
+      parts.set(name, encodeElement(part.root));
+    }
+    const binaries = doc.getMap("binaries");
+    for (const [name, bytes] of pkg.partBytes) {
+      if (!pkg.parts.has(name)) binaries.set(name, bytes);
+    }
+    const rels = doc.getMap("rels");
+    for (const [owner, records] of pkg.relationships) {
+      const byId = new Y.Map();
+      for (const r of records) {
+        byId.set(r.id, {
+          ownerPart: r.ownerPart,
+          id: r.id,
+          type: r.type,
+          rawTarget: r.rawTarget,
+          targetMode: r.targetMode,
+          order: r.order
+        });
+      }
+      rels.set(owner, byId);
+    }
+    for (const e of pkg.externalTargets) {
+      let byId = rels.get(e.ownerPart);
+      if (!byId) {
+        byId = new Y.Map();
+        rels.set(e.ownerPart, byId);
+      }
+      byId.set(e.id, {
+        ownerPart: e.ownerPart,
+        id: e.id,
+        type: e.type,
+        rawTarget: e.rawTarget,
+        targetMode: "External",
+        order: byId.size
+      });
+    }
+    const ctDefaults = doc.getMap("ctDefaults");
+    for (const [ext, mime] of pkg.contentTypes.defaults) ctDefaults.set(ext, mime);
+    const ctOverrides = doc.getMap("ctOverrides");
+    for (const [name, mime] of pkg.contentTypes.overrides) ctOverrides.set(name, mime);
+  });
+}
+function isBootstrapped(doc) {
+  return doc.getMap("meta").get("format") !== void 0;
+}
+function readFormat(doc) {
+  const format = doc.getMap("meta").get("format");
+  return typeof format === "string" ? format : void 0;
+}
+function serializePart(doc, partName) {
+  const root = doc.getMap("parts").get(partName);
+  if (!root) throw new Error(`collab: part ${partName} is not in the room`);
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+${serializeLive(root, /* @__PURE__ */ new Map())}`;
+}
+function contentTypeOf(doc, partName) {
+  const override = doc.getMap("ctOverrides").get(partName.toLowerCase());
+  if (override !== void 0) return override;
+  const dot = partName.lastIndexOf(".");
+  if (dot < 0) return void 0;
+  return doc.getMap("ctDefaults").get(partName.slice(dot + 1).toLowerCase());
+}
+function registerMirror(doc, registry, only) {
+  const parts = doc.getMap("parts");
+  if (!only) {
+    registry.clear();
+    for (const [name, root] of parts) registry.registerTree(name, root);
+    return;
+  }
+  for (const name of only) {
+    registry.dropPart(name);
+    const root = parts.get(name);
+    if (root) registry.registerTree(name, root);
+  }
+}
+var MaterializeCache = class {
+  parts = /* @__PURE__ */ new Map();
+  dirty = /* @__PURE__ */ new Set();
+  everything = true;
+  stop = [];
+  constructor(doc) {
+    const parts = doc.getMap("parts");
+    const onParts = (events) => {
+      for (const event of events) {
+        if (event.target === parts) {
+          for (const key of event.keysChanged) this.dirty.add(key);
+        } else if (typeof event.path[0] === "string") this.dirty.add(event.path[0]);
+      }
+    };
+    parts.observeDeep(onParts);
+    this.stop.push(() => parts.unobserveDeep(onParts));
+    for (const name of ["ctOverrides", "ctDefaults"]) {
+      const map = doc.getMap(name);
+      const onTypes = () => {
+        this.everything = true;
+      };
+      map.observe(onTypes);
+      this.stop.push(() => map.unobserve(onTypes));
+    }
+  }
+  /** Names to re-read, or null when everything must be. Clears the pending set. */
+  take() {
+    const names = this.everything ? null : this.dirty;
+    this.dirty = /* @__PURE__ */ new Set();
+    this.everything = false;
+    return names;
+  }
+  /** Mark parts changed again, for a materialisation that did not complete. */
+  restore(names) {
+    if (names === null) this.everything = true;
+    else for (const name of names) this.dirty.add(name);
+  }
+  destroy() {
+    for (const stop of this.stop.splice(0)) stop();
+  }
+};
+var RELS_CONTENT_TYPE = "application/vnd.openxmlformats-package.relationships+xml";
+var RELS_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/relationships";
+function isRelsPart(partName) {
+  return partName.endsWith(".rels");
+}
+function relationshipsXml(records) {
+  const rows = records.map(
+    (r) => `<Relationship Id="${escapeAttr(r.id)}" Type="${escapeAttr(r.type)}" Target="${escapeAttr(r.rawTarget)}"${r.targetMode === "External" ? ' TargetMode="External"' : ""}/>`
+  ).join("");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="${RELS_NAMESPACE}">${rows}</Relationships>`;
+}
+var MaterializeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MaterializeError";
+  }
+};
+function materialize(doc, cache, changed = null) {
+  const meta = doc.getMap("meta");
+  const main = meta.get("mainDocumentPart");
+  if (typeof main !== "string") throw new MaterializeError("room has no main document part");
+  const parts = /* @__PURE__ */ new Map();
+  for (const name of doc.getMap("parts").keys()) {
+    if (isRelsPart(name)) continue;
+    const reusable = cache && changed && !changed.has(name) ? cache.parts.get(name) : void 0;
+    if (reusable) {
+      parts.set(name, reusable);
+      continue;
+    }
+    const contentType = contentTypeOf(doc, name);
+    if (contentType === void 0) throw new MaterializeError(`part ${name} has no content type`);
+    const read = readOoxmlPart(serializePart(doc, name), { name, contentType });
+    if (!read.ok) throw new MaterializeError(`part ${name} is not readable: ${read.reason}`);
+    parts.set(name, read.part);
+  }
+  if (cache) {
+    cache.parts.clear();
+    for (const [name, part] of parts) if (!isRelsPart(name)) cache.parts.set(name, part);
+  }
+  const partBytes = /* @__PURE__ */ new Map();
+  for (const [name, bytes] of doc.getMap("binaries")) partBytes.set(name, bytes);
+  const relationships = /* @__PURE__ */ new Map();
+  const externalTargets = [];
+  for (const [owner, byId] of doc.getMap("rels")) {
+    const records = [...byId.values()].sort((a, b) => a.order - b.order || a.id.localeCompare(b.id));
+    if (records.length === 0) continue;
+    const internal = records.filter((r) => r.targetMode !== "External");
+    if (internal.length > 0) relationships.set(owner, internal);
+    for (const r of records) {
+      if (r.targetMode !== "External") continue;
+      externalTargets.push({
+        ownerPart: r.ownerPart,
+        id: r.id,
+        type: r.type,
+        rawTarget: r.rawTarget,
+        sinkSafe: validateExternalTarget(r.rawTarget).ok
+      });
+    }
+    const relsName = relsPartNameFor(owner);
+    const read = readOoxmlPart(relationshipsXml(records), {
+      name: relsName,
+      contentType: RELS_CONTENT_TYPE
+    });
+    if (!read.ok)
+      throw new MaterializeError(`relationships of ${owner} are not valid: ${read.reason}`);
+    parts.set(relsName, read.part);
+  }
+  const contentTypes = {
+    defaults: new Map(doc.getMap("ctDefaults")),
+    overrides: new Map(doc.getMap("ctOverrides"))
+  };
+  return {
+    parts,
+    partBytes,
+    relationships,
+    externalTargets,
+    contentTypes,
+    mainDocumentPart: main
+  };
+}
+function materializeBytes(doc) {
+  return writeOoxmlPackage(materialize(doc));
+}
+function bootstrapFromBytes(doc, bytes) {
+  const result = readOoxmlPackage(bytes);
+  if (!result.ok) throw new MaterializeError(`not a readable DOCX: ${result.reason}`);
+  bootstrap(doc, result.package);
+  return result.package;
+}
+
+export { COLLAB_FORMAT, MaterializeCache, MaterializeError, bootstrap, bootstrapFromBytes, contentTypeOf, encodeElement, encodeText, isBootstrapped, materialize, materializeBytes, readFormat, registerMirror, serializePart };
+//# sourceMappingURL=encoding.js.map
+//# sourceMappingURL=encoding.js.map