@portone/docx-editor 0.1.0

package/dist/page/pageLayout.d.ts

@@ -0,0 +1,176 @@
+/**
+ * The arithmetic that makes one continuous sheet look like separate pages.
+ *
+ * The push amounts, the space opened at each page break and the places where a gap opens up
+ * between pages are all decided here in one pass, and the view simply uses those values.
+ * A page break is the one thing split inside a block; nothing else is broken line by line, so
+ * the places where Word actually breaks may differ.
+ *
+ * The size of a page is the document's own (`docx/pageGeometry`), not a fixed A4: a Letter
+ * document breaks at Letter's height and fits its tables to Letter's width.
+ */
+import { type PageGeometry } from "../docx/pageGeometry";
+/** The paper measured in the pixels the sheet is drawn with */
+export interface PagePixels {
+    /** The whole sheet, padding included */
+    pageWidth: number;
+    pageHeight: number;
+    /** The width one line of body text occupies: the sheet less its side padding */
+    bodyWidth: number;
+    /** The height the body occupies on one page */
+    bodyHeight: number;
+    marginLeft: number;
+    marginRight: number;
+    marginTop: number;
+    marginBottom: number;
+    /** From the end of one page's body to the top of the next page's body */
+    pageStep: number;
+}
+/** The grey gap visible between one page and the next. The one number the paper does not decide */
+export declare const PAGE_SPLIT_PX = 24;
+/**
+ * The paper as the sheet draws it.
+ *
+ * Every width and height on screen comes from here, so the document's own `w:pgSz` and
+ * `w:pgMar` decide the sheet, the page breaks, and the width a table or an image is fitted to.
+ */
+export declare function pagePixels(geometry: PageGeometry): PagePixels;
+/** The paper a document that names none is drawn on */
+export declare const A4_PAGE_PIXELS: PagePixels;
+/**
+ * The paper the document names, as the CSS variables the sheet is drawn from.
+ *
+ * The page breaks above are worked out from the same geometry, so the divider drawn between
+ * pages lands where the paper actually ends. `editor.css` carries A4 as the fallback for the
+ * moment before a document is opened.
+ */
+export declare function pageGeometryStyle(page: PagePixels): string;
+/** One body block as drawn on screen */
+export interface MeasuredBlock {
+    /** The position where this block starts in the document */
+    pos: number;
+    /** The height that naturally opens up between the previous block and this one */
+    gap: number;
+    height: number;
+    /** Set when the document records that a new page starts at this block */
+    breakBefore: boolean;
+    /**
+     * Every page break inside the block, in document order, each measured from the block's own top
+     * so that the block can be laid out wherever it lands.
+     * That top is the one the block would be drawn at with no space in it, so a space opened at one
+     * break shifts the ones after it.
+     */
+    breaks: readonly number[];
+    /** Row boundaries available when this block is an editable table */
+    table?: MeasuredTable;
+}
+/** A row that may start the continued part of a table */
+export interface TableBoundary {
+    /** The row's document position */
+    pos: number;
+    /** Its top measured from the table's natural top */
+    offset: number;
+}
+/** The measurements needed to continue a table without changing the document */
+export interface MeasuredTable {
+    boundaries: readonly TableBoundary[];
+    /** The smallest useful first piece: headers followed by one body row group */
+    firstPageMinimum: number;
+    repeatHeaderHeight: number;
+    /** Document positions of the contiguous header rows at the start of the table */
+    headerRows: readonly number[];
+    /** Changes when any projected header content or formatting changes */
+    headerSignature: string;
+    columns: number;
+}
+/** The space opened up at one page break, so that what follows it starts the next page */
+export interface BreakSpace {
+    /** The position where the block holding the break starts */
+    pos: number;
+    /** Which break inside that block, counted in document order */
+    index: number;
+    height: number;
+}
+/** One block to be moved down to the next page */
+export interface BlockPush {
+    pos: number;
+    /** The gap to place above the block: the original gap plus the push */
+    marginTop: number;
+    /** Of that, the extra amount pushed for the page's sake */
+    push: number;
+}
+/** A display-only row inserted before the row that continues on the next page */
+export interface TableContinuation {
+    /** The position of the first original row on the next page */
+    pos: number;
+    /** Space from the previous page's row boundary to the next page body */
+    height: number;
+    /** Header rows to project immediately after the space */
+    headerRows: readonly number[];
+    headerSignature: string;
+    columns: number;
+}
+/** A place where one page parts from the next */
+export interface PageSplit {
+    /** Where the previous page's body ends, measured from the top of the body */
+    y: number;
+    /** The number of the page that follows this place */
+    page: number;
+    /** Whether the document records a break at this place */
+    forced: boolean;
+    /**
+     * Whether every place before this one was recorded by the document, so the number can
+     * be trusted
+     */
+    exactPage: boolean;
+    /**
+     * Whether the block is taller than one page, so it cannot be pushed and the text
+     * crosses this place
+     */
+    crossed: boolean;
+}
+/** Where one page starts */
+export interface PageStart {
+    page: number;
+    /** Where this page's body starts, measured from the top of the body */
+    bodyStart: number;
+    /**
+     * Whether every place before this one was recorded by the document, so the number can
+     * be trusted
+     */
+    exactPage: boolean;
+    /**
+     * Whether text crosses over from the previous page, so this page continues with no top
+     * margin
+     */
+    crossed: boolean;
+}
+export interface PageLayout {
+    /** Only the blocks to be moved down to the next page */
+    pushes: BlockPush[];
+    spaces: BreakSpace[];
+    tableContinuations: TableContinuation[];
+    splits: PageSplit[];
+    /** One per page, the first page included */
+    pages: PageStart[];
+    /** The body height with the last page filled out in full */
+    bodyHeight: number;
+}
+export interface PageLayoutInput {
+    blocks: readonly MeasuredBlock[];
+    pageBodyHeight: number;
+    /** From the end of the previous page's body to the top of the next page's body */
+    pageStep: number;
+}
+/**
+ * Distributes the blocks across pages.
+ *
+ * A block straddling the end of a page is pushed to the top of the next page, and the
+ * blocks below it move down by the same amount.
+ * A block taller than one page cannot be pushed, so it is left where it is and only the
+ * places it crosses are reported.
+ * A page break inside a block is filled out to the end of the page it falls on, which carries
+ * the rest of that block - the rest of the sentence, the rest of the list item - to the top of
+ * the next page while the block itself stays whole.
+ */
+export declare function pageLayout({ blocks, pageBodyHeight, pageStep, }: PageLayoutInput): PageLayout;

package/dist/page/pageLayout.js

@@ -0,0 +1,157 @@
+// src/page/pageLayout.ts
+import {
+  A4_PORTRAIT,
+  bodyHeightTwips,
+  bodyWidth,
+  twipsToPx
+} from "../docx/pageGeometry.js";
+import { editorCssVariables } from "../styles/classNames.js";
+var PAGE_SPLIT_PX = 24;
+function pagePixels(geometry) {
+  const marginTop = twipsToPx(geometry.marginTopTwips);
+  const marginBottom = twipsToPx(geometry.marginBottomTwips);
+  return {
+    pageWidth: twipsToPx(geometry.widthTwips),
+    pageHeight: twipsToPx(geometry.heightTwips),
+    // The same width a table is fitted to, so the sheet and the tables on it cannot drift
+    bodyWidth: bodyWidth(geometry).px,
+    bodyHeight: twipsToPx(bodyHeightTwips(geometry)),
+    marginLeft: twipsToPx(geometry.marginLeftTwips),
+    marginRight: twipsToPx(geometry.marginRightTwips),
+    marginTop,
+    marginBottom,
+    pageStep: marginTop + marginBottom + PAGE_SPLIT_PX
+  };
+}
+var A4_PAGE_PIXELS = pagePixels(A4_PORTRAIT);
+function px(value) {
+  return `${Math.round(value * 100) / 100}px`;
+}
+function pageGeometryStyle(page) {
+  return [
+    `${editorCssVariables.pageWidth}:${px(page.pageWidth)}`,
+    `${editorCssVariables.pageHeight}:${px(page.pageHeight)}`,
+    `${editorCssVariables.pageMarginTop}:${px(page.marginTop)}`,
+    `${editorCssVariables.pageMarginRight}:${px(page.marginRight)}`,
+    `${editorCssVariables.pageMarginBottom}:${px(page.marginBottom)}`,
+    `${editorCssVariables.pageMarginLeft}:${px(page.marginLeft)}`
+  ].join(";");
+}
+var TOLERANCE_PX = 0.5;
+function round(value) {
+  return Math.round(value * 100) / 100;
+}
+function pageLayout({
+  blocks,
+  pageBodyHeight,
+  pageStep
+}) {
+  const pushes = [];
+  const spaces = [];
+  const tableContinuations = [];
+  const splits = [];
+  const firstPage = {
+    page: 1,
+    bodyStart: 0,
+    exactPage: true,
+    crossed: false
+  };
+  const pages = [firstPage];
+  if (!(pageBodyHeight > 0)) {
+    return {
+      pushes,
+      spaces,
+      tableContinuations,
+      splits,
+      pages,
+      bodyHeight: 0
+    };
+  }
+  let pageStart = 0;
+  let cursor = 0;
+  let exactPage = true;
+  const split = (y, crossed, forced) => {
+    if (!forced) exactPage = false;
+    const page = splits.length + 2;
+    splits.push({ y: round(y), page, forced, exactPage, crossed });
+    pageStart = crossed ? y : y + pageStep;
+    pages.push({ page, bodyStart: round(pageStart), exactPage, crossed });
+  };
+  const crossTo = (y) => {
+    while (y > pageStart + pageBodyHeight + TOLERANCE_PX) {
+      split(pageStart + pageBodyHeight, true, false);
+    }
+  };
+  for (const block of blocks) {
+    const pageEnd = pageStart + pageBodyHeight;
+    const top = cursor + block.gap;
+    const startsPage = block.breakBefore && top > pageStart + TOLERANCE_PX;
+    const first = block.breaks[0] ?? block.table?.firstPageMinimum ?? block.height;
+    const overflows = top + first > pageEnd + TOLERANCE_PX;
+    const fits = first <= pageBodyHeight + TOLERANCE_PX;
+    const push = startsPage || overflows && fits ? Math.max(0, pageEnd + pageStep - top) : 0;
+    if (push > 0 || startsPage) split(pageEnd, false, startsPage);
+    if (push > 0) {
+      pushes.push({
+        pos: block.pos,
+        marginTop: round(block.gap + push),
+        push: round(push)
+      });
+    }
+    let contentTop = top + push;
+    for (const [index, offset] of block.breaks.entries()) {
+      const breakY = contentTop + offset;
+      crossTo(breakY);
+      split(pageStart + pageBodyHeight, false, true);
+      const height = Math.max(0, pageStart - breakY);
+      spaces.push({ pos: block.pos, index, height: round(height) });
+      contentTop += height;
+    }
+    let tableAdded = 0;
+    if (block.table) {
+      let segmentStart = 0;
+      for (let index = 0; index <= block.table.boundaries.length; index += 1) {
+        const segmentEnd = block.table.boundaries[index]?.offset ?? block.height;
+        const segmentTop = contentTop + segmentStart + tableAdded;
+        let segmentBottom = contentTop + segmentEnd + tableAdded;
+        const pageEnd2 = pageStart + pageBodyHeight;
+        const overflows2 = segmentBottom > pageEnd2 + TOLERANCE_PX;
+        const boundary = index === 0 ? null : block.table.boundaries[index - 1];
+        const segmentHeight = segmentEnd - segmentStart;
+        if (overflows2 && boundary && segmentTop > pageStart + TOLERANCE_PX && segmentHeight <= pageBodyHeight + TOLERANCE_PX) {
+          split(pageEnd2, false, false);
+          const height = Math.max(0, pageStart - segmentTop);
+          tableContinuations.push({
+            pos: boundary.pos,
+            height: round(height),
+            headerRows: block.table.headerRows,
+            headerSignature: block.table.headerSignature,
+            columns: block.table.columns
+          });
+          tableAdded += height + block.table.repeatHeaderHeight;
+          segmentBottom = contentTop + segmentEnd + tableAdded;
+        }
+        crossTo(segmentBottom);
+        segmentStart = segmentEnd;
+      }
+    }
+    const bottom = contentTop + block.height + tableAdded;
+    crossTo(bottom);
+    cursor = bottom;
+  }
+  return {
+    pushes,
+    spaces,
+    tableContinuations,
+    splits,
+    pages,
+    bodyHeight: round(pageStart + pageBodyHeight)
+  };
+}
+export {
+  A4_PAGE_PIXELS,
+  PAGE_SPLIT_PX,
+  pageGeometryStyle,
+  pageLayout,
+  pagePixels
+};

package/dist/page/tableMeasurements.d.ts

@@ -0,0 +1,10 @@
+/** Measures safe row boundaries without treating pagination decorations as document content. */
+import type { Node as PMNode } from "prosemirror-model";
+import type { EditorView } from "prosemirror-view";
+import type { MeasuredTable } from "./pageLayout";
+export interface TableMeasure {
+    table: MeasuredTable;
+    /** Height already added by the previous pagination pass */
+    appliedHeight: number;
+}
+export declare function measureTable(view: EditorView, tableNode: PMNode, tablePos: number, tableDom: HTMLElement, scale?: number): TableMeasure | null;

package/dist/page/tableMeasurements.js

@@ -0,0 +1,115 @@
+// src/page/tableMeasurements.ts
+import { toRowFormat } from "../model/format.js";
+import { editorAttributes } from "../styles/classNames.js";
+function span(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : 1;
+}
+function paginationRows(table) {
+  return Array.from(
+    table.querySelectorAll(
+      `[${editorAttributes.tablePageSpace}],[${editorAttributes.tableRepeatedHeader}]`
+    )
+  );
+}
+function before(candidate, row) {
+  return Boolean(
+    candidate.compareDocumentPosition(row) & Node.DOCUMENT_POSITION_FOLLOWING
+  );
+}
+function rowEntries(view, tableNode, tablePos, tableDom, appliedRows, scale) {
+  const entries = [];
+  const tableTop = tableDom.getBoundingClientRect().top;
+  tableNode.forEach((row, offset) => {
+    const pos = tablePos + 1 + offset;
+    const dom = view.nodeDOM(pos);
+    if (!(dom instanceof HTMLElement)) return;
+    const rect = dom.getBoundingClientRect();
+    const appliedBefore = appliedRows.reduce(
+      (total, candidate) => total + (before(candidate, dom) ? candidate.getBoundingClientRect().height / scale : 0),
+      0
+    );
+    entries.push({
+      node: row,
+      pos,
+      top: (rect.top - tableTop) / scale - appliedBefore,
+      height: rect.height / scale
+    });
+  });
+  return entries;
+}
+function unsafeBoundaries(rows) {
+  const unsafe = /* @__PURE__ */ new Set();
+  rows.forEach((row, rowIndex) => {
+    row.node.forEach((cell) => {
+      const bottom = Math.min(rows.length, rowIndex + span(cell.attrs.rowspan));
+      for (let boundary = rowIndex + 1; boundary < bottom; boundary += 1) {
+        unsafe.add(boundary);
+      }
+    });
+  });
+  return unsafe;
+}
+function headerCount(rows) {
+  let count = 0;
+  while (count < rows.length && toRowFormat(rows[count]?.node.attrs.format)?.repeatHeader === true) {
+    count += 1;
+  }
+  return count;
+}
+function columnCount(tableNode) {
+  const grid = tableNode.attrs.gridCols;
+  if (Array.isArray(grid) && grid.length > 0) return grid.length;
+  const first = tableNode.firstChild;
+  if (!first) return 1;
+  let columns = 0;
+  first.forEach((cell) => {
+    columns += span(cell.attrs.colspan);
+  });
+  return Math.max(1, columns);
+}
+function measureTable(view, tableNode, tablePos, tableDom, scale = 1) {
+  if (tableNode.type.spec.tableRole !== "table") return null;
+  const appliedRows = paginationRows(tableDom);
+  const rows = rowEntries(
+    view,
+    tableNode,
+    tablePos,
+    tableDom,
+    appliedRows,
+    scale
+  );
+  if (rows.length === 0) return null;
+  const headers = headerCount(rows);
+  const unsafe = unsafeBoundaries(rows);
+  const boundaries = [];
+  for (let rowIndex = Math.max(1, headers); rowIndex < rows.length; rowIndex += 1) {
+    const row = rows[rowIndex];
+    if (row && !unsafe.has(rowIndex)) {
+      boundaries.push({ pos: row.pos, offset: row.top });
+    }
+  }
+  const repeatHeaderHeight = rows.slice(0, headers).reduce((total, row) => total + row.height, 0);
+  const firstBodyBoundary = boundaries.find(
+    (boundary) => boundary.offset > repeatHeaderHeight + 0.5
+  );
+  const appliedHeight = appliedRows.reduce(
+    (total, row) => total + row.getBoundingClientRect().height / scale,
+    0
+  );
+  return {
+    table: {
+      boundaries,
+      firstPageMinimum: firstBodyBoundary?.offset ?? tableDom.getBoundingClientRect().height / scale - appliedHeight,
+      repeatHeaderHeight,
+      headerRows: rows.slice(0, headers).map((row) => row.pos),
+      headerSignature: JSON.stringify(
+        rows.slice(0, headers).map((row) => row.node.toJSON())
+      ),
+      columns: columnCount(tableNode)
+    },
+    appliedHeight
+  };
+}
+export {
+  measureTable
+};

package/dist/page/usePageLayout.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Measures the sheet, moves straddling blocks down to the next page, and hands the
+ * page-boundary positions over to the view. It remeasures whenever the text changes or the
+ * box is resized.
+ *
+ * A measurement hands new pushes and break spaces to the view (`./pageDecorations`), which is a
+ * decoration transaction against the very paragraph an IME may be composing in, and a composition
+ * in Japanese or Chinese stays open across a whole clause while the text grows line by line. So no
+ * measurement is taken while a composition is open: the frame is taken again until it is over.
+ */
+import type { EditorView } from "prosemirror-view";
+import { type RefObject } from "react";
+import type { PageGeometry } from "../docx/pageGeometry";
+/** One place where a page parts from the next. The position is measured on the sheet */
+export interface PageMark {
+    page: number;
+    top: number;
+    /** The height of the gap between pages. 0 where the text crosses the boundary */
+    height: number;
+    crossed: boolean;
+}
+/** The number laid on the corner of a page */
+export interface PageBadge {
+    page: number;
+    top: number;
+    exactPage: boolean;
+}
+/** The paper area of one visual page, used to place its header and footer stories. */
+export interface PageFace {
+    page: number;
+    headerTop: number;
+    footerTop: number;
+    left: number;
+    width: number;
+    crossed: boolean;
+}
+export interface PageOverlay {
+    left: number;
+    top: number;
+    width: number;
+    /** The sheet height with the last page filled out in full */
+    sheetHeight: number;
+    marks: PageMark[];
+    badges: PageBadge[];
+    pages: PageFace[];
+}
+interface PageLayoutOptions {
+    view: EditorView | null;
+    layer: RefObject<HTMLElement | null>;
+    enabled: boolean;
+    /** A value that differs every time the text changes */
+    revision: unknown;
+    /** The paper the open document names. A4 where a document names none */
+    geometry?: PageGeometry;
+}
+export declare function usePageLayout({ view, layer, enabled, revision, geometry, }: PageLayoutOptions): PageOverlay | null;
+export {};

package/dist/page/usePageLayout.js

@@ -0,0 +1,141 @@
+// src/page/usePageLayout.ts
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import { editorCssVariables } from "../styles/classNames.js";
+import { measureSheet } from "./measureBlocks.js";
+import {
+  setPageBreakSpaces,
+  setPagePushes,
+  setTableContinuations
+} from "./pageDecorations.js";
+import {
+  A4_PAGE_PIXELS,
+  PAGE_SPLIT_PX,
+  pageLayout,
+  pagePixels
+} from "./pageLayout.js";
+var BADGE_INSET_PX = 8;
+function useFrameThrottle(run, hold) {
+  const latest = useRef({ run, hold });
+  const frame = useRef(0);
+  useEffect(() => {
+    latest.current = { run, hold };
+  });
+  useEffect(() => {
+    return () => {
+      if (frame.current !== 0) {
+        cancelAnimationFrame(frame.current);
+        frame.current = 0;
+      }
+    };
+  }, []);
+  return useCallback(() => {
+    if (frame.current !== 0) return;
+    const take = () => {
+      frame.current = requestAnimationFrame(() => {
+        if (latest.current.hold()) {
+          take();
+          return;
+        }
+        frame.current = 0;
+        latest.current.run();
+      });
+    };
+    take();
+  }, []);
+}
+function sameOverlay(a, b) {
+  return a !== null && a.left === b.left && a.top === b.top && a.width === b.width && a.sheetHeight === b.sheetHeight && JSON.stringify(a.marks) === JSON.stringify(b.marks) && JSON.stringify(a.badges) === JSON.stringify(b.badges) && JSON.stringify(a.pages) === JSON.stringify(b.pages);
+}
+function usePageLayout({
+  view,
+  layer,
+  enabled,
+  revision,
+  geometry
+}) {
+  const [overlay, setOverlay] = useState(null);
+  const page = useMemo(
+    () => geometry ? pagePixels(geometry) : A4_PAGE_PIXELS,
+    [geometry]
+  );
+  const remeasure = useFrameThrottle(
+    () => {
+      const box = layer.current;
+      if (!view || !box || !enabled) return;
+      const measured = measureSheet(view, box);
+      const layout = pageLayout({
+        blocks: measured.blocks,
+        pageBodyHeight: page.bodyHeight,
+        pageStep: page.pageStep
+      });
+      setPagePushes(view, layout.pushes);
+      setPageBreakSpaces(view, layout.spaces);
+      setTableContinuations(view, layout.tableContinuations);
+      const sheetHeight = measured.contentTop + layout.bodyHeight + measured.contentBottom;
+      box.style.setProperty(editorCssVariables.sheetHeight, `${sheetHeight}px`);
+      const next = {
+        left: measured.left,
+        top: measured.top,
+        width: measured.width,
+        sheetHeight,
+        marks: layout.splits.map((split) => ({
+          page: split.page,
+          top: measured.contentTop + split.y + (split.crossed ? 0 : page.marginBottom),
+          height: split.crossed ? 0 : PAGE_SPLIT_PX,
+          crossed: split.crossed
+        })),
+        // The number is laid on the page's top corner. A page crossed into has no margin,
+        // so the place it was split at is its corner
+        badges: layout.pages.map((start) => ({
+          page: start.page,
+          top: measured.contentTop + start.bodyStart - (start.crossed ? 0 : page.marginTop) + BADGE_INSET_PX,
+          exactPage: start.exactPage
+        })),
+        pages: layout.pages.map((start) => {
+          const paperTop = measured.contentTop + start.bodyStart - (start.crossed ? 0 : page.marginTop);
+          return {
+            page: start.page,
+            headerTop: paperTop + page.marginTop / 2,
+            footerTop: paperTop + page.pageHeight - page.marginBottom / 2,
+            left: page.marginLeft,
+            width: page.bodyWidth,
+            crossed: start.crossed
+          };
+        })
+      };
+      setOverlay((previous) => sameOverlay(previous, next) ? previous : next);
+    },
+    () => view?.composing === true
+  );
+  useEffect(() => {
+    if (enabled) remeasure();
+  }, [remeasure, revision, enabled]);
+  useEffect(() => {
+    if (enabled) return;
+    layer.current?.style.removeProperty(editorCssVariables.sheetHeight);
+    if (!view) return;
+    setPagePushes(view, []);
+    setPageBreakSpaces(view, []);
+    setTableContinuations(view, []);
+  }, [enabled, layer, view]);
+  useEffect(() => {
+    const box = layer.current;
+    if (!view || !box || !enabled || typeof ResizeObserver === "undefined") {
+      return;
+    }
+    const observer = new ResizeObserver(remeasure);
+    observer.observe(view.dom);
+    observer.observe(box);
+    return () => observer.disconnect();
+  }, [view, layer, enabled, remeasure]);
+  return enabled ? overlay : null;
+}
+export {
+  usePageLayout
+};

package/dist/schema/docxSchema.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ProseMirror schema joining preserved DOCX fragments with validated display values. Original XML
+ * remains on nodes and marks so untouched content can round-trip verbatim.
+ */
+import { Schema } from "prosemirror-model";
+export { imageNodeSpec, runMarkSpec } from "./rendering";
+/** Whether this is a page-splitting break (`<w:br w:type="page"/>`). Read straight from the original attribute text */
+export declare function isPageBreak(brAttrs: unknown): boolean;
+export declare const docxSchema: Schema<"bookmarkBlock" | "commentEnd" | "commentReference" | "commentStart" | "doc" | "docxRaw" | "hardBreak" | "image" | "noteReference" | "paragraph" | "rawBlock" | "rawInline" | "table" | "tableCell" | "tableRow" | "text", "link" | "run" | "sdt" | "tab">;