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

package/dist/prosemirror/schema/nodes.d.ts

@@ -0,0 +1,389 @@
+import { document_d_exports } from "../../types/document.js";
+import { OutlineStyleAttr } from "../../types/documentEnumValues.js";
+import { SpacingExplicit } from "../../types/formatting.js";
+import { ParagraphDirection } from "../paragraphDirection.js";
+
+//#region src/prosemirror/schema/nodes.d.ts
+type HardBreakAttrs = {
+  breakType?: "column";
+};
+/**
+ * Paragraph node attributes - maps to ParagraphFormatting
+ */
+type ParagraphAttrs = {
+  paraId?: string;
+  textId?: string;
+  alignment?: document_d_exports.ParagraphAlignment;
+  spaceBefore?: number;
+  spaceAfter?: number;
+  lineSpacing?: number;
+  lineSpacingRule?: document_d_exports.LineSpacingRule;
+  spacingExplicit?: SpacingExplicit;
+  indentLeft?: number;
+  indentRight?: number;
+  indentFirstLine?: number;
+  hangingIndent?: boolean;
+  numPr?: {
+    numId?: number;
+    ilvl?: number;
+  };
+  /**
+   * The style-sourced numPr value when `numPr` came from the paragraph
+   * style rather than direct formatting. While `numPr` still equals this,
+   * fromProseDoc omits it from serialized formatting (writing it as direct
+   * `<w:numPr>` would flip Word's level-indent precedence on reload). List
+   * commands that change `numPr` make the values diverge, which re-enables
+   * direct serialization — no explicit clearing needed.
+   */
+  numPrFromStyle?: {
+    numId?: number;
+    ilvl?: number;
+  }; /** List number format (decimal, lowerRoman, upperRoman, etc.) for CSS counter styling */
+  listNumFmt?: document_d_exports.NumberFormat; /** Whether this is a bullet list */
+  listIsBullet?: boolean; /** Whether this level uses legal numbering (parent placeholders render decimal). */
+  listIsLegal?: boolean; /** Computed list marker text (e.g., "1.", "1.1.", "•") */
+  listMarker?: string; /** Whether the list marker is hidden (w:vanish on numbering level rPr) */
+  listMarkerHidden?: boolean; /** Marker font family from numbering level rPr */
+  listMarkerFontFamily?: string; /** Marker font size from numbering level rPr, in points */
+  listMarkerFontSize?: number;
+  /**
+   * `w:suff` (§17.9.25) — what follows the marker before body text.
+   * `tab` (default) grows the marker to the next tab stop; `space` adds one
+   * space glyph; `nothing` lets body text butt against the marker.
+   */
+  listMarkerSuffix?: "tab" | "space" | "nothing"; /** `w:caps` on the numbering level rPr — render marker in upper case. */
+  listMarkerAllCaps?: boolean;
+  /**
+   * Inline LISTNUM count carried by this paragraph. Each advances the
+   * counter at `ilvl + 1` so a later sibling at that depth renders the
+   * next marker letter.
+   */
+  listImplicitChildLevelAdvances?: number;
+  /**
+   * When the marker text contains a TAB separator, this column offset (in
+   * twips) is where the slot after the tab should land — used to align an
+   * inline LISTNUM "(a)" with the deeper level's marker column.
+   */
+  listMarkerSecondSlotOffsetTwips?: number; /** Number format for each level used by multi-level marker templates. */
+  listLevelNumFmts?: document_d_exports.NumberFormat[]; /** Abstract numbering ID shared by numbering instances. */
+  listAbstractNumId?: number; /** Numbering start override for this numId/level. */
+  listStartOverride?: number;
+  styleId?: string;
+  borders?: {
+    top?: document_d_exports.BorderSpec;
+    bottom?: document_d_exports.BorderSpec;
+    left?: document_d_exports.BorderSpec;
+    right?: document_d_exports.BorderSpec;
+    between?: document_d_exports.BorderSpec;
+    bar?: document_d_exports.BorderSpec;
+  };
+  shading?: document_d_exports.ShadingProperties;
+  tabs?: document_d_exports.TabStop[];
+  pageBreakBefore?: boolean; /** Word's cached rendered-page-break marker; preserved for round-trip only. */
+  renderedPageBreakBefore?: boolean;
+  keepNext?: boolean;
+  keepLines?: boolean; /** Contextual spacing — suppress space between same-style paragraphs */
+  contextualSpacing?: boolean;
+  defaultTextFormatting?: document_d_exports.TextFormatting;
+  sectionBreakType?: "nextPage" | "continuous" | "oddPage" | "evenPage";
+  /**
+   * Base text direction as a discriminated union (undecided when absent). Maps
+   * to the serialized OOXML `w:bidi` tri-state via `directionToBidi`; the
+   * `source` discriminates an authoritative manual/import decision from a
+   * re-evaluable auto-detected one. See `paragraphDirection.ts`.
+   */
+  direction?: ParagraphDirection | null;
+  outlineLevel?: number;
+  bookmarks?: {
+    id: number;
+    name: string;
+  }[];
+  /** Empty `w:hyperlink` elements cannot be represented as text marks.
+   *  Preserve their relationship metadata at the paragraph boundary so a
+   *  no-edit DOCX round-trip does not silently drop hyperlink elements. */
+  _emptyHyperlinks?: {
+    /** ProseMirror inline offset where the zero-width hyperlink appeared. */offset: number;
+    href?: document_d_exports.Hyperlink["href"];
+    anchor?: document_d_exports.Hyperlink["anchor"];
+    tooltip?: document_d_exports.Hyperlink["tooltip"];
+    rId?: document_d_exports.Hyperlink["rId"];
+  }[];
+  /**
+   * Run-in heading flag: this paragraph's mark carries
+   * `<w:specVanish/>` and the next paragraph should flow inline on
+   * the same line (NVCA-style "6.11 Severability" → "The
+   * invalidity..." merges). Layout consumes this in toFlowBlocks.
+   */
+  runInWithNext?: boolean;
+  /** Original inline paragraph formatting from DOCX (pre-style-resolution).
+   *  Used by fromProseDoc for lossless round-trip serialization. */
+  _originalFormatting?: document_d_exports.ParagraphFormatting;
+  /** Import-effective spacing baseline for HTML auto-spacing detection.
+   *  PM-only; never serialized back into DOCX formatting. */
+  _autospacingBase?: {
+    before?: number | null;
+    after?: number | null;
+  };
+  /** Full section properties for paragraphs that end a section.
+   *  Used by layout engine for per-section column/page config and round-trip. */
+  _sectionProperties?: document_d_exports.SectionProperties;
+  /** Paragraph-property-change tracking entries (`w:pPrChange`).
+   *  Preserved opaquely through ProseMirror — the editor does not surface
+   *  them in UI today, but stripping them on every edit would corrupt the
+   *  `w:pPrChange` history Word relies on for "show previous formatting"
+   *  and for reverting an accepted property change. */
+  _propertyChanges?: document_d_exports.ParagraphPropertyChange[];
+  /** Paragraph-mark insertion / deletion (`<w:pPr><w:rPr><w:ins/>` /
+   *  `<w:del/>`). Word emits this when the paragraph break itself was
+   *  authored in track-changes mode — pressing Enter mid-paragraph
+   *  produces an `ins`, Backspace-at-start / Delete-at-end produce a
+   *  `del`. Stored as a discriminated union to mirror folio's
+   *  `TrackedChangeWrapperType` model rather than two parallel attrs. */
+  pPrMark?: document_d_exports.ParagraphMarkChange;
+};
+/**
+ * Image position for floating images (horizontal and vertical positioning)
+ */
+type ImagePositionAttrs = {
+  horizontal?: {
+    relativeTo?: NonNullable<document_d_exports.ImagePosition["horizontal"]["relativeTo"]>;
+    posOffset?: number;
+    align?: NonNullable<document_d_exports.ImagePosition["horizontal"]["alignment"]>;
+  };
+  vertical?: {
+    relativeTo?: NonNullable<document_d_exports.ImagePosition["vertical"]["relativeTo"]>;
+    posOffset?: number;
+    align?: NonNullable<document_d_exports.ImagePosition["vertical"]["alignment"]>;
+  };
+};
+/**
+ * Image node attributes
+ */
+type ImageAttrs = {
+  src: string;
+  alt?: string;
+  title?: string; /** Width in pixels (already converted from EMU) */
+  width?: number; /** Height in pixels (already converted from EMU) */
+  height?: number;
+  rId?: string; /** Wrap type from DOCX: inline, square, tight, through, topAndBottom, behind, inFront */
+  wrapType?: document_d_exports.ImageWrap["type"]; /** Display mode for CSS: inline (flows with text), float (left/right float), block (centered) */
+  displayMode?: "inline" | "float" | "block"; /** CSS float direction for floating images */
+  cssFloat?: "left" | "right" | "none"; /** CSS transform string (rotation, flip) */
+  transform?: string;
+  /**
+   * Opacity in [0, 1] from `<a:alphaModFix amt>`. Undefined / 1 means fully
+   * opaque (no CSS `opacity` emitted). eigenpal #424.
+   */
+  opacity?: number; /** Distance from text above (pixels) */
+  distTop?: number; /** Distance from text below (pixels) */
+  distBottom?: number; /** Distance from text left (pixels) */
+  distLeft?: number; /** Distance from text right (pixels) */
+  distRight?: number;
+  /**
+   * wp:srcRect crop fractions in [0, 1]. Carried through the editor so a
+   * cropped image survives parse → edit → serialize. eigenpal #424
+   * (image-crop subset).
+   */
+  cropTop?: number;
+  cropRight?: number;
+  cropBottom?: number;
+  cropLeft?: number; /** Position for floating images (horizontal and vertical alignment) */
+  position?: ImagePositionAttrs; /** Border width in pixels */
+  borderWidth?: number; /** Border color as CSS color string */
+  borderColor?: string; /** Border style (CSS border-style value) */
+  borderStyle?: string; /** Wrap text setting from DOCX (left, right, bothSides, largest) for round-trip */
+  wrapText?: NonNullable<document_d_exports.ImageWrap["wrapText"]>; /** Hyperlink URL for clickable image */
+  hlinkHref?: string; /** Original OOXML for opaque/unsupported DOCX drawings. */
+  _docxRawXml?: string;
+};
+/**
+ * Field node attributes
+ */
+type FieldAttrs = {
+  /** Field type: PAGE, NUMPAGES, DATE, MERGEFIELD, etc. */fieldType: document_d_exports.FieldType; /** Full field instruction (e.g. "PAGE \\* MERGEFORMAT") */
+  instruction: string; /** Current/cached display text */
+  displayText: string; /** Whether the field came from w:fldSimple or a complex fldChar range */
+  fieldKind: "simple" | "complex"; /** Field is locked */
+  fldLock?: boolean; /** Field is dirty and should be recalculated by the host application */
+  dirty?: boolean;
+};
+/**
+ * Math equation node attributes
+ */
+type MathAttrs = {
+  /** Whether this is inline OMML or a block equation paragraph */display?: "inline" | "block"; /** Raw OMML XML for round-trip preservation */
+  ommlXml: string; /** Plain text fallback used by the editor and layout engine */
+  plainText?: string;
+};
+/**
+ * Structured document tag node attributes
+ */
+type SdtAttrs = {
+  /** SDT type */sdtType: document_d_exports.SdtType; /** Alias (friendly name) */
+  alias?: string; /** Tag (developer identifier) */
+  tag?: string; /** Numeric `w:id/@w:val`. */
+  id?: number; /** Lock setting */
+  lock?: NonNullable<document_d_exports.SdtProperties["lock"]>; /** Placeholder text */
+  placeholder?: string; /** Whether showing placeholder */
+  showingPlaceholder?: boolean; /** Date format for date controls */
+  dateFormat?: string; /** ISO 8601 bound date value (`w:date@w:fullDate`). */
+  dateValueISO?: string; /** Dropdown/combobox list items as JSON string */
+  listItems?: string; /** Selected dropdown / comboBox value (`w:dropDownList@w:lastValue`). */
+  dropdownLastValue?: string; /** Checkbox checked state */
+  checked?: boolean; /** Captured `<w:sdtPr>…</w:sdtPr>` for round-trip replay. */
+  rawPropertiesXml?: string; /** Captured `<w:sdtEndPr>…</w:sdtEndPr>` for round-trip replay. */
+  rawEndPropertiesXml?: string;
+};
+/**
+ * Block-level structured document tag node attributes. Mirrors `SdtAttrs`
+ * plus an optional numeric `w:id` and the verbatim `w:sdtPr`/`w:sdtEndPr`
+ * strings captured by the parser for lossless round-trip.
+ */
+type BlockSdtAttrs = {
+  sdtType: document_d_exports.SdtType;
+  alias?: string;
+  tag?: string; /** Numeric `w:id/@w:val`. */
+  id?: number;
+  lock?: NonNullable<document_d_exports.SdtProperties["lock"]>;
+  placeholder?: string;
+  showingPlaceholder?: boolean;
+  dateFormat?: string; /** ISO 8601 bound date value (`w:date@w:fullDate`). */
+  dateValueISO?: string; /** Dropdown/combobox list items as JSON string. */
+  listItems?: string; /** Selected dropdown / comboBox value (`w:dropDownList@w:lastValue`). */
+  dropdownLastValue?: string;
+  checked?: boolean;
+  /**
+   * Marker: source had empty `<w:sdtContent/>`. `toProseDoc` inserts a
+   * filler paragraph to satisfy PM's `block+`; on save the converter
+   * uses this flag to drop the filler instead of guessing from shape.
+   */
+  _originallyEmpty?: boolean; /** Captured `<w:sdtPr>…</w:sdtPr>` for round-trip replay. */
+  rawPropertiesXml?: string; /** Captured `<w:sdtEndPr>…</w:sdtEndPr>` for round-trip replay. */
+  rawEndPropertiesXml?: string; /** Verbatim XML for sdt siblings before sdtContent (range markers). */
+  rawSdtChildrenBeforeContent?: string; /** Verbatim XML for sdt siblings after sdtContent (range markers). */
+  rawSdtChildrenAfterContent?: string;
+};
+/**
+ * Shape node attributes
+ */
+type ShapeAttrs = {
+  /** Shape type preset */shapeType?: string; /** Unique identifier */
+  shapeId?: string; /** Width in pixels */
+  width?: number; /** Height in pixels */
+  height?: number; /** Fill color as CSS color */
+  fillColor?: string; /** Fill type: none, solid, gradient, pattern, picture */
+  fillType?: document_d_exports.ShapeFill["type"]; /** Gradient type: linear, radial, rectangular, path */
+  gradientType?: NonNullable<document_d_exports.ShapeFill["gradient"]>["type"]; /** Gradient angle in degrees (for linear) */
+  gradientAngle?: number; /** Gradient stops as JSON string: [{position, color}] */
+  gradientStops?: string; /** Outline width in pixels */
+  outlineWidth?: number; /** Outline color as CSS color */
+  outlineColor?: string; /** Outline dash style, or `"none"` for an explicit no-outline. */
+  outlineStyle?: OutlineStyleAttr; /** Line cap */
+  outlineCap?: NonNullable<document_d_exports.ShapeOutline["cap"]>; /** Head arrow/end marker */
+  outlineHeadEnd?: NonNullable<document_d_exports.ShapeOutline["headEnd"]>; /** Tail arrow/end marker */
+  outlineTailEnd?: NonNullable<document_d_exports.ShapeOutline["tailEnd"]>; /** CSS transform */
+  transform?: string; /** Display mode */
+  displayMode?: "inline" | "float" | "block"; /** CSS float */
+  cssFloat?: "left" | "right" | "none"; /** Wrap type */
+  wrapType?: document_d_exports.ImageWrap["type"]; /** Wrap text setting from DOCX (left, right, bothSides, largest) for round-trip */
+  wrapText?: NonNullable<document_d_exports.ImageWrap["wrapText"]>; /** Distance from text above (pixels) */
+  distTop?: number; /** Distance from text below (pixels) */
+  distBottom?: number; /** Distance from text left (pixels) */
+  distLeft?: number; /** Distance from text right (pixels) */
+  distRight?: number; /** Position for floating shapes (horizontal and vertical alignment) */
+  position?: ImagePositionAttrs; /** Shadow color as CSS color */
+  shadowColor?: string; /** Shadow blur radius in pixels */
+  shadowBlur?: number; /** Shadow X offset in pixels */
+  shadowOffsetX?: number; /** Shadow Y offset in pixels */
+  shadowOffsetY?: number; /** Glow color as CSS color */
+  glowColor?: string; /** Glow radius in pixels */
+  glowRadius?: number;
+};
+/**
+ * Text box node attributes
+ */
+type TextBoxAttrs = {
+  /** Width in pixels */width?: number; /** Height in pixels */
+  height?: number; /** Unique identifier */
+  textBoxId?: string; /** Fill color as CSS color */
+  fillColor?: string; /** Outline width in pixels */
+  outlineWidth?: number; /** Outline color as CSS color */
+  outlineColor?: string; /** Outline dash style, or `"none"` for an explicit no-outline. */
+  outlineStyle?: OutlineStyleAttr; /** Internal margin top in pixels */
+  marginTop?: number; /** Internal margin bottom in pixels */
+  marginBottom?: number; /** Internal margin left in pixels */
+  marginLeft?: number; /** Internal margin right in pixels */
+  marginRight?: number; /** Vertical text alignment */
+  verticalAlign?: string; /** Display mode */
+  displayMode?: "inline" | "float" | "block"; /** CSS float direction */
+  cssFloat?: "left" | "right" | "none"; /** Wrap type */
+  wrapType?: document_d_exports.ImageWrap["type"]; /** OOXML wrapText direction for anchored text boxes (eigenpal #474). */
+  wrapText?: "bothSides" | "left" | "right" | "largest"; /** Wrap distance from top edge, in pixels (OOXML distT, EMU-converted). */
+  distTop?: number; /** Wrap distance from bottom edge, in pixels. */
+  distBottom?: number; /** Wrap distance from left edge, in pixels. */
+  distLeft?: number; /** Wrap distance from right edge, in pixels. */
+  distRight?: number; /** Position for floating/anchored text boxes */
+  position?: ImagePositionAttrs; /** Original DOCX placement hint for save-path reconstruction. */
+  _docxPlacement?: "standalone" | "inlineWithPrevious"; /** Original DOCX paragraph group for standalone text-box reconstruction. */
+  _docxGroupId?: string;
+};
+/**
+ * Table node attributes
+ */
+type TableAttrs = {
+  /** Table style ID */styleId?: string; /** Table width (in twips) */
+  width?: number; /** Table width type ('auto', 'pct', 'dxa') */
+  widthType?: document_d_exports.TableWidthType; /** Table justification/alignment */
+  justification?: "left" | "center" | "right"; /** Column widths (in twips) from w:tblGrid */
+  columnWidths?: number[]; /** Floating table properties (w:tblpPr) */
+  floating?: document_d_exports.FloatingTableProperties; /** Default cell margins for the table (w:tblCellMar), in twips */
+  cellMargins?: {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+  }; /** Table look flags for conditional formatting (w:tblLook) */
+  look?: document_d_exports.TableLook; /** Table-level borders (w:tblBorders) — full BorderSpec per side */
+  borders?: document_d_exports.TableBorders; /** Original table formatting from DOCX for lossless round-trip serialization */
+  _originalFormatting?: document_d_exports.TableFormatting;
+};
+/**
+ * Table row attributes
+ */
+type TableRowAttrs = {
+  /** Row height (in twips) */height?: number; /** Height rule ('auto', 'exact', 'atLeast') */
+  heightRule?: NonNullable<document_d_exports.TableRowFormatting["heightRule"]>; /** Is header row */
+  isHeader?: boolean; /** Original row formatting from DOCX for lossless round-trip serialization */
+  _originalFormatting?: document_d_exports.TableRowFormatting;
+};
+/**
+ * Table cell attributes
+ */
+type TableCellAttrs = {
+  /** Column span */colspan: number; /** Row span */
+  rowspan: number; /** Column widths for prosemirror-tables resizing (array of pixel widths) */
+  colwidth?: number[] | null; /** Cell width (in twips) */
+  width?: number; /** Cell width type */
+  widthType?: document_d_exports.TableWidthType; /** Vertical alignment */
+  verticalAlign?: "top" | "center" | "bottom"; /** Background color (RGB hex) */
+  backgroundColor?: string; /** OOXML text direction (e.g. 'tbRl', 'btLr') */
+  textDirection?: NonNullable<document_d_exports.TableCellFormatting["textDirection"]>; /** No text wrapping in cell */
+  noWrap?: boolean; /** Cell borders — full BorderSpec per side (style, color, size) */
+  borders?: {
+    top?: document_d_exports.BorderSpec;
+    bottom?: document_d_exports.BorderSpec;
+    left?: document_d_exports.BorderSpec;
+    right?: document_d_exports.BorderSpec;
+  }; /** Cell margins/padding in twips per side */
+  margins?: {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+  }; /** Original cell formatting from DOCX for lossless round-trip serialization */
+  _originalFormatting?: document_d_exports.TableCellFormatting; /** Preserve a DOCX vMerge restart even when PM cannot model it as a rowspan. */
+  _preserveVMergeRestart?: boolean; /** Original DOCX vMerge continuation cells skipped into this PM rowspan. */
+  _docxVMergeContinuationCells?: document_d_exports.TableCell[];
+};
+//#endregion
+export { BlockSdtAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, ParagraphAttrs, SdtAttrs, ShapeAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs };

package/dist/prosemirror/selectionState.d.ts

@@ -0,0 +1,23 @@
+import { document_d_exports } from "../types/document.js";
+import { EditorState } from "prosemirror-state";
+
+//#region src/prosemirror/selectionState.d.ts
+/**
+ * Selection state for toolbar integration
+ */
+type SelectionState = {
+  /** Whether there's an active selection (not just cursor) */hasSelection: boolean; /** Whether selection spans multiple paragraphs */
+  isMultiParagraph: boolean; /** Current text formatting at selection/cursor */
+  textFormatting: document_d_exports.TextFormatting; /** Current paragraph formatting */
+  paragraphFormatting: document_d_exports.ParagraphFormatting; /** Current paragraph style ID (e.g., 'Heading1', 'Normal') */
+  styleId: string | null; /** Start paragraph index */
+  startParagraphIndex: number; /** End paragraph index */
+  endParagraphIndex: number;
+};
+/**
+ * Extract selection state from editor state.
+ * Used by PagedEditor integration in DocxEditor for toolbar state.
+ */
+declare function extractSelectionState(state: EditorState): SelectionState | null;
+//#endregion
+export { SelectionState, extractSelectionState };

package/dist/prosemirror/selectionState.js

@@ -0,0 +1,111 @@
+import { directionIsRtl } from "./paragraphDirection.js";
+//#region src/prosemirror/selectionState.ts
+/**
+* Extract selection state from editor state.
+* Used by PagedEditor integration in DocxEditor for toolbar state.
+*/
+function extractSelectionState(state) {
+	const { selection, doc } = state;
+	const { from, to, empty } = selection;
+	const $from = doc.resolve(from);
+	let startParagraphIndex = 0;
+	let endParagraphIndex = 0;
+	doc.forEach((_node, offset, index) => {
+		if (offset <= from) startParagraphIndex = index;
+		if (offset <= to) endParagraphIndex = index;
+	});
+	let textFormatting = {};
+	const paragraph = $from.parent;
+	const isEmptyParagraph = paragraph.type.name === "paragraph" && paragraph.textContent.length === 0;
+	const paragraphDefaultFormatting = paragraph.attrs["defaultTextFormatting"];
+	const marks = empty ? state.storedMarks || selection.$from.marks() : collectMarksInRange(doc, from, to);
+	if (isEmptyParagraph && marks.length === 0 && paragraphDefaultFormatting) textFormatting = { ...paragraphDefaultFormatting };
+	for (const mark of marks) switch (mark.type.name) {
+		case "bold":
+			textFormatting.bold = true;
+			break;
+		case "italic":
+			textFormatting.italic = true;
+			break;
+		case "underline":
+			textFormatting.underline = {
+				style: mark.attrs["style"] || "single",
+				color: mark.attrs["color"]
+			};
+			break;
+		case "strike":
+			if (mark.attrs["double"]) textFormatting.doubleStrike = true;
+			else textFormatting.strike = true;
+			break;
+		case "textColor":
+			textFormatting.color = {
+				rgb: mark.attrs["rgb"],
+				themeColor: mark.attrs["themeColor"]
+			};
+			break;
+		case "highlight":
+			textFormatting.highlight = mark.attrs["color"];
+			break;
+		case "fontSize":
+			textFormatting.fontSize = mark.attrs["size"];
+			break;
+		case "fontFamily":
+			textFormatting.fontFamily = {
+				ascii: mark.attrs["ascii"],
+				hAnsi: mark.attrs["hAnsi"]
+			};
+			break;
+		case "superscript":
+			textFormatting.vertAlign = "superscript";
+			break;
+		case "subscript":
+			textFormatting.vertAlign = "subscript";
+			break;
+		default: break;
+	}
+	const paragraphFormatting = {};
+	let styleId = null;
+	if (paragraph.type.name === "paragraph") {
+		if (paragraph.attrs["alignment"]) paragraphFormatting.alignment = paragraph.attrs["alignment"];
+		if (paragraph.attrs["lineSpacing"]) {
+			paragraphFormatting.lineSpacing = paragraph.attrs["lineSpacing"];
+			paragraphFormatting.lineSpacingRule = paragraph.attrs["lineSpacingRule"];
+		}
+		if (paragraph.attrs["numPr"]) paragraphFormatting.numPr = paragraph.attrs["numPr"];
+		if (paragraph.attrs["indentLeft"]) paragraphFormatting.indentLeft = paragraph.attrs["indentLeft"];
+		if (paragraph.attrs["indentRight"]) paragraphFormatting.indentRight = paragraph.attrs["indentRight"];
+		if (paragraph.attrs["indentFirstLine"]) paragraphFormatting.indentFirstLine = paragraph.attrs["indentFirstLine"];
+		if (paragraph.attrs["hangingIndent"]) paragraphFormatting.hangingIndent = paragraph.attrs["hangingIndent"];
+		if (paragraph.attrs["tabs"]) paragraphFormatting.tabs = paragraph.attrs["tabs"];
+		if (directionIsRtl(paragraph.attrs["direction"])) paragraphFormatting.bidi = true;
+		if (paragraph.attrs["styleId"]) styleId = paragraph.attrs["styleId"];
+	}
+	return {
+		hasSelection: !empty,
+		isMultiParagraph: startParagraphIndex !== endParagraphIndex,
+		textFormatting,
+		paragraphFormatting,
+		styleId,
+		startParagraphIndex,
+		endParagraphIndex
+	};
+}
+/**
+* Collect the first occurrence of each mark type found on any text node within
+* the range. Mirrors the "any inline child has this mark" semantics that
+* prosemirror-commands' toggleMark uses to decide add-vs-remove, so the
+* toolbar's active state stays consistent with what a toggle click will do.
+*/
+function collectMarksInRange(doc, from, to) {
+	const seen = /* @__PURE__ */ new Map();
+	doc.nodesBetween(from, to, (node) => {
+		if (!node.isText) return;
+		for (const mark of node.marks) {
+			const name = mark.type.name;
+			if (!seen.has(name)) seen.set(name, mark);
+		}
+	});
+	return Array.from(seen.values());
+}
+//#endregion
+export { extractSelectionState };

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

@@ -0,0 +1,2 @@
+import { ResolvedParagraphStyle, StyleResolver, createStyleResolver } from "./styleResolver.js";
+export { type ResolvedParagraphStyle, StyleResolver, createStyleResolver };

package/dist/prosemirror/styles/index.js

@@ -0,0 +1,2 @@
+import { StyleResolver, createStyleResolver } from "./styleResolver.js";
+export { StyleResolver, createStyleResolver };

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

@@ -0,0 +1,32 @@
+import { NumberingMap } from "../../docx/numberingParser.js";
+import { ResolvedParagraphStyle } from "./styleResolver.js";
+
+//#region src/prosemirror/styles/resolvedStyleAttrs.d.ts
+/**
+ * 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.
+ */
+declare function paragraphAttrsFromResolvedStyle(resolved: ResolvedParagraphStyle): Record<string, unknown>;
+/**
+ * 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.
+ */
+declare function listAttrsFromResolvedStyle(resolved: ResolvedParagraphStyle, numbering: NumberingMap | null | undefined): Record<string, unknown> | null;
+//#endregion
+export { listAttrsFromResolvedStyle, paragraphAttrsFromResolvedStyle };