@sofereditor/import-docx 0.1.0

package/dist/index.cjs

@@ -0,0 +1,665 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  docxBlobToDocument: () => docxBlobToDocument,
+  docxBlobToEditorDocument: () => docxBlobToEditorDocument
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/docx.ts
+var import_core2 = require("@sofereditor/core");
+
+// src/parse-xml.ts
+var import_jszip = __toESM(require("jszip"), 1);
+var import_fast_xml_parser = require("fast-xml-parser");
+var parser = new import_fast_xml_parser.XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  preserveOrder: true,
+  trimValues: false,
+  // keep whitespace inside <w:t>
+  parseAttributeValue: false,
+  parseTagValue: false
+});
+async function readDocx(input) {
+  const data = input instanceof Uint8Array ? input : input instanceof ArrayBuffer ? new Uint8Array(input) : new Uint8Array(await input.arrayBuffer());
+  const zip = await import_jszip.default.loadAsync(data);
+  const documentXml = await readXml(zip, "word/document.xml");
+  if (!documentXml) throw new Error("Invalid .docx: missing word/document.xml");
+  const numberingXml = await readXml(zip, "word/numbering.xml");
+  const relsXml = await readXml(zip, "word/_rels/document.xml.rels");
+  const relationships = parseRelationships(relsXml);
+  const mediaBytes = /* @__PURE__ */ new Map();
+  const mediaFolder = zip.folder("word/media");
+  if (mediaFolder) {
+    const promises = [];
+    mediaFolder.forEach((relativePath, file) => {
+      if (file.dir) return;
+      promises.push(
+        file.async("uint8array").then((bytes) => {
+          mediaBytes.set(`media/${relativePath}`, bytes);
+        })
+      );
+    });
+    await Promise.all(promises);
+  }
+  return { documentXml, numberingXml, relationships, mediaBytes };
+}
+async function readXml(zip, path) {
+  const entry = zip.file(path);
+  if (!entry) return void 0;
+  const text = await entry.async("string");
+  return parser.parse(text);
+}
+function parseRelationships(nodes) {
+  const out = /* @__PURE__ */ new Map();
+  if (!nodes) return out;
+  for (const top of nodes) {
+    const children = top["Relationships"];
+    if (!Array.isArray(children)) continue;
+    for (const child of children) {
+      if (!("Relationship" in child)) continue;
+      const attrs = child[":@"] ?? {};
+      const id = attrs["@_Id"];
+      const target = attrs["@_Target"];
+      if (typeof id === "string" && typeof target === "string") {
+        out.set(id, target);
+      }
+    }
+  }
+  return out;
+}
+function tagOf(node) {
+  for (const key of Object.keys(node)) {
+    if (key === ":@") continue;
+    return key;
+  }
+  return null;
+}
+function childrenOf(node) {
+  const tag = tagOf(node);
+  if (!tag) return [];
+  const v = node[tag];
+  return Array.isArray(v) ? v : [];
+}
+function attrsOf(node) {
+  return node[":@"] ?? {} ?? {};
+}
+function attr(node, key) {
+  const v = attrsOf(node)[`@_${key}`];
+  return typeof v === "string" ? v : void 0;
+}
+function findChild(node, tag) {
+  for (const child of childrenOf(node)) {
+    if (tagOf(child) === tag) return child;
+  }
+  return void 0;
+}
+function findChildren(node, tag) {
+  const out = [];
+  for (const child of childrenOf(node)) {
+    if (tagOf(child) === tag) out.push(child);
+  }
+  return out;
+}
+
+// src/units.ts
+function halfPointsToCssPt(halfPoints) {
+  if (!Number.isFinite(halfPoints) || halfPoints <= 0) return void 0;
+  const pt = halfPoints / 2;
+  return `${stripTrailingZeros(pt)}pt`;
+}
+function docxHexToCssColor(hex) {
+  if (!hex) return void 0;
+  const m = /^[0-9a-f]{6}$/i.exec(hex.trim());
+  if (!m) return void 0;
+  return `#${hex.toLowerCase()}`;
+}
+function parseAlign(val) {
+  if (!val) return void 0;
+  switch (val.toLowerCase()) {
+    case "left":
+    case "start":
+      return "left";
+    case "center":
+      return "center";
+    case "right":
+    case "end":
+      return "right";
+    case "both":
+    case "distribute":
+    case "justify":
+      return "justify";
+    default:
+      return void 0;
+  }
+}
+function parseIntAttr(val, fallback = 0) {
+  if (typeof val === "number" && Number.isFinite(val)) return Math.trunc(val);
+  if (typeof val !== "string") return fallback;
+  const n = Number.parseInt(val, 10);
+  return Number.isFinite(n) ? n : fallback;
+}
+function stripTrailingZeros(n) {
+  return Number.isInteger(n) ? n.toString() : n.toFixed(2).replace(/\.?0+$/, "");
+}
+
+// src/images.ts
+var EMU_PER_PX = 9525;
+var MIME_BY_EXT = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  bmp: "image/bmp",
+  svg: "image/svg+xml"
+};
+function extractImageFromDrawing(drawing, ctx) {
+  let embedId;
+  let cx;
+  let cy;
+  walk(drawing, (n) => {
+    const tag = tagOf(n);
+    if (!tag) return;
+    if (tag === "a:blip") {
+      const id = attr(n, "r:embed") ?? attr(n, "r:link");
+      if (id) embedId = id;
+    } else if (tag === "wp:extent") {
+      cx = parseIntAttr(attr(n, "cx"));
+      cy = parseIntAttr(attr(n, "cy"));
+    }
+  });
+  if (!embedId) return null;
+  const target = ctx.relationships.get(embedId);
+  if (!target) return null;
+  const bytes = ctx.mediaBytes.get(target);
+  if (!bytes) return null;
+  const ext = extensionOf(target);
+  const mime = MIME_BY_EXT[ext] ?? "image/png";
+  const src = `data:${mime};base64,${bytesToBase64(bytes)}`;
+  const widthPx = cx != null ? Math.max(1, Math.round(cx / EMU_PER_PX)) : 100;
+  const heightPx = cy != null ? Math.max(1, Math.round(cy / EMU_PER_PX)) : 100;
+  return { type: "image", src, width: widthPx, height: heightPx };
+}
+function walk(node, visit) {
+  visit(node);
+  for (const child of childrenOf(node)) {
+    if ("#text" in child) continue;
+    walk(child, visit);
+  }
+}
+function extensionOf(path) {
+  const m = /\.([a-z0-9]+)$/i.exec(path);
+  return m ? m[1].toLowerCase() : "";
+}
+function bytesToBase64(bytes) {
+  if (typeof btoa === "function") {
+    let bin = "";
+    const CHUNK = 32768;
+    for (let i = 0; i < bytes.length; i += CHUNK) {
+      bin += String.fromCharCode.apply(null, Array.from(bytes.subarray(i, i + CHUNK)));
+    }
+    return btoa(bin);
+  }
+  return Buffer.from(bytes).toString("base64");
+}
+
+// src/runs.ts
+function paragraphChildrenToDelta(children, ctx) {
+  const ops = [];
+  for (const child of children) {
+    const tag = tagOf(child);
+    if (!tag) continue;
+    if (tag === "w:pPr") continue;
+    if (tag === "w:r") {
+      collectRun(child, ctx, void 0, ops);
+    } else if (tag === "w:hyperlink") {
+      const rId = attr(child, "r:id");
+      const href = rId ? ctx.relationships.get(rId) : void 0;
+      const linkMark = href ? { link: { href } } : void 0;
+      for (const sub of childrenOf(child)) {
+        if (tagOf(sub) === "w:r") collectRun(sub, ctx, linkMark, ops);
+      }
+    }
+  }
+  return mergeAdjacent(ops);
+}
+function collectRun(run, ctx, wrappingMarks, out) {
+  const marks = mergeMarks(wrappingMarks, runMarks(findChild(run, "w:rPr")));
+  for (const child of childrenOf(run)) {
+    const tag = tagOf(child);
+    if (!tag) continue;
+    if (tag === "w:t") {
+      const text = textContent(child);
+      if (text.length > 0) push(out, text, marks);
+    } else if (tag === "w:tab") {
+      push(out, "	", marks);
+    } else if (tag === "w:br") {
+      push(out, "\n", marks);
+    } else if (tag === "w:drawing") {
+      const embed = extractImageFromDrawing(child, ctx);
+      if (embed) out.push({ insert: embed });
+    }
+  }
+}
+function runMarks(rPr) {
+  const m = {};
+  if (!rPr) return m;
+  for (const child of childrenOf(rPr)) {
+    const tag = tagOf(child);
+    if (!tag) continue;
+    switch (tag) {
+      case "w:b":
+        if (!isFalse(attr(child, "w:val"))) m.bold = true;
+        break;
+      case "w:i":
+        if (!isFalse(attr(child, "w:val"))) m.italic = true;
+        break;
+      case "w:u": {
+        const val = attr(child, "w:val");
+        if (val && val.toLowerCase() !== "none") m.underline = true;
+        break;
+      }
+      case "w:strike":
+        if (!isFalse(attr(child, "w:val"))) m.strike = true;
+        break;
+      case "w:color": {
+        const hex = attr(child, "w:val");
+        const css = docxHexToCssColor(hex);
+        if (css) m.color = css;
+        break;
+      }
+      // w:rFonts intentionally ignored: school standard is Arial for all
+      // exams. Any font declared in the .docx is dropped on import so the
+      // imported doc inherits Arial from `.ed-root` / PDF base stylesheet.
+      case "w:sz": {
+        const halfPts = Number.parseFloat(attr(child, "w:val") ?? "");
+        const css = halfPointsToCssPt(halfPts);
+        if (css) m.fontSize = css;
+        break;
+      }
+    }
+  }
+  return m;
+}
+function mergeMarks(a, b) {
+  if (!a) return b;
+  return { ...a, ...b };
+}
+function textContent(node) {
+  let out = "";
+  for (const child of childrenOf(node)) {
+    if ("#text" in child) {
+      const t = child["#text"];
+      if (typeof t === "string") out += t;
+    }
+  }
+  return out;
+}
+function isFalse(val) {
+  if (val == null) return false;
+  const v = val.toLowerCase();
+  return v === "0" || v === "false" || v === "none";
+}
+function push(out, text, marks) {
+  const op = Object.keys(marks).length === 0 ? { insert: text } : { insert: text, attributes: { ...marks } };
+  out.push(op);
+}
+function mergeAdjacent(ops) {
+  const out = [];
+  for (const op of ops) {
+    const prev = out[out.length - 1];
+    if (prev && typeof prev.insert === "string" && typeof op.insert === "string" && sameMarks(prev.attributes, op.attributes)) {
+      prev.insert = prev.insert + op.insert;
+      continue;
+    }
+    out.push(op);
+  }
+  return out;
+}
+function sameMarks(a, b) {
+  const ak = a ? Object.keys(a).sort() : [];
+  const bk = b ? Object.keys(b).sort() : [];
+  if (ak.length !== bk.length) return false;
+  for (let i = 0; i < ak.length; i++) {
+    if (ak[i] !== bk[i]) return false;
+    const av = a[ak[i]];
+    const bv = b[bk[i]];
+    if (typeof av === "object" && av !== null && typeof bv === "object" && bv !== null) {
+      if (JSON.stringify(av) !== JSON.stringify(bv)) return false;
+    } else if (av !== bv) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/paragraphs.ts
+function paragraphToBlock(p, ctx, numbering) {
+  const pPr = findChild(p, "w:pPr");
+  const numPr = pPr ? findChild(pPr, "w:numPr") : void 0;
+  const styleId = pPr ? attr(findChild(pPr, "w:pStyle") ?? {}, "w:val") : void 0;
+  const delta = paragraphChildrenToDelta(childrenOf(p), ctx);
+  const text = collectText(delta);
+  const align = parseAlign(pPr ? attr(findChild(pPr, "w:jc") ?? {}, "w:val") : void 0);
+  const isRtl = pPr ? !!findChild(pPr, "w:bidi") : false;
+  if (numPr) {
+    const resolved = numbering.resolve(numPr);
+    const attrs2 = {
+      listKind: resolved?.listKind ?? "bullet",
+      listLevel: resolved?.listLevel ?? 0
+    };
+    if (align) attrs2.align = align;
+    if (isRtl) attrs2.dir = "rtl";
+    return { type: "listItem", text, delta, attrs: attrs2 };
+  }
+  const headingLevel = styleId ? headingFromStyleId(styleId) : null;
+  if (headingLevel != null) {
+    const attrs2 = { level: headingLevel };
+    if (align) attrs2.align = align;
+    if (isRtl) attrs2.dir = "rtl";
+    return { type: "heading", text, delta, attrs: attrs2 };
+  }
+  if (pPr && hasLeftBorder(pPr)) {
+    const attrs2 = {};
+    if (align) attrs2.align = align;
+    if (isRtl) attrs2.dir = "rtl";
+    return { type: "blockquote", text, delta, attrs: attrs2 };
+  }
+  if (pPr && hasCodeBlockShading(pPr)) {
+    const attrs2 = {};
+    if (align) attrs2.align = align;
+    if (isRtl) attrs2.dir = "rtl";
+    return { type: "codeBlock", text, delta, attrs: attrs2 };
+  }
+  const attrs = {};
+  if (align) attrs.align = align;
+  if (isRtl) attrs.dir = "rtl";
+  return { type: "paragraph", text, delta, attrs };
+}
+function collectText(delta) {
+  let out = "";
+  for (const op of delta) {
+    if (typeof op.insert === "string") out += op.insert;
+  }
+  return out;
+}
+function headingFromStyleId(id) {
+  const m = /^Heading\s*([1-6])$/i.exec(id);
+  if (!m) return null;
+  const n = Number.parseInt(m[1], 10);
+  return n ?? null;
+}
+function hasLeftBorder(pPr) {
+  const pBdr = findChild(pPr, "w:pBdr");
+  if (!pBdr) return false;
+  return !!findChild(pBdr, "w:left");
+}
+function hasCodeBlockShading(pPr) {
+  const shd = findChild(pPr, "w:shd");
+  if (!shd) return false;
+  const fill = attr(shd, "w:fill");
+  if (!fill) return false;
+  return fill.toLowerCase() === "f1f5f9";
+}
+
+// src/tables.ts
+function tableToBlock(tbl, ctx) {
+  const tblGrid = findChild(tbl, "w:tblGrid");
+  const gridCols = tblGrid ? findChildren(tblGrid, "w:gridCol") : [];
+  const trs = findChildren(tbl, "w:tr");
+  let cols = gridCols.length;
+  for (const tr of trs) {
+    const tcs = findChildren(tr, "w:tc");
+    let count = 0;
+    for (const tc of tcs) count += gridSpanOf(tc);
+    if (count > cols) cols = count;
+  }
+  if (cols < 1) cols = 1;
+  const rows = trs.length;
+  const slots = new Array(rows * cols).fill(null);
+  const vMergeAnchorByCol = /* @__PURE__ */ new Map();
+  for (let r = 0; r < rows; r++) {
+    const tr = trs[r];
+    let cursor = 0;
+    for (const tc of findChildren(tr, "w:tc")) {
+      while (cursor < cols && slots[r * cols + cursor] !== null) cursor++;
+      if (cursor >= cols) break;
+      const tcPr = findChild(tc, "w:tcPr");
+      const gridSpan = gridSpanOf(tc);
+      const vMergeNode = tcPr ? findChild(tcPr, "w:vMerge") : void 0;
+      const vMergeVal = vMergeNode ? attr(vMergeNode, "w:val") ?? "continue" : null;
+      if (vMergeNode && vMergeVal !== "restart") {
+        const anchor = vMergeAnchorByCol.get(cursor);
+        if (anchor) {
+          const anchorIdx = anchor.row * cols + anchor.col;
+          const a = slots[anchorIdx];
+          if (a) {
+            a.attrs = { ...a.attrs ?? {}, rowspan: (a.attrs?.rowspan ?? 1) + 1 };
+          }
+        }
+        for (let c = 0; c < gridSpan && cursor + c < cols; c++) {
+          slots[r * cols + cursor + c] = coveredCell();
+        }
+        cursor += gridSpan;
+        continue;
+      }
+      const delta = cellChildrenToDelta(tc, ctx);
+      const text = textOfDelta(delta);
+      const cellAttrs = {};
+      if (gridSpan > 1) cellAttrs.colspan = gridSpan;
+      const realCell = { text, delta, attrs: cellAttrs };
+      slots[r * cols + cursor] = realCell;
+      for (let c = 1; c < gridSpan && cursor + c < cols; c++) {
+        slots[r * cols + cursor + c] = coveredCell();
+      }
+      if (vMergeVal === "restart") {
+        vMergeAnchorByCol.set(cursor, { row: r, col: cursor });
+      } else {
+        vMergeAnchorByCol.delete(cursor);
+      }
+      cursor += gridSpan;
+    }
+    for (let c = 0; c < cols; c++) {
+      if (slots[r * cols + c] === null) {
+        slots[r * cols + c] = emptyCell();
+      }
+    }
+  }
+  const cells = slots.map((s) => s ?? emptyCell());
+  const attrs = { rows, cols };
+  return { type: "table", text: "", delta: [], attrs, cells };
+}
+function gridSpanOf(tc) {
+  const tcPr = findChild(tc, "w:tcPr");
+  if (!tcPr) return 1;
+  const gs = findChild(tcPr, "w:gridSpan");
+  if (!gs) return 1;
+  const n = parseIntAttr(attr(gs, "w:val"), 1);
+  return Math.max(1, n);
+}
+function cellChildrenToDelta(tc, ctx) {
+  const out = [];
+  let first = true;
+  for (const child of childrenOf(tc)) {
+    if (tagOf(child) !== "w:p") continue;
+    if (!first) out.push({ insert: "\n" });
+    first = false;
+    out.push(...paragraphChildrenToDelta(childrenOf(child), ctx));
+  }
+  return out;
+}
+function textOfDelta(delta) {
+  let out = "";
+  for (const op of delta) {
+    if (typeof op.insert === "string") out += op.insert;
+  }
+  return out;
+}
+function coveredCell() {
+  return { text: "", delta: [], attrs: { covered: true } };
+}
+function emptyCell() {
+  return { text: "", delta: [], attrs: {} };
+}
+
+// src/numbering.ts
+var NumberingResolver = class {
+  numIdToAbstract = /* @__PURE__ */ new Map();
+  abstractLevelFmt = /* @__PURE__ */ new Map();
+  constructor(numberingXml) {
+    if (!numberingXml) return;
+    for (const top of numberingXml) {
+      if (tagOf(top) !== "w:numbering") continue;
+      for (const child of childrenOf(top)) {
+        const tag = tagOf(child);
+        if (tag === "w:abstractNum") {
+          const abstractId = attr(child, "w:abstractNumId");
+          if (!abstractId) continue;
+          const levels = /* @__PURE__ */ new Map();
+          for (const lvl of findChildren(child, "w:lvl")) {
+            const ilvl = parseIntAttr(attr(lvl, "w:ilvl"), 0);
+            const fmt = attr(findChild(lvl, "w:numFmt") ?? {}, "w:val");
+            if (fmt) levels.set(ilvl, fmt);
+          }
+          this.abstractLevelFmt.set(abstractId, levels);
+        } else if (tag === "w:num") {
+          const numId = attr(child, "w:numId");
+          const abstractRef = findChild(child, "w:abstractNumId");
+          const abstractId = abstractRef ? attr(abstractRef, "w:val") : void 0;
+          if (numId && abstractId) this.numIdToAbstract.set(numId, abstractId);
+        }
+      }
+    }
+  }
+  /** Returns `{listKind, listLevel}` for a given paragraph's `<w:numPr>` node, or null. */
+  resolve(numPr) {
+    if (!numPr) return null;
+    const ilvlRef = findChild(numPr, "w:ilvl");
+    const numIdRef = findChild(numPr, "w:numId");
+    if (!numIdRef) return null;
+    const numId = attr(numIdRef, "w:val");
+    if (!numId) return null;
+    const listLevel = clampLevel(parseIntAttr(ilvlRef ? attr(ilvlRef, "w:val") : void 0, 0));
+    const abstractId = this.numIdToAbstract.get(numId);
+    if (abstractId == null) {
+      return { listKind: "bullet", listLevel };
+    }
+    const levels = this.abstractLevelFmt.get(abstractId);
+    const fmt = (levels?.get(listLevel) ?? "bullet").toLowerCase();
+    const listKind = fmt === "bullet" || fmt === "none" ? "bullet" : "ordered";
+    return { listKind, listLevel };
+  }
+};
+function clampLevel(n) {
+  if (!Number.isFinite(n)) return 0;
+  return Math.max(0, Math.min(5, Math.trunc(n)));
+}
+
+// src/page-settings.ts
+var import_core = require("@sofereditor/core");
+var MM_PER_TWIP = 25.4 / 1440;
+function twipsToPx(twips) {
+  return (0, import_core.mmToPx)(twips * MM_PER_TWIP);
+}
+function sectPrToPageSettings(sectPr) {
+  if (!sectPr) return void 0;
+  const pgSz = findChild(sectPr, "w:pgSz");
+  const pgMar = findChild(sectPr, "w:pgMar");
+  if (!pgSz && !pgMar) return void 0;
+  const widthTwips = pgSz ? parseIntAttr(attr(pgSz, "w:w"), 0) : 0;
+  const heightTwips = pgSz ? parseIntAttr(attr(pgSz, "w:h"), 0) : 0;
+  const topTwips = pgMar ? parseIntAttr(attr(pgMar, "w:top"), 0) : 0;
+  const bottomTwips = pgMar ? parseIntAttr(attr(pgMar, "w:bottom"), 0) : 0;
+  const leftTwips = pgMar ? parseIntAttr(attr(pgMar, "w:left"), 0) : 0;
+  const rightTwips = pgMar ? parseIntAttr(attr(pgMar, "w:right"), 0) : 0;
+  if (widthTwips <= 0 && heightTwips <= 0 && topTwips <= 0 && leftTwips <= 0) {
+    return void 0;
+  }
+  const width = widthTwips > 0 ? twipsToPx(widthTwips) : 794;
+  const height = heightTwips > 0 ? twipsToPx(heightTwips) : 1123;
+  const settings = {
+    width,
+    height,
+    marginTop: twipsToPx(topTwips || 0),
+    marginBottom: twipsToPx(bottomTwips || 0),
+    marginLeft: twipsToPx(leftTwips || 0),
+    marginRight: twipsToPx(rightTwips || 0)
+  };
+  settings.preset = (0, import_core.detectPreset)(settings.width, settings.height);
+  return settings;
+}
+
+// src/docx.ts
+async function docxBlobToDocument(input) {
+  const file = await readDocx(input);
+  const numbering = new NumberingResolver(file.numberingXml);
+  const ctx = {
+    relationships: file.relationships,
+    mediaBytes: file.mediaBytes
+  };
+  const body = findBody(file.documentXml);
+  if (!body) return { blocks: [{ type: "paragraph", text: "", delta: [], attrs: {} }] };
+  const blocks = [];
+  for (const child of childrenOf(body)) {
+    const tag = tagOf(child);
+    if (tag === "w:p") {
+      blocks.push(paragraphToBlock(child, ctx, numbering));
+    } else if (tag === "w:tbl") {
+      blocks.push(tableToBlock(child, ctx));
+    }
+  }
+  if (blocks.length === 0) {
+    blocks.push({ type: "paragraph", text: "", delta: [], attrs: {} });
+  }
+  const pageSettings = sectPrToPageSettings(findChild(body, "w:sectPr"));
+  return pageSettings ? { blocks, pageSettings } : { blocks };
+}
+async function docxBlobToEditorDocument(input) {
+  const serialized = await docxBlobToDocument(input);
+  return import_core2.EditorDocument.fromJSON(serialized);
+}
+function findBody(documentXml) {
+  for (const top of documentXml) {
+    if (tagOf(top) === "w:document") {
+      const body = findChild(top, "w:body");
+      if (body) return body;
+    }
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  docxBlobToDocument,
+  docxBlobToEditorDocument
+});
+//# sourceMappingURL=index.cjs.map