quoin-editor 0.4.2 → 1.0.0

package/dist/docx.cjs

@@ -0,0 +1,854 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }require('./chunk-PZ4GT5JO.cjs');
+require('./chunk-2QCRZ7OL.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkND5XJVK2cjs = require('./chunk-ND5XJVK2.cjs');
+
+// src/docx/asset-source.ts
+function assetUrl(block, resolveAssetUrl) {
+  const key = _chunkND5XJVK2cjs.str.call(void 0, block.attrs.storageKey);
+  const src = key === "" ? null : resolveAssetUrl(key);
+  return src ? _chunkND5XJVK2cjs.sanitizeAssetUrl.call(void 0, src) : null;
+}
+function pictureUrl(block, resolveAssetUrl) {
+  const url = _chunkND5XJVK2cjs.str.call(void 0, block.attrs.url);
+  return url === "" ? assetUrl(block, resolveAssetUrl) : _chunkND5XJVK2cjs.sanitizeHref.call(void 0, url);
+}
+
+// src/docx/docx-context.ts
+var FIRST_RELATIONSHIP = 3;
+function createContext({ schema, resolveAssetUrl, headings: headings2, images }) {
+  const bookmarks = new Map(headings2.map(({ blockId }, at) => [blockId, `_q${at + 1}`]));
+  const relationships = [];
+  const lists = [];
+  const media = [];
+  const related = /* @__PURE__ */ new Map();
+  const placed = /* @__PURE__ */ new Map();
+  let drawings = 0;
+  const relate = (kind, target) => {
+    const key = `${kind} ${target}`;
+    let id = related.get(key);
+    if (id === void 0) {
+      id = `rId${relationships.length + FIRST_RELATIONSHIP}`;
+      related.set(key, id);
+      relationships.push({ id, kind, target });
+    }
+    return id;
+  };
+  return {
+    schema,
+    resolveAssetUrl,
+    headings: headings2,
+    bookmarks,
+    relationships,
+    lists,
+    media,
+    link: (target) => relate("hyperlink", target),
+    list(ordered, level, start) {
+      const numId = lists.length + 1;
+      lists.push({ numId, ordered, level, start });
+      return numId;
+    },
+    picture(url) {
+      const image = url === null ? null : images.get(url);
+      if (!url || !image) return null;
+      let place = placed.get(url);
+      if (!place) {
+        const name = `image${media.length + 1}.${image.extension}`;
+        media.push({ path: `word/media/${name}`, data: image.data, extension: image.extension, type: image.type });
+        place = { rId: relate("image", `media/${name}`), image, name };
+        placed.set(url, place);
+      }
+      return place;
+    },
+    drawingId: () => ++drawings
+  };
+}
+
+// src/docx/palette-hex.ts
+var TEXT = {
+  default: "0A0A0A",
+  gray: "6C6C6C",
+  brown: "855F49",
+  orange: "B2580B",
+  yellow: "93690D",
+  green: "2A7E4F",
+  blue: "0A71B1",
+  purple: "8050B0",
+  pink: "B53874",
+  red: "C9302D"
+};
+var BACKGROUND = {
+  default: "FFFFFF",
+  gray: "F0F0F0",
+  brown: "F6ECE7",
+  orange: "FFEDDC",
+  yellow: "FDF4D2",
+  green: "E1F7E7",
+  blue: "E1F3FF",
+  purple: "F4ECFE",
+  pink: "FEEAF2",
+  red: "FDE9E8"
+};
+var pick = (table2, name) => {
+  const color = _chunkND5XJVK2cjs.paletteOrUndefined.call(void 0, name);
+  return color === void 0 ? void 0 : table2[color];
+};
+var textHex = (name) => pick(TEXT, name);
+var backgroundHex = (name) => pick(BACKGROUND, name);
+
+// src/docx/xml.ts
+var ESCAPES = { "<": "&lt;", ">": "&gt;", "&": "&amp;", '"': "&quot;", "'": "&apos;" };
+var NOT_XML = /(?![\t\n\r])\p{Cc}|[\uD800-\uDFFF\uFFFE\uFFFF]/gu;
+var escapeXml = (text) => text.replace(NOT_XML, "").replace(/[<>&"']/g, (char) => ESCAPES[char]);
+function xmlElement(name, attrs = {}, inner = "") {
+  const written = Object.entries(attrs).filter((entry) => entry[1] !== void 0).map(([key, value]) => ` ${key}="${escapeXml(String(value))}"`).join("");
+  return inner === "" ? `<${name}${written}/>` : `<${name}${written}>${inner}</${name}>`;
+}
+var XML_DECLARATION = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+
+// src/docx/paragraph-xml.ts
+var INDENT_STEP = 720;
+var JUSTIFY = { left: "left", center: "center", right: "right", justify: "both" };
+var BOTTOM_BORDER = xmlElement(
+  "w:pBdr",
+  {},
+  xmlElement("w:bottom", { "w:val": "single", "w:sz": 6, "w:space": 1, "w:color": "auto" })
+);
+function numberingXml({ numId, level }) {
+  if (numId === void 0) return "";
+  return xmlElement("w:numPr", {}, xmlElement("w:ilvl", { "w:val": _nullishCoalesce(level, () => ( 0)) }) + xmlElement("w:numId", { "w:val": numId }));
+}
+function paragraphPropsXml(props) {
+  const align = _chunkND5XJVK2cjs.alignOrUndefined.call(void 0, props.align);
+  const indented = (_nullishCoalesce(props.indent, () => ( 0))) > 0 || props.hanging !== void 0;
+  const inner = [
+    props.style === void 0 ? "" : xmlElement("w:pStyle", { "w:val": props.style }),
+    numberingXml(props),
+    props.border ? BOTTOM_BORDER : "",
+    props.shade === void 0 ? "" : xmlElement("w:shd", { "w:val": "clear", "w:color": "auto", "w:fill": props.shade }),
+    indented ? xmlElement("w:ind", { "w:left": _nullishCoalesce(props.indent, () => ( 0)), "w:hanging": props.hanging }) : "",
+    align === void 0 ? "" : xmlElement("w:jc", { "w:val": JUSTIFY[align] })
+  ].join("");
+  return inner === "" ? "" : xmlElement("w:pPr", {}, inner);
+}
+var paragraphXml = (props, runs) => xmlElement("w:p", {}, paragraphPropsXml(props) + runs);
+var indentOf = (indent) => indent * INDENT_STEP;
+
+// src/docx/style-ids.ts
+var CODE_STYLE = "QuoinCode";
+var CODE_CHAR_STYLE = "QuoinCodeChar";
+
+// src/docx/run-properties.ts
+var HIGHLIGHT = "yellow";
+function markProps(mark) {
+  const color = _optionalChain([mark, 'access', _2 => _2.attrs, 'optionalAccess', _3 => _3.color]);
+  switch (mark.type) {
+    case "bold":
+      return { bold: true };
+    case "italic":
+      return { italic: true };
+    case "underline":
+      return { underline: true };
+    case "strike":
+      return { strike: true };
+    case "sub":
+      return { vertAlign: "subscript" };
+    case "sup":
+      return { vertAlign: "superscript" };
+    case "code":
+      return { style: CODE_CHAR_STYLE };
+    case "highlight":
+      return { shade: backgroundHex(color || HIGHLIGHT) };
+    case "color":
+      return { color: textHex(color) };
+    case "background":
+      return { shade: backgroundHex(color) };
+    default:
+      return {};
+  }
+}
+var defined = (props) => Object.fromEntries(Object.entries(props).filter(([, value]) => value !== void 0));
+function propsOf(marks, base, linked) {
+  const props = marks.reduce((all, mark) => ({ ...all, ...defined(markProps(mark)) }), base);
+  return linked && props.style === void 0 ? { ...props, style: "Hyperlink" } : props;
+}
+var on = (flag, name) => flag ? xmlElement(name) : "";
+function runPropertiesXml(props) {
+  const inner = [
+    props.style === void 0 ? "" : xmlElement("w:rStyle", { "w:val": props.style }),
+    on(props.bold, "w:b"),
+    on(props.italic, "w:i"),
+    on(props.strike, "w:strike"),
+    props.color === void 0 ? "" : xmlElement("w:color", { "w:val": props.color }),
+    props.underline ? xmlElement("w:u", { "w:val": "single" }) : "",
+    props.shade === void 0 ? "" : xmlElement("w:shd", { "w:val": "clear", "w:color": "auto", "w:fill": props.shade }),
+    props.vertAlign === void 0 ? "" : xmlElement("w:vertAlign", { "w:val": props.vertAlign })
+  ].join("");
+  return inner === "" ? "" : xmlElement("w:rPr", {}, inner);
+}
+
+// src/docx/word-link.ts
+var LINKED = /^(?:https?|mailto|tel):/i;
+function wordLink(href) {
+  const safe = _chunkND5XJVK2cjs.sanitizeHref.call(void 0, href);
+  return safe !== null && LINKED.test(safe) ? safe : null;
+}
+
+// src/docx/runs-xml.ts
+var pieceXml = (piece) => piece === "" ? "" : xmlElement("w:t", { "xml:space": "preserve" }, escapeXml(piece));
+var lineXml = (line) => line.split("	").map(pieceXml).join("<w:tab/>");
+var textXml = (text) => text.split(/\r\n|\r|\n/).map(lineXml).join("<w:br/>");
+var runXml = (text, props = {}) => text === "" ? "" : xmlElement("w:r", {}, runPropertiesXml(props) + textXml(text));
+function linkOf(marks) {
+  const link = marks.find((mark) => mark.type === "link");
+  return link ? wordLink(_nullishCoalesce(_optionalChain([link, 'access', _4 => _4.attrs, 'optionalAccess', _5 => _5.href]), () => ( ""))) : null;
+}
+function nodeRun(node, ctx, base, linked) {
+  const props = propsOf(node.marks, base, linked);
+  if (node.kind === "text") return runXml(node.text, props);
+  const text = _nullishCoalesce(_optionalChain([ctx, 'access', _6 => _6.schema, 'access', _7 => _7.atoms, 'access', _8 => _8.get, 'call', _9 => _9(node.type), 'optionalAccess', _10 => _10.plainText, 'call', _11 => _11(node.attrs)]), () => ( ""));
+  return runXml(text, node.type === "math" ? { ...props, style: CODE_CHAR_STYLE } : props);
+}
+function runsXml(inline, ctx, base = {}) {
+  let out = "";
+  let open = null;
+  let runs = "";
+  const flush = () => {
+    out += open === null || runs === "" ? runs : xmlElement("w:hyperlink", { "r:id": ctx.link(open) }, runs);
+    runs = "";
+  };
+  for (const node of _nullishCoalesce(inline, () => ( []))) {
+    const href = linkOf(node.marks);
+    if (href !== open) {
+      flush();
+      open = href;
+    }
+    runs += nodeRun(node, ctx, base, href !== null);
+  }
+  flush();
+  return out;
+}
+
+// src/docx/line-xml.ts
+var CHECKBOX_HANG = 360;
+function bookmarked(block, ctx, runs) {
+  const name = ctx.bookmarks.get(block.id);
+  if (name === void 0) return runs;
+  const id = name.slice(2);
+  return xmlElement("w:bookmarkStart", { "w:id": id, "w:name": name }) + runs + xmlElement("w:bookmarkEnd", { "w:id": id });
+}
+function lineXml2(block, ctx, numId) {
+  const { attrs } = block;
+  const runs = runsXml(block.regions.text, ctx, { color: textHex(attrs.color) });
+  const props = { align: attrs.align, shade: backgroundHex(attrs.background), indent: indentOf(block.indent) };
+  switch (attrs.kind) {
+    case "heading":
+      return paragraphXml({ ...props, style: `Heading${_nullishCoalesce(_chunkND5XJVK2cjs.headingLevel2.call(void 0, block), () => ( 1))}` }, bookmarked(block, ctx, runs));
+    case "bullet":
+    case "ordered":
+      return paragraphXml({ ...props, indent: void 0, numId, level: Math.min(block.indent, 8) }, runs);
+    case "task": {
+      const box = attrs.checked === true ? "\u2611 " : "\u2610 ";
+      const hung = { ...props, indent: indentOf(block.indent) + CHECKBOX_HANG, hanging: CHECKBOX_HANG };
+      return paragraphXml(hung, runXml(box) + runs);
+    }
+    case "quote":
+      return paragraphXml({ ...props, style: "Quote" }, runs);
+    default:
+      return paragraphXml(props, runs);
+  }
+}
+
+// src/docx/drawing-xml.ts
+var EMU_PER_PIXEL = 9525;
+var EMU_PER_TWIP = 635;
+var PAGE_TEXT_WIDTH = 9026;
+var PAGE_WIDTH_EMU = PAGE_TEXT_WIDTH * EMU_PER_TWIP;
+var DEFAULT_SIZE = { width: 480, height: 360 };
+var PICTURE = "http://schemas.openxmlformats.org/drawingml/2006/picture";
+var DRAWING = "http://schemas.openxmlformats.org/drawingml/2006/main";
+function pixelSize({ image }, attrs) {
+  if (image.width && image.height) return { width: image.width, height: image.height };
+  const width = _chunkND5XJVK2cjs.optionalNumber.call(void 0, attrs.width);
+  const height = _chunkND5XJVK2cjs.optionalNumber.call(void 0, attrs.height);
+  return width && height && width > 0 && height > 0 ? { width, height } : DEFAULT_SIZE;
+}
+function extent(place, attrs) {
+  const { width, height } = pixelSize(place, attrs);
+  const percent = _chunkND5XJVK2cjs.optionalNumber.call(void 0, attrs.widthPercent);
+  const own = width * EMU_PER_PIXEL;
+  const share = percent && percent > 0 && percent <= 100 ? PAGE_WIDTH_EMU * percent / 100 : void 0;
+  const cx = Math.round(_nullishCoalesce(share, () => ( Math.min(own, PAGE_WIDTH_EMU))));
+  return { cx, cy: Math.round(cx * height / width) };
+}
+function drawingXml(place, attrs, alt, id) {
+  const { cx, cy } = extent(place, attrs);
+  const size = { cx, cy };
+  const picture = xmlElement(
+    "pic:pic",
+    { "xmlns:pic": PICTURE },
+    xmlElement("pic:nvPicPr", {}, xmlElement("pic:cNvPr", { id, name: place.name }) + xmlElement("pic:cNvPicPr")) + xmlElement("pic:blipFill", {}, xmlElement("a:blip", { "r:embed": place.rId }) + "<a:stretch><a:fillRect/></a:stretch>") + xmlElement(
+      "pic:spPr",
+      {},
+      xmlElement("a:xfrm", {}, xmlElement("a:off", { x: 0, y: 0 }) + xmlElement("a:ext", size)) + '<a:prstGeom prst="rect"><a:avLst/></a:prstGeom>'
+    )
+  );
+  const inline = xmlElement(
+    "wp:inline",
+    { distT: 0, distB: 0, distL: 0, distR: 0 },
+    xmlElement("wp:extent", size) + xmlElement("wp:docPr", { id, name: `Picture ${id}`, descr: alt || void 0 }) + xmlElement("a:graphic", { "xmlns:a": DRAWING }, xmlElement("a:graphicData", { uri: PICTURE }, picture))
+  );
+  return xmlElement("w:r", {}, xmlElement("w:drawing", {}, inline));
+}
+
+// src/docx/media-xml.ts
+function linkParagraphXml(href, text, ctx, indent) {
+  const safe = href === null ? null : wordLink(href);
+  const runs = safe ? xmlElement("w:hyperlink", { "r:id": ctx.link(safe) }, runXml(text, { style: "Hyperlink" })) : runXml(text);
+  return paragraphXml({ indent: indentOf(indent) }, runs);
+}
+function imageXml(block, ctx) {
+  const { attrs } = block;
+  const alt = _chunkND5XJVK2cjs.str.call(void 0, attrs.alt);
+  const place = ctx.picture(pictureUrl(block, ctx.resolveAssetUrl));
+  const props = { indent: indentOf(block.indent), align: attrs.align };
+  const picture = place ? drawingXml(place, attrs, alt, ctx.drawingId()) : runXml(alt);
+  const caption = _nullishCoalesce(block.regions.caption, () => ( []));
+  return (picture === "" ? "" : paragraphXml(props, picture)) + (caption.length > 0 ? paragraphXml({ ...props, style: "Caption" }, runsXml(caption, ctx)) : "");
+}
+var fileXml = (block, ctx) => linkParagraphXml(assetUrl(block, ctx.resolveAssetUrl), _chunkND5XJVK2cjs.str.call(void 0, block.attrs.filename), ctx, block.indent);
+function webLinkXml(block, ctx) {
+  const url = _chunkND5XJVK2cjs.str.call(void 0, block.attrs.url);
+  const text = block.type === "BOOKMARK" ? _chunkND5XJVK2cjs.str.call(void 0, block.attrs.title) || url : url;
+  return url === "" ? "" : linkParagraphXml(url, text, ctx, block.indent);
+}
+
+// src/docx/table-xml.ts
+var TONE_COLORS = {
+  info: "blue",
+  tip: "purple",
+  success: "green",
+  warning: "yellow",
+  danger: "red"
+};
+var NO_BORDERS = xmlElement(
+  "w:tblBorders",
+  {},
+  ["top", "left", "bottom", "right", "insideH", "insideV"].map((side) => xmlElement(`w:${side}`, { "w:val": "nil" })).join("")
+);
+function tableShell({ cols, indent, style, rows }) {
+  const width = Math.floor((PAGE_TEXT_WIDTH - indentOf(indent)) / cols);
+  const props = (style ? xmlElement("w:tblStyle", { "w:val": style }) : "") + xmlElement("w:tblW", { "w:w": width * cols, "w:type": "dxa" }) + (indent > 0 ? xmlElement("w:tblInd", { "w:w": indentOf(indent), "w:type": "dxa" }) : "") + (style ? "" : NO_BORDERS);
+  const grid = Array.from({ length: cols }, () => xmlElement("w:gridCol", { "w:w": width })).join("");
+  return xmlElement("w:tbl", {}, xmlElement("w:tblPr", {}, props) + xmlElement("w:tblGrid", {}, grid) + rows.join(""));
+}
+var cellXml = (inner, cellProps = "") => xmlElement("w:tc", {}, (cellProps && xmlElement("w:tcPr", {}, cellProps)) + inner);
+function tableXml(block, ctx) {
+  const rows = _chunkND5XJVK2cjs.tableCells.call(void 0, block);
+  const cols = _nullishCoalesce(_optionalChain([rows, 'access', _12 => _12[0], 'optionalAccess', _13 => _13.length]), () => ( 0));
+  if (rows.length === 0 || cols === 0) return "";
+  const aligns = Array.isArray(block.attrs.align) ? block.attrs.align : [];
+  const headed = block.attrs.header !== false;
+  const rowXml = (cells, header2) => {
+    const base = header2 ? { bold: true } : {};
+    const written2 = cells.map((cell, col) => cellXml(paragraphXml({ align: aligns[col] }, runsXml(cell, ctx, base))));
+    return xmlElement("w:tr", {}, (header2 ? "<w:trPr><w:tblHeader/></w:trPr>" : "") + written2.join(""));
+  };
+  const written = rows.map((cells, row) => rowXml(cells, headed && row === 0));
+  return tableShell({ cols, indent: block.indent, style: "TableGrid", rows: written });
+}
+function calloutXml(block, ctx) {
+  const icon = _chunkND5XJVK2cjs.str.call(void 0, block.attrs.icon);
+  const fill = backgroundHex(_nullishCoalesce(TONE_COLORS[_chunkND5XJVK2cjs.str.call(void 0, block.attrs.tone)], () => ( "gray")));
+  const shade = xmlElement("w:shd", { "w:val": "clear", "w:color": "auto", "w:fill": fill });
+  const body = paragraphXml({}, (icon === "" ? "" : runXml(`${icon} `)) + runsXml(block.regions.body, ctx));
+  return tableShell({ cols: 1, indent: block.indent, rows: [xmlElement("w:tr", {}, cellXml(body, shade))] });
+}
+
+// src/docx/toc-xml.ts
+var LEVEL_STEP = 360;
+function entriesXml(nodes, depth, ctx, indent) {
+  return nodes.map(({ heading, children }) => {
+    const anchor = _nullishCoalesce(ctx.bookmarks.get(heading.blockId), () => ( ""));
+    const run = runXml(heading.text, { style: "Hyperlink" });
+    const link = xmlElement("w:hyperlink", { "w:anchor": anchor, "w:history": 1 }, run);
+    return paragraphXml({ indent: indent + depth * LEVEL_STEP }, link) + entriesXml(children, depth + 1, ctx, indent);
+  }).join("");
+}
+var tocXml = (headings2, ctx, indent) => entriesXml(_chunkND5XJVK2cjs.nestHeadings.call(void 0, headings2), 0, ctx, indent);
+
+// src/docx/block-xml.ts
+function unknownXml(block, ctx) {
+  const text = _chunkND5XJVK2cjs.blockPlainText.call(void 0, block, ctx.schema);
+  const label = runXml(`[${block.type}]`, { italic: true });
+  return paragraphXml({ indent: indentOf(block.indent) }, label + runXml(text && ` ${text}`));
+}
+function blockXml(block, ctx, numId) {
+  const indent = { indent: indentOf(block.indent) };
+  switch (block.type) {
+    case "MARKDOWN":
+      return lineXml2(block, ctx, numId);
+    case "CALLOUT":
+      return calloutXml(block, ctx);
+    case "CODE":
+      return paragraphXml({ ...indent, style: CODE_STYLE }, runXml(_chunkND5XJVK2cjs.str.call(void 0, block.attrs.code)));
+    case "IMAGE":
+      return imageXml(block, ctx);
+    case "FILE":
+      return fileXml(block, ctx);
+    case "DIVIDER":
+      return paragraphXml({ ...indent, border: true }, "");
+    case "TOGGLE":
+      return paragraphXml(indent, runsXml(block.regions.text, ctx));
+    case "TABLE":
+      return tableXml(block, ctx);
+    case "EMBED":
+    case "BOOKMARK":
+      return webLinkXml(block, ctx);
+    case "MATH":
+      return paragraphXml(indent, runXml(_chunkND5XJVK2cjs.str.call(void 0, block.attrs.latex), { style: CODE_CHAR_STYLE }));
+    case "TOC":
+      return tocXml(ctx.headings, ctx, indent.indent);
+    default:
+      return unknownXml(block, ctx);
+  }
+}
+
+// src/docx/document-xml.ts
+var NAMESPACES = {
+  "xmlns:w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
+  "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+  "xmlns:wp": "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"
+};
+var MARGIN = 1440;
+var SECTION = xmlElement(
+  "w:sectPr",
+  {},
+  xmlElement("w:pgSz", { "w:w": PAGE_TEXT_WIDTH + 2 * MARGIN, "w:h": 16838 }) + xmlElement("w:pgMar", {
+    "w:top": MARGIN,
+    "w:right": MARGIN,
+    "w:bottom": MARGIN,
+    "w:left": MARGIN,
+    "w:header": 708,
+    "w:footer": 708,
+    "w:gutter": 0
+  })
+);
+var LEVELS = 9;
+function entryXml({ block, children }, ctx, numId) {
+  return blockXml(block, ctx, numId) + groupsXml(children, ctx);
+}
+function groupXml(group, ctx) {
+  if (group.kind === "single") return entryXml(group.entry, ctx);
+  if (group.kind === "quote") return group.items.map((entry) => entryXml(entry, ctx)).join("");
+  const first = group.items[0].block;
+  const start = first.attrs.start;
+  const numId = group.list === "task" ? void 0 : ctx.list(group.list === "ordered", Math.min(first.indent, LEVELS - 1), Number.isInteger(start) ? Number(start) : 1);
+  return group.items.map((entry) => entryXml(entry, ctx, numId)).join("");
+}
+var groupsXml = (groups, ctx) => groups.map((group) => groupXml(group, ctx)).join("");
+var separateTables = (body) => body.replaceAll("</w:tbl><w:tbl>", "</w:tbl><w:p/><w:tbl>").replace(/<\/w:tbl>$/, "</w:tbl><w:p/>");
+function documentXml(groups, ctx) {
+  const body = separateTables(groupsXml(groups, ctx)) || "<w:p/>";
+  return XML_DECLARATION + xmlElement("w:document", NAMESPACES, xmlElement("w:body", {}, body + SECTION));
+}
+
+// src/docx/fetch-asset.ts
+async function bytesOf(answer) {
+  if (answer instanceof Uint8Array) return answer;
+  if (answer instanceof ArrayBuffer) return new Uint8Array(answer);
+  if ("ok" in answer && !answer.ok) throw new Error(`status ${answer.status}`);
+  return new Uint8Array(await answer.arrayBuffer());
+}
+var defaultFetch = (url, init) => fetch(url, init);
+var LONGEST_WAIT = 2147483647;
+var waitOf = (timeout) => timeout >= 0 && timeout <= LONGEST_WAIT ? timeout : LONGEST_WAIT;
+async function fetchBytes(url, fetchAsset = defaultFetch, timeout) {
+  const controller = new AbortController();
+  let timer;
+  const expired = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      resolve(null);
+    }, waitOf(timeout));
+  });
+  const read = (async () => bytesOf(await fetchAsset(url, { signal: controller.signal })))();
+  try {
+    return await Promise.race([read, expired]);
+  } catch (e) {
+    return null;
+  } finally {
+    clearTimeout(timer);
+    read.catch(() => void 0);
+  }
+}
+
+// src/docx/image-size.ts
+var startsWith = (bytes, signature, at = 0) => bytes.length >= at + signature.length && signature.every((byte, index) => bytes[at + index] === byte);
+var ascii = (text) => [...text].map((char) => char.charCodeAt(0));
+var sized = (width, height) => width > 0 && height > 0 ? { width, height } : void 0;
+function pngSize(view) {
+  return view.byteLength >= 24 ? sized(view.getUint32(16), view.getUint32(20)) : void 0;
+}
+function gifSize(view) {
+  return view.byteLength >= 10 ? sized(view.getUint16(6, true), view.getUint16(8, true)) : void 0;
+}
+function jpegSize(view) {
+  let at = 2;
+  while (at + 9 <= view.byteLength && view.getUint8(at) === 255) {
+    if (view.getUint8(at + 1) === 255) {
+      at++;
+      continue;
+    }
+    const marker = view.getUint8(at + 1);
+    if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+      return sized(view.getUint16(at + 7), view.getUint16(at + 5));
+    }
+    at += 2 + view.getUint16(at + 2);
+  }
+  return void 0;
+}
+var uint24 = (view, at) => view.getUint8(at) | view.getUint8(at + 1) << 8 | view.getUint8(at + 2) << 16;
+function webpSize(view, bytes) {
+  if (startsWith(bytes, ascii("VP8 "), 12) && view.byteLength >= 30) {
+    return sized(view.getUint16(26, true) & 16383, view.getUint16(28, true) & 16383);
+  }
+  if (startsWith(bytes, ascii("VP8L"), 12) && view.byteLength >= 25) {
+    const bits = view.getUint32(21, true);
+    return sized((bits & 16383) + 1, (bits >>> 14 & 16383) + 1);
+  }
+  if (startsWith(bytes, ascii("VP8X"), 12) && view.byteLength >= 30) return sized(uint24(view, 24) + 1, uint24(view, 27) + 1);
+  return void 0;
+}
+var FORMATS = [
+  { extension: "png", signature: [137, 80, 78, 71], size: pngSize },
+  { extension: "jpeg", signature: [255, 216, 255], size: jpegSize },
+  { extension: "gif", signature: ascii("GIF8"), size: gifSize },
+  { extension: "webp", signature: ascii("RIFF"), size: webpSize }
+];
+function imageFormat(bytes) {
+  const format = FORMATS.find(
+    ({ extension, signature }) => startsWith(bytes, signature) && (extension !== "webp" || startsWith(bytes, ascii("WEBP"), 8))
+  );
+  if (!format) return null;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return { extension: format.extension, type: `image/${format.extension}`, ...format.size(view, bytes) };
+}
+
+// src/docx/images.ts
+async function load(url, loading) {
+  const data = await fetchBytes(url, loading.fetchAsset, loading.timeout);
+  const format = data && imageFormat(data);
+  return format ? { ...format, data } : null;
+}
+async function loadImages(urls, loading) {
+  const queue = [...new Set(urls)];
+  const loaded = /* @__PURE__ */ new Map();
+  const worker = async () => {
+    for (let url = queue.shift(); url !== void 0; url = queue.shift()) loaded.set(url, await load(url, loading));
+  };
+  const workers = Math.min(Math.max(1, Math.floor(loading.concurrency) || 1), queue.length);
+  await Promise.all(Array.from({ length: workers }, worker));
+  return loaded;
+}
+
+// src/docx/numbering-xml.ts
+var LEVELS2 = 9;
+var BULLETS = ["\u2022", "\u25E6", "\u25AA"];
+var ORDERED_FORMATS = ["decimal", "lowerLetter", "lowerRoman"];
+var HANG = 360;
+var BULLET = 0;
+var ORDERED = 1;
+function levelXml(level, ordered) {
+  const format = ordered ? ORDERED_FORMATS[level % 3] : "bullet";
+  const text = ordered ? `%${level + 1}.` : BULLETS[level % 3];
+  return xmlElement(
+    "w:lvl",
+    { "w:ilvl": level },
+    xmlElement("w:start", { "w:val": 1 }) + xmlElement("w:numFmt", { "w:val": format }) + xmlElement("w:lvlText", { "w:val": text }) + xmlElement("w:lvlJc", { "w:val": "left" }) + xmlElement("w:pPr", {}, xmlElement("w:ind", { "w:left": (level + 1) * INDENT_STEP, "w:hanging": HANG }))
+  );
+}
+var abstractXml = (id, ordered) => xmlElement(
+  "w:abstractNum",
+  { "w:abstractNumId": id },
+  xmlElement("w:multiLevelType", { "w:val": "hybridMultilevel" }) + Array.from({ length: LEVELS2 }, (_, level) => levelXml(level, ordered)).join("")
+);
+function numXml({ numId, ordered, level, start }) {
+  const override = (at) => xmlElement("w:lvlOverride", { "w:ilvl": at }, xmlElement("w:startOverride", { "w:val": at === level ? start : 1 }));
+  const restart = ordered ? Array.from({ length: LEVELS2 }, (_, at) => override(at)).join("") : "";
+  const scheme = xmlElement("w:abstractNumId", { "w:val": ordered ? ORDERED : BULLET });
+  return xmlElement("w:num", { "w:numId": numId }, scheme + restart);
+}
+var numberingXml2 = (lists) => XML_DECLARATION + xmlElement(
+  "w:numbering",
+  { "xmlns:w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main" },
+  abstractXml(BULLET, false) + abstractXml(ORDERED, true) + lists.map(numXml).join("")
+);
+
+// src/docx/package-xml.ts
+var RELATIONSHIPS = "http://schemas.openxmlformats.org/package/2006/relationships";
+var OFFICE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+var WORD = "application/vnd.openxmlformats-officedocument.wordprocessingml";
+var CORE_PROPERTIES = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties";
+var relationshipsXml = (items) => XML_DECLARATION + xmlElement("Relationships", { xmlns: RELATIONSHIPS }, items.map((item) => xmlElement("Relationship", item)).join(""));
+function contentTypesXml(media) {
+  const pictures = [...new Map(media.map(({ extension, type }) => [extension, type]))];
+  const defaults = [
+    ["rels", "application/vnd.openxmlformats-package.relationships+xml"],
+    ["xml", "application/xml"],
+    ...pictures
+  ].map(([Extension, ContentType]) => xmlElement("Default", { Extension, ContentType }));
+  const overrides = [
+    ["/word/document.xml", `${WORD}.document.main+xml`],
+    ["/word/styles.xml", `${WORD}.styles+xml`],
+    ["/word/numbering.xml", `${WORD}.numbering+xml`],
+    ["/docProps/core.xml", "application/vnd.openxmlformats-package.core-properties+xml"]
+  ].map(([PartName, ContentType]) => xmlElement("Override", { PartName, ContentType }));
+  const types = "http://schemas.openxmlformats.org/package/2006/content-types";
+  return XML_DECLARATION + xmlElement("Types", { xmlns: types }, [...defaults, ...overrides].join(""));
+}
+var packageRelationshipsXml = () => relationshipsXml([
+  { Id: "rId1", Type: `${OFFICE}/officeDocument`, Target: "word/document.xml" },
+  { Id: "rId2", Type: CORE_PROPERTIES, Target: "docProps/core.xml" }
+]);
+var documentRelationshipsXml = (relationships) => relationshipsXml([
+  { Id: "rId1", Type: `${OFFICE}/styles`, Target: "styles.xml" },
+  { Id: "rId2", Type: `${OFFICE}/numbering`, Target: "numbering.xml" },
+  ...relationships.map(({ id, kind, target }) => ({
+    Id: id,
+    Type: `${OFFICE}/${kind}`,
+    Target: target,
+    TargetMode: kind === "hyperlink" ? "External" : void 0
+  }))
+]);
+function corePropertiesXml(title) {
+  const attrs = {
+    "xmlns:cp": "http://schemas.openxmlformats.org/package/2006/metadata/core-properties",
+    "xmlns:dc": "http://purl.org/dc/elements/1.1/",
+    "xmlns:dcterms": "http://purl.org/dc/terms/"
+  };
+  const inner = title ? xmlElement("dc:title", {}, escapeXml(title)) : "";
+  return XML_DECLARATION + xmlElement("cp:coreProperties", attrs, inner);
+}
+
+// src/docx/styles-xml.ts
+var MONO = '<w:rFonts w:ascii="Consolas" w:hAnsi="Consolas" w:cs="Consolas"/>';
+var HEADING_SIZES = [36, 30, 26, 24, 22, 22];
+function styleXml({ type, id, name, basedOn, pPr, rPr, tblPr }) {
+  return xmlElement(
+    "w:style",
+    { "w:type": type, "w:styleId": id, "w:default": id === "Normal" ? 1 : void 0 },
+    xmlElement("w:name", { "w:val": name }) + (basedOn ? xmlElement("w:basedOn", { "w:val": basedOn }) : "") + (type === "paragraph" ? xmlElement("w:next", { "w:val": "Normal" }) : "") + (pPr ? xmlElement("w:pPr", {}, pPr) : "") + (rPr ? xmlElement("w:rPr", {}, rPr) : "") + (tblPr ? xmlElement("w:tblPr", {}, tblPr) : "")
+  );
+}
+var headings = HEADING_SIZES.map((size, at) => ({
+  type: "paragraph",
+  id: `Heading${at + 1}`,
+  name: `heading ${at + 1}`,
+  basedOn: "Normal",
+  pPr: `<w:keepNext/><w:spacing w:before="${at < 2 ? 360 : 240}" w:after="120"/><w:outlineLvl w:val="${at}"/>`,
+  rPr: `<w:b/><w:sz w:val="${size}"/><w:szCs w:val="${size}"/>`
+}));
+var border = (side) => `<w:${side} w:val="single" w:sz="4" w:space="0" w:color="BFBFBF"/>`;
+var STYLES = [
+  { type: "paragraph", id: "Normal", name: "Normal", pPr: '<w:spacing w:after="120" w:line="276" w:lineRule="auto"/>' },
+  ...headings,
+  {
+    type: "paragraph",
+    id: "Quote",
+    name: "Quote",
+    basedOn: "Normal",
+    pPr: '<w:pBdr><w:left w:val="single" w:sz="18" w:space="8" w:color="BFBFBF"/></w:pBdr><w:ind w:left="240"/>',
+    rPr: '<w:i/><w:color w:val="595959"/>'
+  },
+  {
+    type: "paragraph",
+    id: CODE_STYLE,
+    name: "Code",
+    basedOn: "Normal",
+    pPr: '<w:shd w:val="clear" w:color="auto" w:fill="F0F0F0"/><w:spacing w:after="120" w:line="240" w:lineRule="auto"/>',
+    rPr: `${MONO}<w:sz w:val="20"/>`
+  },
+  {
+    type: "paragraph",
+    id: "Caption",
+    name: "caption",
+    basedOn: "Normal",
+    rPr: '<w:i/><w:color w:val="595959"/><w:sz w:val="18"/>'
+  },
+  {
+    type: "character",
+    id: CODE_CHAR_STYLE,
+    name: "Code Char",
+    rPr: `${MONO}<w:shd w:val="clear" w:color="auto" w:fill="F0F0F0"/>`
+  },
+  { type: "character", id: "Hyperlink", name: "Hyperlink", rPr: '<w:color w:val="0A71B1"/><w:u w:val="single"/>' },
+  {
+    type: "table",
+    id: "TableGrid",
+    name: "Table Grid",
+    tblPr: `<w:tblBorders>${["top", "left", "bottom", "right", "insideH", "insideV"].map(border).join("")}</w:tblBorders>`
+  }
+];
+var DEFAULTS = '<w:docDefaults><w:rPrDefault><w:rPr><w:rFonts w:ascii="Calibri" w:hAnsi="Calibri" w:eastAsia="Calibri" w:cs="Calibri"/><w:sz w:val="22"/><w:szCs w:val="22"/><w:lang w:val="en-US"/></w:rPr></w:rPrDefault><w:pPrDefault/></w:docDefaults>';
+var stylesXml = () => XML_DECLARATION + xmlElement(
+  "w:styles",
+  { "xmlns:w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main" },
+  DEFAULTS + STYLES.map(styleXml).join("")
+);
+
+// src/docx/crc32.ts
+var table;
+function crcTable() {
+  table ??= Uint32Array.from({ length: 256 }, (_, byte) => {
+    let crc = byte;
+    for (let bit = 0; bit < 8; bit++) crc = crc & 1 ? 3988292384 ^ crc >>> 1 : crc >>> 1;
+    return crc;
+  });
+  return table;
+}
+function crc32(bytes) {
+  const lookup = crcTable();
+  let crc = 4294967295;
+  for (const byte of bytes) crc = lookup[(crc ^ byte) & 255] ^ crc >>> 8;
+  return (crc ^ 4294967295) >>> 0;
+}
+
+// src/docx/deflate.ts
+async function deflateRaw(bytes) {
+  try {
+    const compressed = new Blob([bytes]).stream().pipeThrough(new CompressionStream("deflate-raw"));
+    return new Uint8Array(await new Response(compressed).arrayBuffer());
+  } catch (e2) {
+    return null;
+  }
+}
+
+// src/docx/zip.ts
+var UTF8_NAMES = 2048;
+var DEFLATE = 8;
+var DOS_DATE = 0 << 9 | 1 << 5 | 1;
+async function entryOf({ path, data }) {
+  const deflated = await deflateRaw(data);
+  const smaller = deflated !== null && deflated.length < data.length;
+  return {
+    name: new TextEncoder().encode(path),
+    crc: crc32(data),
+    size: data.length,
+    method: smaller ? DEFLATE : 0,
+    body: smaller ? deflated : data
+  };
+}
+function header(signature, entry, central) {
+  const length = central === void 0 ? 30 : 46;
+  const bytes = new Uint8Array(length + entry.name.length);
+  const view = new DataView(bytes.buffer);
+  let at = 0;
+  const u16 = (value) => (view.setUint16(at, value, true), at += 2);
+  const u32 = (value) => (view.setUint32(at, value, true), at += 4);
+  u32(signature);
+  if (central !== void 0) u16(20);
+  u16(20);
+  u16(UTF8_NAMES);
+  u16(entry.method);
+  u16(0);
+  u16(DOS_DATE);
+  u32(entry.crc);
+  u32(entry.body.length);
+  u32(entry.size);
+  u16(entry.name.length);
+  u16(0);
+  if (central !== void 0) {
+    u16(0);
+    u16(0);
+    u16(0);
+    u32(0);
+    u32(central);
+  }
+  bytes.set(entry.name, length);
+  return bytes;
+}
+function endOfDirectory(count, size, offset) {
+  const bytes = new Uint8Array(22);
+  const view = new DataView(bytes.buffer);
+  view.setUint32(0, 101010256, true);
+  view.setUint16(8, count, true);
+  view.setUint16(10, count, true);
+  view.setUint32(12, size, true);
+  view.setUint32(16, offset, true);
+  return bytes;
+}
+function concat(parts) {
+  const out = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
+  let at = 0;
+  for (const part of parts) {
+    out.set(part, at);
+    at += part.length;
+  }
+  return out;
+}
+async function zipArchive(files) {
+  const entries = await Promise.all(files.map(entryOf));
+  const local = [];
+  const central = [];
+  let offset = 0;
+  for (const entry of entries) {
+    const head = header(67324752, entry, void 0);
+    central.push(header(33639248, entry, offset));
+    local.push(head, entry.body);
+    offset += head.length + entry.body.length;
+  }
+  const directory = concat(central);
+  return concat([...local, directory, endOfDirectory(entries.length, directory.length, offset)]);
+}
+
+// src/docx/index.ts
+var WORD_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+var IMAGE_TIMEOUT = 1e4;
+var IMAGE_CONCURRENCY = 4;
+var encode = (xml) => new TextEncoder().encode(xml);
+async function toDocx(blocks, options = {}) {
+  const schema = _nullishCoalesce(options.schema, () => ( _chunkND5XJVK2cjs.createSchema.call(void 0, )));
+  const resolveAssetUrl = _nullishCoalesce(options.resolveAssetUrl, () => ( _chunkND5XJVK2cjs.sanitizeHref));
+  const engine = _chunkND5XJVK2cjs.engineBlocksOf.call(void 0, blocks, schema);
+  const urls = engine.filter((block) => block.type === "IMAGE").map((block) => pictureUrl(block, resolveAssetUrl));
+  const images = await loadImages(
+    urls.filter((url) => url !== null),
+    {
+      fetchAsset: options.fetchAsset,
+      timeout: _nullishCoalesce(options.imageTimeout, () => ( IMAGE_TIMEOUT)),
+      concurrency: _nullishCoalesce(options.imageConcurrency, () => ( IMAGE_CONCURRENCY))
+    }
+  );
+  const ctx = createContext({ schema, resolveAssetUrl, headings: _chunkND5XJVK2cjs.collectHeadings.call(void 0, engine, schema), images });
+  const mainPart = documentXml(_chunkND5XJVK2cjs.groupBlocks.call(void 0, engine), ctx);
+  const archive = await zipArchive([
+    { path: "[Content_Types].xml", data: encode(contentTypesXml(ctx.media)) },
+    { path: "_rels/.rels", data: encode(packageRelationshipsXml()) },
+    { path: "docProps/core.xml", data: encode(corePropertiesXml(options.title)) },
+    { path: "word/document.xml", data: encode(mainPart) },
+    { path: "word/styles.xml", data: encode(stylesXml()) },
+    { path: "word/numbering.xml", data: encode(numberingXml2(ctx.lists)) },
+    { path: "word/_rels/document.xml.rels", data: encode(documentRelationshipsXml(ctx.relationships)) },
+    ...ctx.media.map(({ path, data }) => ({ path, data }))
+  ]);
+  return new Blob([archive], { type: WORD_TYPE });
+}
+
+
+exports.toDocx = toDocx;
+//# sourceMappingURL=docx.cjs.map