@portone/docx-editor 0.1.0

package/dist/model/format.js

@@ -0,0 +1,305 @@
+// src/model/format.ts
+var ALIGNS = ["left", "center", "right", "justify"];
+var VERTICAL_ALIGNS = ["superscript", "subscript"];
+var CELL_VERTICAL_ALIGNS = ["top", "center", "bottom"];
+var NO_FILL = "none";
+var UNDERLINES = [
+  "single",
+  "words",
+  "double",
+  "thick",
+  "dotted",
+  "dottedHeavy",
+  "dash",
+  "dashedHeavy",
+  "dashLong",
+  "dashLongHeavy",
+  "dotDash",
+  "dashDotHeavy",
+  "dotDotDash",
+  "dashDotDotHeavy",
+  "wave",
+  "wavyHeavy",
+  "wavyDouble"
+];
+var HIGHLIGHTS = [
+  "black",
+  "blue",
+  "cyan",
+  "darkBlue",
+  "darkCyan",
+  "darkGray",
+  "darkGreen",
+  "darkMagenta",
+  "darkRed",
+  "darkYellow",
+  "green",
+  "lightGray",
+  "magenta",
+  "red",
+  "white",
+  "yellow"
+];
+function isUnderlineKind(value) {
+  return UNDERLINES.some((kind) => kind === value);
+}
+function isHighlightName(value) {
+  return HIGHLIGHTS.some((name) => name === value);
+}
+function widthNumber(width) {
+  if (width.type === "dxa") return width.twips;
+  if (width.type === "pct") return width.fiftieths;
+  return null;
+}
+function withWidthNumber(width, value) {
+  if (width.type === "dxa") return { type: "dxa", twips: value };
+  if (width.type === "pct") return { type: "pct", fiftieths: value };
+  return width;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var HEX_COLOR = /^#[0-9a-fA-F]{6}$/;
+var BORDER_CSS = /^(none|\d+(\.\d{1,2})?pt (solid|double|dotted|dashed) #[0-9a-fA-F]{6})$/;
+var FILL = /^(none|#[0-9a-fA-F]{6})$/;
+var FONT_FAMILY = /^"[^"';]+"(,"[^"';]+")*$/;
+var LANGUAGE_TAG = /^[A-Za-z]{1,8}(-[A-Za-z0-9]{1,8}){0,4}$/;
+function matching(pattern, value) {
+  return typeof value === "string" && pattern.test(value) ? value : void 0;
+}
+function isAlign(value) {
+  return ALIGNS.some((align) => align === value);
+}
+function isVerticalAlign(value) {
+  return VERTICAL_ALIGNS.some((align) => align === value);
+}
+function toLineSpacing(value) {
+  if (!isRecord(value)) return null;
+  if (value.rule === "auto" && typeof value.lines === "number") {
+    return { rule: "auto", lines: value.lines };
+  }
+  if (typeof value.pt !== "number") return null;
+  if (value.rule === "exact") return { rule: "exact", pt: value.pt };
+  if (value.rule === "atLeast") return { rule: "atLeast", pt: value.pt };
+  return null;
+}
+function toNumberingRef(value) {
+  if (!isRecord(value)) return null;
+  const { numId, ilvl } = value;
+  if (typeof numId !== "number" || typeof ilvl !== "number") return null;
+  return { numId, ilvl };
+}
+var TAB_ALIGNMENTS = [
+  "start",
+  "center",
+  "end",
+  "decimal",
+  "num",
+  "bar"
+];
+var TAB_LEADERS = [
+  "none",
+  "dot",
+  "hyphen",
+  "underscore",
+  "heavy",
+  "middleDot"
+];
+function toTabStops(value) {
+  if (!Array.isArray(value)) return null;
+  const stops = [];
+  for (const entry of value) {
+    if (!isRecord(entry) || typeof entry.positionPt !== "number" || !Number.isFinite(entry.positionPt)) {
+      continue;
+    }
+    const align = TAB_ALIGNMENTS.find((candidate) => candidate === entry.align);
+    if (!align) continue;
+    const leader = TAB_LEADERS.find((candidate) => candidate === entry.leader);
+    stops.push({
+      positionPt: entry.positionPt,
+      align,
+      ...leader === void 0 ? {} : { leader }
+    });
+  }
+  return stops.length > 0 ? stops : null;
+}
+function toParagraphFormat(value) {
+  if (!isRecord(value)) return null;
+  const format = {};
+  if (isAlign(value.align)) format.align = value.align;
+  if (value.direction === "ltr" || value.direction === "rtl")
+    format.direction = value.direction;
+  if (typeof value.indentLeftPt === "number")
+    format.indentLeftPt = value.indentLeftPt;
+  if (typeof value.indentRightPt === "number")
+    format.indentRightPt = value.indentRightPt;
+  if (typeof value.indentStartPt === "number")
+    format.indentStartPt = value.indentStartPt;
+  if (typeof value.indentEndPt === "number")
+    format.indentEndPt = value.indentEndPt;
+  if (typeof value.textIndentPt === "number")
+    format.textIndentPt = value.textIndentPt;
+  if (typeof value.spaceBeforePt === "number")
+    format.spaceBeforePt = value.spaceBeforePt;
+  if (typeof value.spaceAfterPt === "number")
+    format.spaceAfterPt = value.spaceAfterPt;
+  const lineSpacing = toLineSpacing(value.lineSpacing);
+  if (lineSpacing) format.lineSpacing = lineSpacing;
+  const numbering = toNumberingRef(value.numbering);
+  if (numbering) format.numbering = numbering;
+  const tabStops = toTabStops(value.tabStops);
+  if (tabStops) format.tabStops = tabStops;
+  if (value.pageBreakBefore === true) format.pageBreakBefore = true;
+  copyBorders(value, format);
+  const background = matching(FILL, value.background);
+  if (background) format.background = background;
+  return format;
+}
+function toRunFormat(value) {
+  if (!isRecord(value)) return null;
+  const format = {};
+  if (value.bold === true) format.bold = true;
+  if (value.italic === true) format.italic = true;
+  if (value.strike === true) format.strike = true;
+  if (value.smallCaps === true) format.smallCaps = true;
+  if (isUnderlineKind(value.underline)) format.underline = value.underline;
+  if (typeof value.fontSizePt === "number")
+    format.fontSizePt = value.fontSizePt;
+  const fontFamily = matching(FONT_FAMILY, value.fontFamily);
+  if (fontFamily) format.fontFamily = fontFamily;
+  const color = matching(HEX_COLOR, value.color);
+  if (color) format.color = color;
+  if (isHighlightName(value.highlight)) format.highlight = value.highlight;
+  const background = matching(FILL, value.background);
+  if (background) format.background = background;
+  if (isVerticalAlign(value.verticalAlign))
+    format.verticalAlign = value.verticalAlign;
+  const lang = matching(LANGUAGE_TAG, value.lang);
+  if (lang) format.lang = lang;
+  return format;
+}
+function isCellVerticalAlign(value) {
+  return CELL_VERTICAL_ALIGNS.some((align) => align === value);
+}
+function toTableWidth(value) {
+  if (!isRecord(value)) return null;
+  if (value.type === "auto") return { type: "auto" };
+  if (value.type === "nil") return { type: "nil" };
+  if (value.type === "dxa" && typeof value.twips === "number")
+    return { type: "dxa", twips: value.twips };
+  if (value.type === "pct" && typeof value.fiftieths === "number")
+    return { type: "pct", fiftieths: value.fiftieths };
+  return null;
+}
+function toGridCols(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "number");
+}
+function toColWidth(value) {
+  if (!Array.isArray(value)) return null;
+  const widths = value.filter(
+    (entry) => typeof entry === "number"
+  );
+  return widths.length === value.length && widths.length > 0 ? widths : null;
+}
+function copyBorders(value, format) {
+  const top = matching(BORDER_CSS, value.borderTop);
+  if (top) format.borderTop = top;
+  const bottom = matching(BORDER_CSS, value.borderBottom);
+  if (bottom) format.borderBottom = bottom;
+  const left = matching(BORDER_CSS, value.borderLeft);
+  if (left) format.borderLeft = left;
+  const right = matching(BORDER_CSS, value.borderRight);
+  if (right) format.borderRight = right;
+}
+function toTableFormat(value) {
+  if (!isRecord(value)) return null;
+  const format = {};
+  copyBorders(value, format);
+  const background = matching(FILL, value.background);
+  if (background) format.background = background;
+  if (isAlign(value.align)) format.align = value.align;
+  if (typeof value.indentLeftPt === "number")
+    format.indentLeftPt = value.indentLeftPt;
+  return format;
+}
+function toInsideBorders(value) {
+  if (!isRecord(value)) return null;
+  const horizontal = matching(BORDER_CSS, value.horizontal) ?? null;
+  const vertical = matching(BORDER_CSS, value.vertical) ?? null;
+  if (horizontal === null && vertical === null) return null;
+  return { horizontal, vertical };
+}
+function marginSide(value) {
+  return typeof value === "number" ? value : null;
+}
+function toCellMargins(value) {
+  if (!isRecord(value)) return null;
+  const margins = {
+    topPt: marginSide(value.topPt),
+    rightPt: marginSide(value.rightPt),
+    bottomPt: marginSide(value.bottomPt),
+    leftPt: marginSide(value.leftPt)
+  };
+  const sides = [
+    margins.topPt,
+    margins.rightPt,
+    margins.bottomPt,
+    margins.leftPt
+  ];
+  return sides.every((side) => side === null) ? null : margins;
+}
+function toRowHeight(value) {
+  if (!isRecord(value) || typeof value.pt !== "number") return null;
+  if (value.rule === "exact") return { rule: "exact", pt: value.pt };
+  if (value.rule === "atLeast") return { rule: "atLeast", pt: value.pt };
+  return null;
+}
+function toRowFormat(value) {
+  if (!isRecord(value)) return null;
+  const format = {};
+  const height = toRowHeight(value.height);
+  if (height) format.height = height;
+  if (value.repeatHeader === true) format.repeatHeader = true;
+  if (value.cantSplit === true) format.cantSplit = true;
+  return format;
+}
+function toCellFormat(value) {
+  if (!isRecord(value)) return null;
+  const format = {};
+  copyBorders(value, format);
+  const background = matching(FILL, value.background);
+  if (background) format.background = background;
+  if (isCellVerticalAlign(value.verticalAlign))
+    format.verticalAlign = value.verticalAlign;
+  if (typeof value.paddingTopPt === "number")
+    format.paddingTopPt = value.paddingTopPt;
+  if (typeof value.paddingRightPt === "number")
+    format.paddingRightPt = value.paddingRightPt;
+  if (typeof value.paddingBottomPt === "number")
+    format.paddingBottomPt = value.paddingBottomPt;
+  if (typeof value.paddingLeftPt === "number")
+    format.paddingLeftPt = value.paddingLeftPt;
+  return format;
+}
+function spanCount(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : 1;
+}
+export {
+  NO_FILL,
+  isHighlightName,
+  isUnderlineKind,
+  spanCount,
+  toCellFormat,
+  toCellMargins,
+  toColWidth,
+  toGridCols,
+  toInsideBorders,
+  toParagraphFormat,
+  toRowFormat,
+  toRunFormat,
+  toTableFormat,
+  toTableWidth,
+  widthNumber,
+  withWidthNumber
+};

package/dist/model/tabStops.d.ts

@@ -0,0 +1,17 @@
+export type TabAlignment = "start" | "center" | "end" | "decimal" | "num";
+export type TabLeader = "none" | "dot" | "hyphen" | "underscore" | "heavy" | "middleDot";
+/** One effective custom tab entry. Positions are points from the paragraph's leading margin. */
+export interface TabStop {
+    positionPt: number;
+    align: TabAlignment | "bar";
+    leader?: TabLeader;
+}
+/** A tab entry before the paragraph-property hierarchy has been resolved. */
+export type TabStopDirective = TabStop | {
+    positionPt: number;
+    align: "clear";
+};
+/** Composes two OOXML tab-property layers while retaining clears for a lower layer. */
+export declare function layerTabStopDirectives(base: readonly TabStopDirective[], over: readonly TabStopDirective[]): TabStopDirective[];
+/** Resolves the final OOXML tab-property layers, removing cleared positions. */
+export declare function mergeTabStops(base: readonly TabStopDirective[], over: readonly TabStopDirective[]): TabStop[];

package/dist/model/tabStops.js

@@ -0,0 +1,22 @@
+// src/model/tabStops.ts
+function layerTabStopDirectives(base, over) {
+  const stops = /* @__PURE__ */ new Map();
+  for (const stop of base) {
+    stops.set(stop.positionPt, stop);
+  }
+  for (const stop of over) {
+    stops.set(stop.positionPt, stop);
+  }
+  return [...stops.values()].sort(
+    (left, right) => left.positionPt - right.positionPt
+  );
+}
+function mergeTabStops(base, over) {
+  return layerTabStopDirectives(base, over).filter(
+    (stop) => stop.align !== "clear"
+  );
+}
+export {
+  layerTabStopDirectives,
+  mergeTabStops
+};

package/dist/numbering/listTemplate.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The standard shape of a newly started list.
+ *
+ * The definition of a new list is not kept in the document model.
+ * So its shape has to be derivable from the list number (numId) alone, and that rule
+ * lives here. Even numbers are numbered lists, odd numbers are bullet lists.
+ *
+ * Drawing the markers on screen and writing the definitions into numbering.xml both look
+ * at the same template.
+ */
+import type { LevelIndent, Numbering, NumberingList } from "./parseNumbering";
+export type ListKind = "numbered" | "bullet";
+/** A list has nine levels (the count OOXML defines) */
+export declare const LEVEL_COUNT = 9;
+export declare const MAX_ILVL: number;
+export declare function templateIndent(ilvl: number): LevelIndent;
+export declare function listKindOf(numId: number): ListKind;
+/**
+ * The list definition for this number.
+ * A number the document's numbering.xml does not know is read as the standard template
+ * (which is the case for a list that was just started).
+ */
+export declare function listFor(numbering: Numbering, numId: number): NumberingList;
+/** The next number not yet in use. Picks the even or odd one matching the shape */
+export declare function nextNumId(used: Iterable<number>, kind: ListKind): number;
+/** Writes one template out as a `<w:abstractNum>` definition */
+export declare function abstractNumXml(abstractNumId: number, kind: ListKind): string;
+/** The `<w:num>` that ties a list number to a definition */
+export declare function numXml(numId: number, abstractNumId: number): string;

package/dist/numbering/listTemplate.js

@@ -0,0 +1,83 @@
+// src/numbering/listTemplate.ts
+var LEVEL_COUNT = 9;
+var MAX_ILVL = LEVEL_COUNT - 1;
+var NUMBER_CYCLE = [
+  "decimal",
+  "lowerLetter",
+  "lowerRoman"
+];
+var BULLET_CYCLE = ["\u25CF", "\u25CB", "\u25A0"];
+var LEVEL_STEP_TWIPS = 720;
+var HANGING_TWIPS = 360;
+function templateIndent(ilvl) {
+  return {
+    startTwips: LEVEL_STEP_TWIPS * (ilvl + 1),
+    endTwips: null,
+    hangingTwips: HANGING_TWIPS,
+    firstLineTwips: null
+  };
+}
+function cycled(cycle, ilvl, fallback) {
+  return cycle[ilvl % cycle.length] ?? fallback;
+}
+function templateLevel(kind, ilvl) {
+  const numbered = kind === "numbered";
+  return {
+    format: numbered ? cycled(NUMBER_CYCLE, ilvl, "decimal") : "bullet",
+    text: numbered ? `%${ilvl + 1}.` : cycled(BULLET_CYCLE, ilvl, "\u25CF"),
+    start: 1,
+    indent: templateIndent(ilvl)
+  };
+}
+function templateList(kind) {
+  const levels = /* @__PURE__ */ new Map();
+  for (let ilvl = 0; ilvl < LEVEL_COUNT; ilvl += 1) {
+    levels.set(ilvl, templateLevel(kind, ilvl));
+  }
+  return { levels };
+}
+var TEMPLATES = {
+  numbered: templateList("numbered"),
+  bullet: templateList("bullet")
+};
+function listKindOf(numId) {
+  return numId % 2 === 0 ? "numbered" : "bullet";
+}
+function listFor(numbering, numId) {
+  return numbering.lists.get(numId) ?? TEMPLATES[listKindOf(numId)];
+}
+function nextNumId(used, kind) {
+  const from = Math.max(0, ...used) + 1;
+  return listKindOf(from) === kind ? from : from + 1;
+}
+function indXml(indent) {
+  const attrs = [
+    ["w:left", indent?.startTwips],
+    ["w:right", indent?.endTwips],
+    ["w:hanging", indent?.hangingTwips],
+    ["w:firstLine", indent?.firstLineTwips]
+  ].filter((entry) => typeof entry[1] === "number").map(([name, value]) => `${name}="${value}"`).join(" ");
+  return attrs === "" ? "" : `<w:pPr><w:ind ${attrs}/></w:pPr>`;
+}
+function levelXml(ilvl, level) {
+  const ind = indXml(level.indent);
+  return `<w:lvl w:ilvl="${ilvl}"><w:start w:val="${level.start}"/><w:numFmt w:val="${level.format}"/><w:lvlText w:val="${level.text}"/><w:lvlJc w:val="left"/>${ind}</w:lvl>`;
+}
+function abstractNumXml(abstractNumId, kind) {
+  const levels = TEMPLATES[kind].levels;
+  const body = Array.from(levels.entries()).map(([ilvl, level]) => levelXml(ilvl, level)).join("");
+  return `<w:abstractNum w:abstractNumId="${abstractNumId}">${body}</w:abstractNum>`;
+}
+function numXml(numId, abstractNumId) {
+  return `<w:num w:numId="${numId}"><w:abstractNumId w:val="${abstractNumId}"/></w:num>`;
+}
+export {
+  LEVEL_COUNT,
+  MAX_ILVL,
+  abstractNumXml,
+  listFor,
+  listKindOf,
+  nextNumId,
+  numXml,
+  templateIndent
+};

package/dist/numbering/markers.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Walks the paragraphs in order and computes the number to show for each list paragraph.
+ *
+ * A pure computation that never touches the document model: the same paragraphs with the
+ * same numbering definitions always yield the same numbers.
+ */
+import type { NumberingRef } from "../model/format";
+import { type LevelIndentPt, type Numbering } from "./parseNumbering";
+/** The number to draw in front of one paragraph */
+export interface ListMarker {
+    text: string;
+    /**
+     * The indent defined by the level this paragraph belongs to. Used when the paragraph
+     * records none of its own
+     */
+    indent: LevelIndentPt;
+}
+/**
+ * A slot is null for a paragraph that is not a list item, or whose level shape could not
+ * be found.
+ * A number the document does not know (a list started fresh while editing) is drawn with
+ * the standard template's shape.
+ */
+export declare function computeMarkers(paragraphs: readonly (NumberingRef | null)[], numbering: Numbering): (ListMarker | null)[];

package/dist/numbering/markers.js

@@ -0,0 +1,93 @@
+// src/numbering/markers.ts
+import { listFor } from "./listTemplate.js";
+import {
+  levelIndentPt
+} from "./parseNumbering.js";
+var ROMAN = [
+  [1e3, "M"],
+  [900, "CM"],
+  [500, "D"],
+  [400, "CD"],
+  [100, "C"],
+  [90, "XC"],
+  [50, "L"],
+  [40, "XL"],
+  [10, "X"],
+  [9, "IX"],
+  [5, "V"],
+  [4, "IV"],
+  [1, "I"]
+];
+function toRoman(value) {
+  let rest = value;
+  let out = "";
+  for (const [amount, sign] of ROMAN) {
+    while (rest >= amount) {
+      out += sign;
+      rest -= amount;
+    }
+  }
+  return out;
+}
+function toLetters(value) {
+  const index = (value - 1) % 26;
+  const repeat = Math.floor((value - 1) / 26) + 1;
+  return String.fromCharCode(65 + index).repeat(repeat);
+}
+var MAX_MARKER_CHARS = 64;
+var MAX_SPELLED_VALUE = {
+  decimal: Number.POSITIVE_INFINITY,
+  bullet: Number.POSITIVE_INFINITY,
+  lowerLetter: 26 * MAX_MARKER_CHARS,
+  upperLetter: 26 * MAX_MARKER_CHARS,
+  lowerRoman: 1e3 * MAX_MARKER_CHARS
+};
+function formatNumber(value, format) {
+  if (value < 1 || value > MAX_SPELLED_VALUE[format]) return `${value}`;
+  switch (format) {
+    case "lowerLetter":
+      return toLetters(value).toLowerCase();
+    case "upperLetter":
+      return toLetters(value);
+    case "lowerRoman":
+      return toRoman(value).toLowerCase();
+    default:
+      return `${value}`;
+  }
+}
+function fillLevels(text, list, counters) {
+  return text.replaceAll(/%([1-9])/g, (_, digit) => {
+    const ilvl = Number(digit) - 1;
+    const level = list.levels.get(ilvl);
+    if (!level) return "";
+    return formatNumber(counters.get(ilvl) ?? level.start, level.format);
+  });
+}
+function advance(counters, list, ilvl, start) {
+  const current = counters.get(ilvl);
+  counters.set(ilvl, current === void 0 ? start : current + 1);
+  for (const deeper of [...counters.keys(), ...list.levels.keys()]) {
+    if (deeper > ilvl) counters.delete(deeper);
+  }
+}
+function computeMarkers(paragraphs, numbering) {
+  const countersByList = /* @__PURE__ */ new Map();
+  return paragraphs.map((ref) => {
+    if (!ref) return null;
+    const list = listFor(numbering, ref.numId);
+    const level = list.levels.get(ref.ilvl);
+    if (!level) return null;
+    let counters = countersByList.get(ref.numId);
+    if (!counters) {
+      counters = /* @__PURE__ */ new Map();
+      countersByList.set(ref.numId, counters);
+    }
+    advance(counters, list, ref.ilvl, level.start);
+    const shape = level.format === "bullet" ? level.text : fillLevels(level.text, list, counters);
+    const text = shape.slice(0, MAX_MARKER_CHARS);
+    return text ? { text, indent: levelIndentPt(level.indent) } : null;
+  });
+}
+export {
+  computeMarkers
+};

package/dist/numbering/parseNumbering.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Reads numbering.xml to build up "what shape does level N of list M have".
+ *
+ * The values produced here are used only for drawing the numbers on screen.
+ * numbering.xml itself goes out as the original bytes on export, so this reading never
+ * disturbs the file.
+ */
+import type { TabStopDirective } from "../model/tabStops";
+/** The number formats actually used across every fixture */
+declare const NUMBER_FORMATS: readonly ["decimal", "bullet", "lowerLetter", "upperLetter", "lowerRoman"];
+export type NumberFormat = (typeof NUMBER_FORMATS)[number];
+/**
+ * The indent a level defines. The unit is twips (1/20 of a point), and a slot that is
+ * not recorded is null
+ */
+export interface LevelIndent {
+    startTwips: number | null;
+    endTwips: number | null;
+    hangingTwips: number | null;
+    firstLineTwips: number | null;
+}
+export interface NumberingLevel {
+    format: NumberFormat;
+    /**
+     * The pattern holding the number slots, such as `%1.` or `(%2)`. For a bullet it is
+     * the bullet glyph itself
+     */
+    text: string;
+    start: number;
+    /** The indent the paragraphs of this level use. Null when the level defines none */
+    indent: LevelIndent | null;
+    /** Custom stops contributed by this level's paragraph properties. */
+    tabStops?: readonly TabStopDirective[];
+}
+export interface NumberingList {
+    /** The shape for each level (ilvl) */
+    levels: Map<number, NumberingLevel>;
+}
+export interface Numbering {
+    /** The list for each numId */
+    lists: Map<number, NumberingList>;
+}
+export declare const EMPTY_NUMBERING: Numbering;
+/**
+ * The indent a level defines, converted into the on-screen unit (points). A slot the
+ * level does not define is null
+ */
+export interface LevelIndentPt {
+    startPt: number | null;
+    endPt: number | null;
+    /**
+     * Negative for a hanging indent, positive for a first-line indent. Null when there is
+     * neither
+     */
+    textIndentPt: number | null;
+}
+export declare const NO_LEVEL_INDENT: LevelIndentPt;
+/**
+ * The indent a level passes down to its paragraphs.
+ * As with paragraph formatting, a hanging indent overrides a first-line indent (the
+ * OOXML rule).
+ */
+export declare function levelIndentPt(indent: LevelIndent | null): LevelIndentPt;
+export declare function parseNumbering(xml: string | null): Numbering;
+export {};