@portone/docx-editor 0.1.0

package/dist/docx/formatting/styles.js

@@ -0,0 +1,165 @@
+// src/docx/formatting/styles.ts
+import {
+  toParagraphFormat,
+  toRunFormat,
+  toTableFormat
+} from "../../model/format.js";
+import { childValue, isOn, wAttr } from "../../ooxml/units.js";
+import { childByLocalName, elementChildren } from "../../ooxml/xml.js";
+import { parsePropsXml } from "../propsXml.js";
+import {
+  layerCellMargins,
+  layerInsideBorders,
+  NO_CELL_MARGINS,
+  NO_INSIDE_BORDERS,
+  readCellMarginsOf,
+  readInsideBorders,
+  readTableFormat
+} from "../tableFormatting.js";
+import { NO_THEME_FONTS } from "../theme.js";
+import { readParagraphFormat, readRunFormat } from "./direct.js";
+import { layerParagraphValues } from "./tabStops.js";
+var NO_STYLES = /* @__PURE__ */ new Map();
+function styleChain(id, sources) {
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = id;
+  while (current !== null && !seen.has(current)) {
+    seen.add(current);
+    const source = sources.get(current);
+    if (!source) break;
+    chain.unshift(source);
+    current = source.basedOn;
+  }
+  return chain;
+}
+var EMPTY_STYLE_FORMAT = {
+  paragraph: {},
+  run: {},
+  table: {},
+  tableInside: NO_INSIDE_BORDERS,
+  tableCellMargins: NO_CELL_MARGINS
+};
+function readStyleFormat(source, themeFonts) {
+  return {
+    paragraph: readParagraphFormat(source.pPr) ?? {},
+    run: readRunFormat(source.rPr, themeFonts) ?? {},
+    table: readTableFormat(source.tblPr) ?? {},
+    tableInside: readInsideBorders(source.tblPr),
+    tableCellMargins: readCellMarginsOf(source.tblPr, "tblCellMar")
+  };
+}
+function layerStyleFormat(base, over) {
+  return {
+    paragraph: layerParagraphValues(base.paragraph, over.paragraph),
+    run: { ...base.run, ...over.run },
+    table: { ...base.table, ...over.table },
+    tableInside: layerInsideBorders(base.tableInside, over.tableInside),
+    tableCellMargins: layerCellMargins(
+      base.tableCellMargins,
+      over.tableCellMargins
+    )
+  };
+}
+function foldChain(chain, themeFonts) {
+  return chain.map((source) => readStyleFormat(source, themeFonts)).reduce(layerStyleFormat, EMPTY_STYLE_FORMAT);
+}
+function readStyles(styles, themeFonts = NO_THEME_FONTS) {
+  const sources = /* @__PURE__ */ new Map();
+  for (const el of elementChildren(styles.documentElement)) {
+    if (el.localName !== "style") continue;
+    const id = wAttr(el, "styleId");
+    if (id === null || id.length === 0) continue;
+    sources.set(id, {
+      basedOn: childValue(el, "basedOn"),
+      pPr: childByLocalName(el, "pPr"),
+      rPr: childByLocalName(el, "rPr"),
+      tblPr: childByLocalName(el, "tblPr")
+    });
+  }
+  const table = /* @__PURE__ */ new Map();
+  for (const id of sources.keys()) {
+    table.set(id, foldChain(styleChain(id, sources), themeFonts));
+  }
+  return table;
+}
+function isDefaultStyle(el) {
+  const value = wAttr(el, "default");
+  return value === "1" || value === "true";
+}
+function defaultStyleIdOf(styles, type) {
+  let found = null;
+  for (const el of elementChildren(styles.documentElement)) {
+    if (el.localName !== "style" || wAttr(el, "type") !== type) continue;
+    if (!isDefaultStyle(el)) continue;
+    const id = wAttr(el, "styleId");
+    if (id !== null && id.length > 0) found = id;
+  }
+  return found;
+}
+function defaultTableStyleIdOf(styles) {
+  return defaultStyleIdOf(styles, "table");
+}
+function defaultParagraphStyleIdOf(styles) {
+  return defaultStyleIdOf(styles, "paragraph");
+}
+function readParagraphStyles(styles) {
+  const defaultId = defaultParagraphStyleIdOf(styles);
+  const options = [];
+  for (const el of elementChildren(styles.documentElement)) {
+    if (el.localName !== "style" || wAttr(el, "type") !== "paragraph") continue;
+    const id = wAttr(el, "styleId");
+    if (id === null || id.length === 0) continue;
+    const name = childValue(el, "name");
+    options.push({
+      id,
+      name: name === null || name.length === 0 ? id : name,
+      isDefault: id === defaultId,
+      primary: isOn(el, "qFormat"),
+      hidden: isOn(el, "semiHidden") || isOn(el, "hidden")
+    });
+  }
+  return options;
+}
+var styleIdsByPPr = /* @__PURE__ */ new Map();
+var STYLE_ID_CACHE_LIMIT = 2e3;
+function styleIdOf(pPr) {
+  if (typeof pPr !== "string" || !pPr.includes("pStyle")) return null;
+  const known = styleIdsByPPr.get(pPr);
+  if (known !== void 0) return known;
+  const el = parsePropsXml(pPr);
+  const id = el ? childValue(el, "pStyle") : null;
+  if (styleIdsByPPr.size >= STYLE_ID_CACHE_LIMIT) styleIdsByPPr.clear();
+  styleIdsByPPr.set(pPr, id);
+  return id;
+}
+function paragraphStyleFormat(pPr, styles, defaultStyleId = null) {
+  const id = styleIdOf(pPr) ?? defaultStyleId;
+  return id === null ? void 0 : styles.get(id);
+}
+function layered(style, direct) {
+  if (direct === null && Object.keys(style).length === 0) return null;
+  return { ...style, ...direct };
+}
+function layerParagraphFormat(style, direct) {
+  if (direct === null && Object.keys(style).length === 0) return null;
+  return toParagraphFormat(layerParagraphValues(style, direct ?? {}));
+}
+function layerRunFormat(style, direct) {
+  return toRunFormat(layered(style, direct));
+}
+function layerTableFormat(style, direct) {
+  return toTableFormat(layered(style, direct));
+}
+export {
+  NO_STYLES,
+  defaultParagraphStyleIdOf,
+  defaultTableStyleIdOf,
+  layerParagraphFormat,
+  layerRunFormat,
+  layerTableFormat,
+  paragraphStyleFormat,
+  readParagraphStyles,
+  readStyles,
+  styleIdOf
+};

package/dist/docx/formatting/tabStops.d.ts

@@ -0,0 +1,8 @@
+import { type ParagraphFormat } from "../../model/format";
+import { type TabStopDirective } from "../../model/tabStops";
+export type ParagraphFormatLayer = Omit<ParagraphFormat, "numbering" | "tabStops"> & {
+    numbering?: ParagraphFormat["numbering"] | null;
+    tabStops?: readonly TabStopDirective[];
+};
+export declare function toParagraphFormatLayer(value: unknown): ParagraphFormatLayer | null;
+export declare function layerParagraphValues(base: ParagraphFormatLayer, over: ParagraphFormatLayer): ParagraphFormatLayer;

package/dist/docx/formatting/tabStops.js

@@ -0,0 +1,65 @@
+// src/docx/formatting/tabStops.ts
+import { toParagraphFormat } from "../../model/format.js";
+import {
+  layerTabStopDirectives
+} from "../../model/tabStops.js";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var ALIGNMENTS = /* @__PURE__ */ new Set([
+  "start",
+  "center",
+  "end",
+  "decimal",
+  "num",
+  "bar",
+  "clear"
+]);
+var LEADERS = /* @__PURE__ */ new Set([
+  "none",
+  "dot",
+  "hyphen",
+  "underscore",
+  "heavy",
+  "middleDot"
+]);
+function toTabStopDirective(value) {
+  if (!isRecord(value) || typeof value.positionPt !== "number" || !Number.isFinite(value.positionPt) || typeof value.align !== "string" || !ALIGNMENTS.has(value.align)) {
+    return null;
+  }
+  if (value.align === "clear") {
+    return { positionPt: value.positionPt, align: "clear" };
+  }
+  const align = value.align;
+  const leader = typeof value.leader === "string" && LEADERS.has(value.leader) ? value.leader : void 0;
+  return {
+    positionPt: value.positionPt,
+    align,
+    ...leader === void 0 ? {} : { leader }
+  };
+}
+function toParagraphFormatLayer(value) {
+  if (!isRecord(value)) return null;
+  const format = toParagraphFormat(value) ?? {};
+  if (!Array.isArray(value.tabStops)) return format;
+  const tabStops = value.tabStops.flatMap((entry) => {
+    const stop = toTabStopDirective(entry);
+    return stop === null ? [] : [stop];
+  });
+  if (tabStops.length > 0) format.tabStops = tabStops;
+  return format;
+}
+function layerParagraphValues(base, over) {
+  const result = { ...base, ...over };
+  const tabStops = layerTabStopDirectives(
+    base.tabStops ?? [],
+    over.tabStops ?? []
+  );
+  if (tabStops.length > 0) result.tabStops = tabStops;
+  else delete result.tabStops;
+  return result;
+}
+export {
+  layerParagraphValues,
+  toParagraphFormatLayer
+};

package/dist/docx/formatting.d.ts

@@ -0,0 +1,4 @@
+export * from "./formatting/direct";
+export * from "./formatting/effectiveParagraph";
+export * from "./formatting/styles";
+export type { ParagraphFormatLayer } from "./formatting/tabStops";

package/dist/docx/formatting.js

@@ -0,0 +1,4 @@
+// src/docx/formatting.ts
+export * from "./formatting/direct.js";
+export * from "./formatting/effectiveParagraph.js";
+export * from "./formatting/styles.js";

package/dist/docx/headersFooters.d.ts

@@ -0,0 +1,36 @@
+/** Reads the first section's header and footer stories for the page preview. */
+import type { ParagraphAlign } from "../model/format";
+export type HeaderFooterVariant = "default" | "first" | "even";
+export type PageField = "PAGE" | "NUMPAGES";
+export type HeaderFooterSegment = {
+    kind: "text";
+    value: string;
+} | {
+    kind: "field";
+    field: PageField;
+};
+/** A display-only projection. The original part remains untouched in the package. */
+export interface HeaderFooterContent {
+    segments: readonly HeaderFooterSegment[];
+    align: ParagraphAlign | null;
+}
+export interface HeaderFooterVariants {
+    default: HeaderFooterContent | null;
+    first: HeaderFooterContent | null;
+    even: HeaderFooterContent | null;
+}
+export interface HeadersFooters {
+    headers: HeaderFooterVariants;
+    footers: HeaderFooterVariants;
+    firstPageDifferent: boolean;
+    evenAndOdd: boolean;
+    pageNumberStart: number;
+}
+export declare const NO_HEADERS_FOOTERS: HeadersFooters;
+/** Reads the first section's display stories and section-level selection switches. */
+export declare function readHeadersFooters(parts: Map<string, Uint8Array>, mainPartPath: string, body: Element): HeadersFooters;
+export declare function displayPageNumber(headersFooters: HeadersFooters, page: number): number;
+/** Resolves the section variant and evaluates PAGE and NUMPAGES for one visual page. */
+export declare function headerFooterText(variants: HeaderFooterVariants, headersFooters: HeadersFooters, page: number, totalPages: number): string | null;
+/** Resolves the direct alignment of the first paragraph in the selected story. */
+export declare function headerFooterAlign(variants: HeaderFooterVariants, headersFooters: HeadersFooters, page: number): ParagraphAlign | null;

package/dist/docx/headersFooters.js

@@ -0,0 +1,218 @@
+// src/docx/headersFooters.ts
+import { ALIGN_BY_JC } from "../ooxml/units.js";
+import {
+  decodeUtf8,
+  elementChildren,
+  parseXml,
+  R_NS,
+  W_NS
+} from "../ooxml/xml.js";
+import { readRelationships, relsPathOf, resolveTarget } from "./relationships.js";
+var EMPTY_VARIANTS = {
+  default: null,
+  first: null,
+  even: null
+};
+var NO_HEADERS_FOOTERS = {
+  headers: EMPTY_VARIANTS,
+  footers: EMPTY_VARIANTS,
+  firstPageDifferent: false,
+  evenAndOdd: false,
+  pageNumberStart: 1
+};
+function attribute(el, localName) {
+  return Array.from(el.attributes).find((entry) => entry.localName === localName)?.value ?? null;
+}
+function isOn(el) {
+  if (!el) return false;
+  const value = attribute(el, "val")?.toLowerCase();
+  return value !== "0" && value !== "false" && value !== "off";
+}
+function firstSectPrIn(root) {
+  const namespaced = root.getElementsByTagNameNS(W_NS, "sectPr").item(0);
+  if (namespaced) return namespaced;
+  for (const el of root.getElementsByTagName("*")) {
+    if (el.localName === "sectPr") return el;
+  }
+  return null;
+}
+function pageField(instruction) {
+  const name = instruction.trim().split(/\s+/, 1)[0]?.toUpperCase();
+  return name === "PAGE" || name === "NUMPAGES" ? name : null;
+}
+function paragraphSegments(paragraph) {
+  const segments = [];
+  const fields = [];
+  const suppressed = () => fields.some((field) => !field.separated || field.field !== null);
+  const text = (value) => {
+    if (!value || suppressed()) return;
+    const previous = segments.at(-1);
+    if (previous?.kind === "text") previous.value += value;
+    else segments.push({ kind: "text", value });
+  };
+  const dynamic = (field) => {
+    if (!suppressed()) segments.push({ kind: "field", field });
+  };
+  const visit = (el) => {
+    if (el.namespaceURI === W_NS && (el.localName === "drawing" || el.localName === "pict" || el.localName === "object" || el.localName === "tbl" || el.localName === "txbxContent")) {
+      return;
+    }
+    if (el.namespaceURI === W_NS && el.localName === "fldSimple") {
+      const field = pageField(attribute(el, "instr") ?? "");
+      if (field) dynamic(field);
+      else for (const child of elementChildren(el)) visit(child);
+      return;
+    }
+    if (el.namespaceURI === W_NS && el.localName === "fldChar") {
+      const kind = attribute(el, "fldCharType");
+      if (kind === "begin") {
+        fields.push({ instruction: "", separated: false, field: null });
+      } else if (kind === "separate") {
+        const active = fields.at(-1);
+        if (active) {
+          active.field = pageField(active.instruction);
+          active.separated = true;
+          if (active.field) {
+            const outerSuppresses = fields.slice(0, -1).some((field) => !field.separated || field.field !== null);
+            if (!outerSuppresses) {
+              segments.push({ kind: "field", field: active.field });
+            }
+          }
+        }
+      } else if (kind === "end") {
+        const active = fields.pop();
+        if (active && !active.separated) {
+          const field = pageField(active.instruction);
+          if (field) dynamic(field);
+        }
+      }
+      return;
+    }
+    if (el.namespaceURI === W_NS && el.localName === "instrText") {
+      const active = fields.at(-1);
+      if (active && !active.separated)
+        active.instruction += el.textContent ?? "";
+      return;
+    }
+    if (el.namespaceURI === W_NS && el.localName === "t") {
+      text(el.textContent ?? "");
+      return;
+    }
+    if (el.namespaceURI === W_NS && el.localName === "tab") {
+      text("	");
+      return;
+    }
+    if (el.namespaceURI === W_NS && (el.localName === "br" || el.localName === "cr")) {
+      text("\n");
+      return;
+    }
+    for (const child of elementChildren(el)) visit(child);
+  };
+  for (const child of elementChildren(paragraph)) visit(child);
+  return segments;
+}
+function readContent(bytes) {
+  const root = parseXml(decodeUtf8(bytes).text).documentElement;
+  const paragraphs = elementChildren(root).filter(
+    (child) => child.namespaceURI === W_NS && child.localName === "p"
+  );
+  const segments = [];
+  paragraphs.forEach((paragraph, index) => {
+    if (index > 0) segments.push({ kind: "text", value: "\n" });
+    segments.push(...paragraphSegments(paragraph));
+  });
+  const pPr = paragraphs[0] ? elementChildren(paragraphs[0]).find(
+    (child) => child.namespaceURI === W_NS && child.localName === "pPr"
+  ) : void 0;
+  const jc = pPr ? elementChildren(pPr).find(
+    (child) => child.namespaceURI === W_NS && child.localName === "jc"
+  ) : void 0;
+  return {
+    segments,
+    align: jc ? ALIGN_BY_JC[attribute(jc, "val") ?? ""] ?? null : null
+  };
+}
+function settingsEvenAndOdd(parts, mainPartPath) {
+  const relationship = readRelationships(parts, relsPathOf(mainPartPath)).find(
+    (entry) => entry.type === `${R_NS}/settings` && !entry.external
+  );
+  if (!relationship) return false;
+  const bytes = parts.get(resolveTarget(mainPartPath, relationship.target));
+  if (!bytes) return false;
+  const root = parseXml(decodeUtf8(bytes).text).documentElement;
+  const setting = root.getElementsByTagNameNS(W_NS, "evenAndOddHeaders").item(0);
+  return isOn(setting);
+}
+function readVariants(parts, mainPartPath, sectPr, kind) {
+  const relationships = new Map(
+    readRelationships(parts, relsPathOf(mainPartPath)).map((entry) => [
+      entry.id,
+      entry
+    ])
+  );
+  const variants = { ...EMPTY_VARIANTS };
+  for (const reference of elementChildren(sectPr)) {
+    if (reference.localName !== `${kind}Reference`) continue;
+    const type = attribute(reference, "type") ?? "default";
+    if (type !== "default" && type !== "first" && type !== "even") continue;
+    const id = reference.getAttributeNS(R_NS, "id") ?? attribute(reference, "id");
+    if (!id) continue;
+    const relationship = relationships.get(id);
+    if (!relationship || relationship.external || relationship.type !== `${R_NS}/${kind}`) {
+      continue;
+    }
+    const bytes = parts.get(resolveTarget(mainPartPath, relationship.target));
+    if (bytes) variants[type] = readContent(bytes);
+  }
+  return variants;
+}
+function pageNumberStart(sectPr) {
+  const pgNumType = elementChildren(sectPr).find(
+    (child) => child.localName === "pgNumType"
+  );
+  const declared = pgNumType ? attribute(pgNumType, "start") : null;
+  if (declared === null) return 1;
+  const start = Number(declared);
+  return Number.isSafeInteger(start) && start >= 0 ? start : 1;
+}
+function readHeadersFooters(parts, mainPartPath, body) {
+  const sectPr = firstSectPrIn(body);
+  if (!sectPr) return NO_HEADERS_FOOTERS;
+  return {
+    headers: readVariants(parts, mainPartPath, sectPr, "header"),
+    footers: readVariants(parts, mainPartPath, sectPr, "footer"),
+    firstPageDifferent: isOn(
+      elementChildren(sectPr).find((child) => child.localName === "titlePg") ?? null
+    ),
+    evenAndOdd: settingsEvenAndOdd(parts, mainPartPath),
+    pageNumberStart: pageNumberStart(sectPr)
+  };
+}
+function displayPageNumber(headersFooters, page) {
+  return headersFooters.pageNumberStart + page - 1;
+}
+function contentForPage(variants, headersFooters, page) {
+  if (page === 1 && headersFooters.firstPageDifferent) return variants.first;
+  if (headersFooters.evenAndOdd && displayPageNumber(headersFooters, page) % 2 === 0) {
+    return variants.even;
+  }
+  return variants.default;
+}
+function headerFooterText(variants, headersFooters, page, totalPages) {
+  const content = contentForPage(variants, headersFooters, page);
+  if (!content) return null;
+  return content.segments.map((segment) => {
+    if (segment.kind === "text") return segment.value;
+    return segment.field === "PAGE" ? `${displayPageNumber(headersFooters, page)}` : `${totalPages}`;
+  }).join("");
+}
+function headerFooterAlign(variants, headersFooters, page) {
+  return contentForPage(variants, headersFooters, page)?.align ?? null;
+}
+export {
+  NO_HEADERS_FOOTERS,
+  displayPageNumber,
+  headerFooterAlign,
+  headerFooterText,
+  readHeadersFooters
+};

package/dist/docx/hyperlink.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Hyperlinks (`w:hyperlink`, §17.16.22): the wrapper a document brought in, and the relationship a
+ * link's address lives on. `spec/notes/hyperlinks.md` has what the specification settles.
+ *
+ * A link names its target one of two ways. `r:id` points at a relationship whose target is the
+ * address, so the address of an external link is never in the body at all; `w:anchor` names a
+ * bookmark, which this editor does not model and therefore never reads.
+ *
+ * The wrapper travels as the verbatim opening tag, the way a content control's does (`docx/sdt`),
+ * so `w:tooltip`, `w:history`, `w:docLocation` and anything else we never read go back out
+ * untouched.
+ */
+import { type RelationshipWriter } from "./relationships";
+export interface HyperlinkWrapper {
+    /** The `<w:hyperlink>` opening tag as it came */
+    prefix: string;
+    /** The relationship its address lives on. null for a link that names a bookmark alone */
+    relId: string | null;
+}
+/**
+ * Takes a `w:hyperlink` apart into the wrapper to put back on export. null for a shape we do not
+ * write ourselves, which leaves whatever held the link preserved as its own fragment.
+ *
+ * The `w:` prefix on the tag is one we write, and `r:id` is an attribute a retargeted link has
+ * rewritten by name, so a document that binds either namespace to another prefix is left alone
+ * rather than written back under ours.
+ */
+export declare function readHyperlinkWrapper(el: Element): HyperlinkWrapper | null;
+/** The address of every external link the body can point at, keyed by relationship id */
+export type LinkTargets = ReadonlyMap<string, string>;
+export declare const NO_LINK_TARGETS: LinkTargets;
+/**
+ * Every address the body has a hyperlink relationship to.
+ *
+ * A relationship of another type, or one whose target is a part inside the package rather than an
+ * address outside it, is left out: the link that points at it keeps its wrapper and offers no
+ * address, the same as a link naming a bookmark.
+ */
+export declare function readLinkTargets(parts: Map<string, Uint8Array>, mainPartPath: string): LinkTargets;
+/** The relationship id this opening tag names, null when it names none */
+export declare function relIdIn(prefix: string): string | null;
+/**
+ * The same opening tag pointing at this relationship. `<w:hyperlink>` on its own is what a link
+ * made in the editor starts from.
+ *
+ * A tag that already names one has only that value rewritten, so a link nobody retargeted comes
+ * out as the very string it went in as. A tag that named none is given the attribute, which the
+ * specification has supersede any `w:anchor` beside it, along with the namespace it lives in: the
+ * body we write into is not always one that declares it, and declaring it again where it is
+ * already bound to the same namespace changes nothing.
+ */
+export declare function withRelId(prefix: string, relId: string): string;
+/** Which relationship each address goes out on while the body is being written */
+export interface LinkRefs {
+    /**
+     * The relationship the link at this address points at. `was` is the id the link came in on,
+     * which is kept where it still leads to that same address.
+     * undefined where there is no relationships part to add to, which is a serializer running
+     * outside an export.
+     */
+    relIdOf(href: string, was: string | null): string | undefined;
+}
+/** What a serializer called on its own, outside an export, has to work with */
+export declare const NO_LINK_REFS: LinkRefs;
+/**
+ * Hands out the relationship for every address the body points at, adding one where the package
+ * has none.
+ *
+ * Nothing is planned ahead: an address is asked for as its link is written, and the relationships
+ * part is built once the body is (`docx/exportDocx`).
+ * An address already in the package is pointed at again rather than written twice, and the
+ * relationship a link arrived on is kept wherever it still leads where the link now goes, so
+ * retargeting one link in a document leaves every other link's XML alone.
+ */
+export declare function hyperlinkRefs(relationships: RelationshipWriter): LinkRefs;

package/dist/docx/hyperlink.js

@@ -0,0 +1,71 @@
+// src/docx/hyperlink.ts
+import { attrString, R_NS } from "../ooxml/xml.js";
+import {
+  readRelationships,
+  relsPathOf
+} from "./relationships.js";
+var HYPERLINK_REL_TYPE = `${R_NS}/hyperlink`;
+var REL_ID_ATTR = "r:id";
+var REL_ID_VALUE = /\sr:id="([^"]*)"/;
+function readHyperlinkWrapper(el) {
+  if (el.nodeName !== "w:hyperlink") return null;
+  const relId = el.getAttributeNS(R_NS, "id");
+  if (relId !== null && !el.hasAttribute(REL_ID_ATTR)) return null;
+  const attrs = attrString(el);
+  return {
+    prefix: attrs ? `<w:hyperlink ${attrs}>` : "<w:hyperlink>",
+    relId
+  };
+}
+var NO_LINK_TARGETS = /* @__PURE__ */ new Map();
+function readLinkTargets(parts, mainPartPath) {
+  const targets = /* @__PURE__ */ new Map();
+  for (const rel of readRelationships(parts, relsPathOf(mainPartPath))) {
+    if (rel.type !== HYPERLINK_REL_TYPE || !rel.external) continue;
+    targets.set(rel.id, rel.target);
+  }
+  return targets;
+}
+function relIdIn(prefix) {
+  return REL_ID_VALUE.exec(prefix)?.[1] ?? null;
+}
+function withRelId(prefix, relId) {
+  if (REL_ID_VALUE.test(prefix)) {
+    return prefix.replace(REL_ID_VALUE, ` ${REL_ID_ATTR}="${relId}"`);
+  }
+  const name = "<w:hyperlink";
+  return `${name} xmlns:r="${R_NS}" ${REL_ID_ATTR}="${relId}"${prefix.slice(name.length)}`;
+}
+var NO_LINK_REFS = { relIdOf: () => void 0 };
+function hyperlinkRefs(relationships) {
+  const external = relationships.opened.filter(
+    (rel) => rel.type === HYPERLINK_REL_TYPE && rel.external
+  );
+  const added = /* @__PURE__ */ new Map();
+  return {
+    relIdOf: (href, was) => {
+      const kept = external.find((rel) => rel.id === was);
+      if (kept?.target === href) return was ?? void 0;
+      const found = external.find((rel) => rel.target === href);
+      if (found) return found.id;
+      const already = added.get(href);
+      if (already !== void 0) return already;
+      const id = relationships.add({
+        type: HYPERLINK_REL_TYPE,
+        target: href,
+        external: true
+      });
+      added.set(href, id);
+      return id;
+    }
+  };
+}
+export {
+  NO_LINK_REFS,
+  NO_LINK_TARGETS,
+  hyperlinkRefs,
+  readHyperlinkWrapper,
+  readLinkTargets,
+  relIdIn,
+  withRelId
+};

package/dist/docx/importDocx.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Reads docx bytes and builds the document to edit plus the store holding the original.
+ *
+ * This module knows nothing about the screen. All it knows is the file and the document model.
+ */
+import { type Node as PMNode } from "prosemirror-model";
+import { SessionStore } from "./session";
+/** A docx file as bytes, however it arrived (file input, fetch, filesystem) */
+export type DocxBytes = ArrayBuffer | Uint8Array;
+/**
+ * A docx file however a consumer holds it: the bytes, or the `File`/`Blob` a file
+ * input or a fetch hands over.
+ *
+ * Reading a `Blob` is asynchronous, so only the React component takes one; the
+ * engine on `./core` stays synchronous and bytes-only.
+ */
+export type DocxSource = DocxBytes | Blob;
+export declare function importDocx(input: DocxBytes): {
+    doc: PMNode;
+    session: SessionStore;
+};