@stll/folio-core 0.0.1-placeholder.0 → 0.1.0

package/dist/prosemirror/styles/resolvedStyleAttrs.js

@@ -0,0 +1,108 @@
+import { computeListRendering } from "../../docx/numberingParser.js";
+import { setAutospacingBaseValue } from "../autospacingBase.js";
+//#region src/prosemirror/styles/resolvedStyleAttrs.ts
+/**
+* Shared helper for projecting a resolved paragraph style onto ProseMirror
+* paragraph node attrs.
+*
+* Both `applyStyle` (toolbar style picker) and the Enter handler's
+* next-style switch need to write the same set of style-controlled attrs.
+* Keeping the projection in one place ensures the two paths stay in sync —
+* a style applied via the picker and a style applied on Enter produce
+* identical paragraph attrs.
+*/
+/**
+* The paragraph attrs a style definition controls. Applying a style resets
+* every one of these to the style's value (or `null` to clear), so a prior
+* style's properties (e.g. a heading's spacing) never leak through. Returns
+* a partial attrs object to merge over the paragraph's existing attrs.
+*/
+function paragraphAttrsFromResolvedStyle(resolved) {
+	const ppr = resolved.paragraphFormatting;
+	const runFormatting = resolved.runFormatting;
+	const hasRunFormatting = !!runFormatting && Object.keys(runFormatting).length > 0;
+	return {
+		alignment: ppr?.alignment ?? null,
+		spaceBefore: ppr?.spaceBefore ?? null,
+		spaceAfter: ppr?.spaceAfter ?? null,
+		lineSpacing: ppr?.lineSpacing ?? null,
+		lineSpacingRule: ppr?.lineSpacingRule ?? null,
+		indentLeft: ppr?.indentLeft ?? null,
+		indentRight: ppr?.indentRight ?? null,
+		indentFirstLine: ppr?.indentFirstLine ?? null,
+		hangingIndent: ppr?.hangingIndent ?? null,
+		contextualSpacing: ppr?.contextualSpacing ?? null,
+		keepNext: ppr?.keepNext ?? null,
+		keepLines: ppr?.keepLines ?? null,
+		pageBreakBefore: ppr?.pageBreakBefore ?? null,
+		outlineLevel: ppr?.outlineLevel ?? null,
+		borders: ppr?.borders ?? null,
+		defaultTextFormatting: hasRunFormatting ? runFormatting : null,
+		_autospacingBase: autospacingBaseFromResolvedParagraphFormatting(ppr)
+	};
+}
+function autospacingBaseFromResolvedParagraphFormatting(ppr) {
+	const base = {};
+	if (ppr?.beforeAutospacing) setAutospacingBaseValue(base, "before", ppr.spaceBefore);
+	if (ppr?.afterAutospacing) setAutospacingBaseValue(base, "after", ppr.spaceAfter);
+	return Object.keys(base).length > 0 ? base : null;
+}
+/**
+* The list attrs a style's `w:pPr/w:numPr` controls (numbering reference plus
+* the baked marker-rendering attrs that `toProseDoc` normally derives from
+* `listRendering` at load time). Returns null when the style defines no
+* numbering — applying such a style leaves any existing list attrs alone, so
+* directly-applied (toolbar) lists survive a style switch the way they do in
+* Word, where numbering is not cleared by applying an unnumbered style.
+*
+* When the style does define numbering, the full attr group is reset so a
+* previous list's marker attrs never leak into the new one. Without the
+* numbering definitions the marker template can't be resolved and the painter
+* falls back to a plain decimal marker.
+*
+* The content-derived marker attrs (`listImplicitChildLevelAdvances`,
+* `listMarkerSecondSlotOffsetTwips`) are nulled — they depend on the
+* paragraph's inline LISTNUM fields, which the picker has no view of. A
+* subsequent save + reload re-derives them from the document content.
+*/
+function listAttrsFromResolvedStyle(resolved, numbering) {
+	const numPr = resolved.paragraphFormatting?.numPr;
+	if (!numPr || numPr.numId === void 0 || numPr.numId === 0) return null;
+	const rendering = numbering ? computeListRendering(numPr, numbering) : null;
+	const level = numbering?.getLevel(numPr.numId, numPr.ilvl ?? 0);
+	const attrs = {
+		numPr: {
+			numId: numPr.numId,
+			ilvl: numPr.ilvl ?? 0
+		},
+		numPrFromStyle: {
+			numId: numPr.numId,
+			ilvl: numPr.ilvl ?? 0
+		},
+		listNumFmt: rendering?.numFmt ?? null,
+		listIsBullet: rendering?.isBullet ?? null,
+		listIsLegal: rendering?.isLegal ?? null,
+		listMarker: rendering?.marker ?? null,
+		listMarkerHidden: rendering?.markerHidden ?? null,
+		listMarkerFontFamily: rendering?.markerFontFamily ?? null,
+		listMarkerFontSize: rendering?.markerFontSize ?? null,
+		listMarkerSuffix: rendering?.markerSuffix ?? null,
+		listMarkerAllCaps: rendering?.markerAllCaps ?? null,
+		listImplicitChildLevelAdvances: null,
+		listMarkerSecondSlotOffsetTwips: null,
+		listLevelNumFmts: rendering?.levelNumFmts ?? null,
+		listAbstractNumId: rendering?.abstractNumId ?? null,
+		listStartOverride: rendering?.startOverride ?? null
+	};
+	const ppr = resolved.paragraphFormatting;
+	if (level?.pPr) {
+		if (ppr?.indentLeft === void 0 && level.pPr.indentLeft !== void 0) attrs["indentLeft"] = level.pPr.indentLeft;
+		if (!(ppr?.indentFirstLine !== void 0 || ppr?.hangingIndent !== void 0)) {
+			if (level.pPr.indentFirstLine !== void 0) attrs["indentFirstLine"] = level.pPr.indentFirstLine;
+			if (level.pPr.hangingIndent !== void 0) attrs["hangingIndent"] = level.pPr.hangingIndent;
+		}
+	}
+	return attrs;
+}
+//#endregion
+export { listAttrsFromResolvedStyle, paragraphAttrsFromResolvedStyle };

package/dist/prosemirror/styles/styleResolver.d.ts

@@ -0,0 +1,94 @@
+import { document_d_exports } from "../../types/document.js";
+
+//#region src/prosemirror/styles/styleResolver.d.ts
+/**
+ * Resolved style properties ready for rendering
+ */
+type ResolvedParagraphStyle = {
+  /** Paragraph formatting (alignment, spacing, indentation, etc.) */paragraphFormatting?: document_d_exports.ParagraphFormatting; /** Default run formatting from the style */
+  runFormatting?: document_d_exports.TextFormatting;
+};
+/**
+ * StyleResolver provides efficient access to resolved style properties
+ */
+declare class StyleResolver {
+  private readonly stylesById;
+  private readonly docDefaults;
+  private readonly defaultParagraphStyle;
+  private readonly defaultCharacterStyle;
+  private readonly defaultTableStyle;
+  constructor(styleDefinitions: document_d_exports.StyleDefinitions | undefined);
+  /**
+   * Get a style by ID
+   */
+  getStyle(styleId: string): document_d_exports.Style | undefined;
+  /**
+   * Get all available paragraph styles (for toolbar dropdown)
+   */
+  getParagraphStyles(): document_d_exports.Style[];
+  /**
+   * Resolve paragraph style properties, including docDefaults cascade
+   *
+   * @param styleId - The style ID to resolve (e.g., 'Heading1', 'Normal')
+   * @returns Resolved paragraph and run formatting
+   */
+  resolveParagraphStyle(styleId: string | undefined | null): ResolvedParagraphStyle;
+  /**
+   * Resolve the style applied to the paragraph that follows one styled with
+   * `styleId` when the user presses Enter (OOXML `w:next`, §17.7.4.10).
+   *
+   * Returns null when the style has no `w:next`, when `next` points back at
+   * the same style (the common heading-stays-heading case is handled by the
+   * caller), when the style is unknown, when `next` is a dangling reference
+   * to a style that does not exist, or when the target is not a paragraph
+   * style (malformed DOCX may point `w:next` at a character or table style;
+   * writing such an ID into a paragraph's `styleId` would create an invalid
+   * reference).
+   */
+  getNextStyleId(styleId: string | undefined | null): string | null;
+  /**
+   * Get all available table styles (for style gallery)
+   */
+  getTableStyles(): document_d_exports.Style[];
+  /**
+   * Resolve run (character) style properties
+   *
+   * @param styleId - The character style ID to resolve
+   * @returns Resolved text formatting
+   */
+  resolveRunStyle(styleId: string | undefined | null): document_d_exports.TextFormatting | undefined;
+  /**
+   * Get a character style's own properties WITHOUT docDefaults.
+   * Used when the caller already has docDefaults applied (e.g., from paragraph style resolution).
+   * This prevents docDefault fonts from incorrectly overriding paragraph style fonts.
+   */
+  getRunStyleOwnProperties(styleId: string | undefined | null): document_d_exports.TextFormatting | undefined;
+  /**
+   * Get document defaults
+   */
+  getDocDefaults(): document_d_exports.DocDefaults | undefined;
+  /**
+   * Get default paragraph style (usually "Normal")
+   */
+  getDefaultParagraphStyle(): document_d_exports.Style | undefined;
+  /**
+   * Get default character style.
+   */
+  getDefaultCharacterStyle(): document_d_exports.Style | undefined;
+  /**
+   * Get default table style.
+   */
+  getDefaultTableStyle(): document_d_exports.Style | undefined;
+  /**
+   * Check if a style exists
+   */
+  hasStyle(styleId: string): boolean;
+  private findDefaultStyle;
+  private mergeStyleIntoResult;
+}
+/**
+ * Create a style resolver from document's style definitions
+ */
+declare function createStyleResolver(styleDefinitions: document_d_exports.StyleDefinitions | undefined): StyleResolver;
+//#endregion
+export { ResolvedParagraphStyle, StyleResolver, createStyleResolver };

package/dist/prosemirror/styles/styleResolver.js

@@ -0,0 +1,200 @@
+import { mergeTextFormatting } from "../../utils/textFormattingMerge.js";
+import { mergeParagraphFormatting } from "../../utils/paragraphFormattingMerge.js";
+//#region src/prosemirror/styles/styleResolver.ts
+/**
+* Word's default-template Normal style, used as a last-resort fallback for a
+* bare document that ships neither a `Normal` style nor `w:docDefaults`: 8pt
+* (160 twips) after spacing, 1.08x line spacing — the values Word writes into
+* a freshly created document's Normal.
+*
+* It is NOT applied when the document provides `w:docDefaults`. Those are the
+* authoritative paragraph defaults per ECMA-376 §17.7.5; an empty
+* `w:pPrDefault` means zero spacing / single line, so synthesizing this style
+* over it wrongly inflates style-less paragraphs (e.g. generated-document
+* table cells whose author relied on the compact default). See
+* eigenpal/docx-editor#909.
+*/
+const BUILTIN_NORMAL_STYLE = {
+	styleId: "Normal",
+	type: "paragraph",
+	name: "Normal",
+	default: true,
+	pPr: {
+		spaceAfter: 160,
+		lineSpacing: 259,
+		lineSpacingRule: "auto"
+	}
+};
+/**
+* StyleResolver provides efficient access to resolved style properties
+*/
+var StyleResolver = class {
+	stylesById;
+	docDefaults;
+	defaultParagraphStyle;
+	defaultCharacterStyle;
+	defaultTableStyle;
+	constructor(styleDefinitions) {
+		this.stylesById = /* @__PURE__ */ new Map();
+		this.docDefaults = styleDefinitions?.docDefaults;
+		if (styleDefinitions?.styles) {
+			for (const style of styleDefinitions.styles) if (style.styleId) this.stylesById.set(style.styleId, style);
+		}
+		this.defaultParagraphStyle = this.findDefaultStyle("paragraph");
+		this.defaultCharacterStyle = this.findDefaultStyle("character");
+		this.defaultTableStyle = this.findDefaultStyle("table");
+	}
+	/**
+	* Get a style by ID
+	*/
+	getStyle(styleId) {
+		return this.stylesById.get(styleId);
+	}
+	/**
+	* Get all available paragraph styles (for toolbar dropdown)
+	*/
+	getParagraphStyles() {
+		const styles = [];
+		for (const style of this.stylesById.values()) if (style.type === "paragraph" && !style.hidden && !style.semiHidden) styles.push(style);
+		return styles.toSorted((a, b) => {
+			const priorityA = a.uiPriority ?? 99;
+			const priorityB = b.uiPriority ?? 99;
+			if (priorityA !== priorityB) return priorityA - priorityB;
+			return (a.name ?? a.styleId).localeCompare(b.name ?? b.styleId);
+		});
+	}
+	/**
+	* Resolve paragraph style properties, including docDefaults cascade
+	*
+	* @param styleId - The style ID to resolve (e.g., 'Heading1', 'Normal')
+	* @returns Resolved paragraph and run formatting
+	*/
+	resolveParagraphStyle(styleId) {
+		const result = {};
+		if (this.docDefaults?.pPr) result.paragraphFormatting = { ...this.docDefaults.pPr };
+		if (this.docDefaults?.rPr) result.runFormatting = { ...this.docDefaults.rPr };
+		if (!styleId) {
+			if (this.defaultParagraphStyle) this.mergeStyleIntoResult(result, this.defaultParagraphStyle);
+			return result;
+		}
+		const style = this.stylesById.get(styleId);
+		if (!style) {
+			if (this.defaultParagraphStyle) this.mergeStyleIntoResult(result, this.defaultParagraphStyle);
+			return result;
+		}
+		this.mergeStyleIntoResult(result, style);
+		return result;
+	}
+	/**
+	* Resolve the style applied to the paragraph that follows one styled with
+	* `styleId` when the user presses Enter (OOXML `w:next`, §17.7.4.10).
+	*
+	* Returns null when the style has no `w:next`, when `next` points back at
+	* the same style (the common heading-stays-heading case is handled by the
+	* caller), when the style is unknown, when `next` is a dangling reference
+	* to a style that does not exist, or when the target is not a paragraph
+	* style (malformed DOCX may point `w:next` at a character or table style;
+	* writing such an ID into a paragraph's `styleId` would create an invalid
+	* reference).
+	*/
+	getNextStyleId(styleId) {
+		if (!styleId) return null;
+		const next = this.stylesById.get(styleId)?.next;
+		if (!next || next === styleId) return null;
+		const target = this.stylesById.get(next);
+		if (!target || target.type !== "paragraph") return null;
+		return next;
+	}
+	/**
+	* Get all available table styles (for style gallery)
+	*/
+	getTableStyles() {
+		const styles = [];
+		for (const style of this.stylesById.values()) if (style.type === "table" && !style.hidden && !style.semiHidden) styles.push(style);
+		return styles.toSorted((a, b) => {
+			const priorityA = a.uiPriority ?? 99;
+			const priorityB = b.uiPriority ?? 99;
+			if (priorityA !== priorityB) return priorityA - priorityB;
+			return (a.name ?? a.styleId).localeCompare(b.name ?? b.styleId);
+		});
+	}
+	/**
+	* Resolve run (character) style properties
+	*
+	* @param styleId - The character style ID to resolve
+	* @returns Resolved text formatting
+	*/
+	resolveRunStyle(styleId) {
+		let result = {};
+		if (this.docDefaults?.rPr) result = { ...this.docDefaults.rPr };
+		const defaultCharacterRpr = this.defaultCharacterStyle?.rPr;
+		if (defaultCharacterRpr) result = mergeTextFormatting(result, defaultCharacterRpr) ?? {};
+		const style = styleId ? this.stylesById.get(styleId) : void 0;
+		if (!style?.rPr) return Object.keys(result).length > 0 ? result : void 0;
+		const merged = mergeTextFormatting(result, style.rPr);
+		return merged && Object.keys(merged).length > 0 ? merged : void 0;
+	}
+	/**
+	* Get a character style's own properties WITHOUT docDefaults.
+	* Used when the caller already has docDefaults applied (e.g., from paragraph style resolution).
+	* This prevents docDefault fonts from incorrectly overriding paragraph style fonts.
+	*/
+	getRunStyleOwnProperties(styleId) {
+		if (!styleId) return;
+		const style = this.stylesById.get(styleId);
+		if (!style?.rPr) return;
+		return Object.keys(style.rPr).length > 0 ? { ...style.rPr } : void 0;
+	}
+	/**
+	* Get document defaults
+	*/
+	getDocDefaults() {
+		return this.docDefaults;
+	}
+	/**
+	* Get default paragraph style (usually "Normal")
+	*/
+	getDefaultParagraphStyle() {
+		return this.defaultParagraphStyle;
+	}
+	/**
+	* Get default character style.
+	*/
+	getDefaultCharacterStyle() {
+		return this.defaultCharacterStyle;
+	}
+	/**
+	* Get default table style.
+	*/
+	getDefaultTableStyle() {
+		return this.defaultTableStyle;
+	}
+	/**
+	* Check if a style exists
+	*/
+	hasStyle(styleId) {
+		return this.stylesById.has(styleId);
+	}
+	findDefaultStyle(type) {
+		for (const style of this.stylesById.values()) if (style.type === type && style.default) return style;
+		if (type === "paragraph") return this.stylesById.get("Normal") ?? (this.docDefaults ? void 0 : BUILTIN_NORMAL_STYLE);
+	}
+	mergeStyleIntoResult(result, style) {
+		if (style.pPr) {
+			const merged = mergeParagraphFormatting(result.paragraphFormatting, style.pPr);
+			if (merged !== void 0) result.paragraphFormatting = merged;
+		}
+		if (style.rPr) {
+			const merged = mergeTextFormatting(result.runFormatting, style.rPr);
+			if (merged !== void 0) result.runFormatting = merged;
+		}
+	}
+};
+/**
+* Create a style resolver from document's style definitions
+*/
+function createStyleResolver(styleDefinitions) {
+	return new StyleResolver(styleDefinitions);
+}
+//#endregion
+export { StyleResolver, createStyleResolver };

package/dist/prosemirror/utils/findParagraphByParaId.d.ts

@@ -0,0 +1,26 @@
+import { Node } from "prosemirror-model";
+
+//#region src/prosemirror/utils/findParagraphByParaId.d.ts
+/**
+ * ProseMirror position range for the paragraph (or any textblock) whose
+ * `paraId` attribute equals `paraId`. Returns the inclusive `from` and
+ * exclusive `to` positions, plus the node, so callers can both target
+ * the paragraph (e.g. addMark over its text range) and inspect it.
+ *
+ * `from` is the position immediately before the textblock; `to` is
+ * `from + node.nodeSize`. The text content lives at `[from + 1, to - 1]`.
+ *
+ * Returns null if no textblock with that paraId exists.
+ */
+declare const findParagraphByParaId: (doc: Node, paraId: string) => {
+  node: Node;
+  from: number;
+  to: number;
+} | null;
+/**
+ * Sugar over {@link findParagraphByParaId} when callers only need the
+ * `from` position (e.g. to feed `scrollToPosition`).
+ */
+declare const findStartPosForParaId: (doc: Node, paraId: string) => number | null;
+//#endregion
+export { findParagraphByParaId, findStartPosForParaId };

package/dist/prosemirror/utils/findParagraphByParaId.js

@@ -0,0 +1,37 @@
+//#region src/prosemirror/utils/findParagraphByParaId.ts
+/**
+* ProseMirror position range for the paragraph (or any textblock) whose
+* `paraId` attribute equals `paraId`. Returns the inclusive `from` and
+* exclusive `to` positions, plus the node, so callers can both target
+* the paragraph (e.g. addMark over its text range) and inspect it.
+*
+* `from` is the position immediately before the textblock; `to` is
+* `from + node.nodeSize`. The text content lives at `[from + 1, to - 1]`.
+*
+* Returns null if no textblock with that paraId exists.
+*/
+const findParagraphByParaId = (doc, paraId) => {
+	if (!paraId || !paraId.trim()) return null;
+	let result = null;
+	doc.descendants((node, pos) => {
+		if (result !== null) return false;
+		const nodeParaId = node.attrs["paraId"];
+		if (node.isTextblock && nodeParaId === paraId) {
+			result = {
+				node,
+				from: pos,
+				to: pos + node.nodeSize
+			};
+			return false;
+		}
+		return true;
+	});
+	return result;
+};
+/**
+* Sugar over {@link findParagraphByParaId} when callers only need the
+* `from` position (e.g. to feed `scrollToPosition`).
+*/
+const findStartPosForParaId = (doc, paraId) => findParagraphByParaId(doc, paraId)?.from ?? null;
+//#endregion
+export { findParagraphByParaId, findStartPosForParaId };

package/dist/prosemirror/utils/tabCalculator.d.ts

@@ -0,0 +1,110 @@
+//#region src/prosemirror/utils/tabCalculator.d.ts
+/**
+ * Tab Width Calculator
+ *
+ * Computes tab widths based on position and tab stops.
+ * Follows OOXML tab stop semantics:
+ * - Default tab interval: 720 twips (0.5 inch, 48px at 96dpi)
+ * - Tab stops can be start (left), end (right), center, decimal, or bar
+ * - Explicit tab stops override default stops
+ *
+ * Based on ECMA-376 specification and clean-room understanding of tab layout.
+ */
+/**
+ * Tab alignment types
+ */
+type TabAlignment = "start" | "end" | "center" | "decimal" | "bar" | "clear";
+/**
+ * Tab leader (fill character) types
+ */
+type TabLeader = "none" | "dot" | "hyphen" | "underscore" | "middleDot" | "heavy";
+/**
+ * Tab stop definition
+ */
+type TabStop = {
+  /** Tab alignment mode */val: TabAlignment; /** Position in twips from left margin */
+  pos: number; /** Optional leader character */
+  leader?: TabLeader;
+};
+/**
+ * Context for tab calculations
+ */
+type TabContext = {
+  /** Explicit tab stops from paragraph or style */explicitStops?: TabStop[]; /** Default tab interval in twips (default: 720 = 0.5 inch) */
+  defaultTabInterval?: number; /** Left indent in twips */
+  leftIndent?: number;
+};
+/**
+ * Result of tab width calculation
+ */
+type TabWidthResult = {
+  /** Width of the tab in pixels */width: number; /** Leader character to render (if any) */
+  leader?: TabLeader; /** Alignment that was applied */
+  alignment: TabAlignment | "default";
+};
+/** Default tab interval: 720 twips = 0.5 inch */
+declare const DEFAULT_TAB_INTERVAL_TWIPS = 720;
+/** Twips per inch */
+declare const TWIPS_PER_INCH = 1440;
+/** Pixels per inch (96 dpi standard for CSS) */
+declare const PIXELS_PER_INCH = 96;
+/**
+ * Convert twips to pixels
+ * @param twips - Value in twips (1/1440 inch)
+ * @returns Value in pixels (at 96 dpi)
+ */
+declare function twipsToPixels(twips: number): number;
+/**
+ * Convert pixels to twips
+ * @param pixels - Value in pixels (at 96 dpi)
+ * @returns Value in twips (1/1440 inch)
+ */
+declare function pixelsToTwips(pixels: number): number;
+/**
+ * Compute the list of effective tab stops for a paragraph
+ *
+ * Merges explicit stops with default stops at regular intervals.
+ * Filters out stops that fall before the left indent.
+ *
+ * @param context - Tab context with explicit stops and settings
+ * @returns Sorted array of tab stops in twips
+ */
+declare function computeTabStops(context: TabContext): TabStop[];
+/**
+ * Pixel widths of the content after a tab, needed to position non-left stops.
+ *
+ * Caller measures its own runs (the painter and the layout measurer have
+ * different run models and measurement paths) and passes the result here, so
+ * this module owns the stop grid + alignment math without owning measurement.
+ */
+type TabFollowingContent = {
+  /** Total width of the runs after the tab. Used for `end` and `center` stops. */followingWidth?: number; /** Width of the content before the decimal separator. Used for `decimal` stops. */
+  decimalPrefixWidth?: number;
+};
+/**
+ * Calculate the width of a tab character.
+ *
+ * Finds the next tab stop after the current position and computes the width
+ * needed to reach it. For `end`/`center`/`decimal` stops the content after the
+ * tab is anchored against the stop, so the caller supplies its measured width
+ * via {@link TabFollowingContent}.
+ *
+ * @param currentXPx - Current horizontal position in pixels (from the content
+ *   area's left edge — the same origin tab stop positions are measured from)
+ * @param context - Tab context with stops and settings
+ * @param following - Measured widths of the content after the tab
+ * @returns Tab width result with width in pixels
+ */
+declare function calculateTabWidth(currentXPx: number, context: TabContext, following?: TabFollowingContent): TabWidthResult;
+/**
+ * Calculate tab width with simple default stops
+ *
+ * Simplified version for basic tab rendering without explicit stops.
+ * Uses the default 0.5 inch (48px) tab interval.
+ *
+ * @param currentXPx - Current horizontal position in pixels
+ * @returns Width of the tab in pixels
+ */
+declare function calculateSimpleTabWidth(currentXPx: number): number;
+//#endregion
+export { DEFAULT_TAB_INTERVAL_TWIPS, PIXELS_PER_INCH, TWIPS_PER_INCH, TabAlignment, TabContext, TabFollowingContent, TabLeader, TabStop, TabWidthResult, calculateSimpleTabWidth, calculateTabWidth, computeTabStops, pixelsToTwips, twipsToPixels };