@vivliostyle/core 2.40.0 → 2.41.0

package/lib/vivliostyle/epub.d.ts

@@ -3,6 +3,7 @@ import * as CmykStore from "./cmyk-store";
 import * as Constants from "./constants";
 import * as Counters from "./counters";
 import * as Css from "./css";
+import * as CssCascade from "./css-cascade";
 import * as Exprs from "./exprs";
 import * as Font from "./font";
 import * as Net from "./net";
@@ -37,6 +38,7 @@ export declare class EPUBDocStore extends OPS.OPSDocStore {
     loadAsPlainXML(url: string, opt_required?: boolean, opt_message?: string): Task.Result<XmlDoc.XMLDocHolder>;
     startLoadingAsPlainXML(url: string): void;
     loadAsJSON(url: string, opt_required?: boolean, opt_message?: string): Task.Result<Base.JSON>;
+    loadWebPubManifest(url: string, frame: Task.Frame<OPFDoc>): void;
     loadPubDoc(url: string): Task.Result<OPFDoc>;
     loadEPUBDoc(url: string): Task.Result<OPFDoc>;
     loadOPF(pubURL: string, root: string): Task.Result<OPFDoc>;
@@ -189,6 +191,7 @@ export type OPFViewItem = {
     layoutPositions: Vtree.LayoutPosition[];
     pages: Vtree.Page[];
     complete: boolean;
+    pageCounterStarts: CssCascade.CounterValues[];
 };
 export declare class OPFView implements Vgen.CustomRendererFactory {
     readonly opf: OPFDoc;
@@ -212,6 +215,7 @@ export declare class OPFView implements Vgen.CustomRendererFactory {
     tocAutohide: boolean;
     tocVisible: boolean;
     tocView?: Toc.TOCView;
+    private paginationProgress;
     constructor(opf: OPFDoc, viewport: Vgen.Viewport, fontMapper: Font.Mapper, pref: Exprs.Preferences, pageSheetSizeReporter: (p1: {
         width: number;
         height: number;
@@ -220,7 +224,7 @@ export declare class OPFView implements Vgen.CustomRendererFactory {
             width: number;
             height: number;
         };
-    }, p3: number, p4: number) => any);
+    }, p3: number, p4: number) => any, cmykReserveMap?: CmykStore.CmykReserveMapEntry[]);
     private getPage;
     /**
      * Wait until all previous spine items are loaded before accessing the target
@@ -233,6 +237,27 @@ export declare class OPFView implements Vgen.CustomRendererFactory {
     private waitForPreviousSpines;
     getCurrentPageProgression(position: Position): Constants.PageProgression | null;
     private finishPageContainer;
+    private getRenderedPageCount;
+    /**
+     * Mark a spine item as complete if all layout positions have corresponding
+     * rendered pages (Issue #1498).  When the item becomes complete, clean up
+     * inherited CSS properties that were propagated to the layout box during
+     * page float rendering so they don't leak into the next spine item or
+     * remain in the DOM after layout (Issue #1752).
+     */
+    private markSpineItemCompleteIfReady;
+    private getTotalOffsetForViewItem;
+    private getTotalOffsetAll;
+    private getRenderedOffsetAll;
+    private reportPaginationProgress;
+    private isInCounterResolveScope;
+    private hasNonEmptyPageType;
+    private hasPageTypeBoundaryBetween;
+    private resolvePageTypeForRenderSlot;
+    private evaluateNextPageRelayout;
+    private preparePageCountersForRender;
+    private maybeRelayoutFollowingPage;
+    private resolveUnresolvedReferencesForPage;
     /**
      * Render a single page. If the new page contains elements with ids that are
      * referenced from other pages by 'target-counter()', those pages are rendered
@@ -306,6 +331,7 @@ export declare class OPFView implements Vgen.CustomRendererFactory {
      * Move to the page specified by the given CFI and render it.
      */
     navigateToFragment(fragment: string, position: Position, sync: boolean): Task.Result<PageAndPosition | null>;
+    private resolveSemanticFootnoteNavigationOffset;
     /**
      * Move to the page specified by the given URL and render it.
      */

package/lib/vivliostyle/footnotes.d.ts

@@ -34,7 +34,7 @@ export declare class FootnoteLayoutStrategy implements PageFloats.PageFloatLayou
     /** @override */
     findPageFloatFragment(float: PageFloats.PageFloat, pageFloatLayoutContext: PageFloats.PageFloatLayoutContext): PageFloats.PageFloatFragment | null;
     /** @override */
-    adjustPageFloatArea(floatArea: Layout.PageFloatArea, floatContainer: Vtree.Container, column: Layout.Column): void;
+    adjustPageFloatArea(floatArea: Layout.PageFloatArea, floatContainer: Vtree.Container, column: Layout.Column): Task.Result<void>;
     /** @override */
     forbid(float: PageFloats.PageFloat, pageFloatLayoutContext: PageFloats.PageFloatLayoutContext): void;
 }

package/lib/vivliostyle/layout-helper.d.ts

@@ -13,7 +13,7 @@ export declare function setBrowserColumnBreaking(column: Vtree.Container): void;
  * Disable the browser's multi-column feature for page/column breaking.
  * This function resets the CSS properties set by `setBrowserColumnBreaking`.
  */
-export declare function unsetBrowserColumnBreaking(column: Vtree.Container): void;
+export declare function unsetBrowserColumnBreaking(columnOrElement: Vtree.Container | HTMLElement): void;
 /**
  * Check if the browser's multi-column feature is being used for page/column breaking.
  */
@@ -22,10 +22,6 @@ export declare function isUsingBrowserColumnBreaking(column: Vtree.Container): b
  * Mark the column as a root column for Vivliostyle layout processing.
  */
 export declare function setAsRootColumn(column: Vtree.Container): void;
-/**
- * Check if the column is marked as a root column for Vivliostyle layout processing.
- */
-export declare function isRootColumn(column: Vtree.Container): boolean;
 /**
  * Check if the client rectangle of an element or range is located
  * in a column beyond the current one due to the browser's column breaking.
@@ -71,6 +67,19 @@ export declare function findAncestorNonRootMultiColumn(node: Node): Element | nu
  * Fix overflow caused by forced column breaks in non-root multi-column elements.
  */
 export declare function fixOverflowAtForcedColumnBreak(node: Node): void;
+/**
+ * Check if the root column's content overflows.
+ *
+ * Note: This check is based on the root column's trailing content
+ * (lastElementChild), not only on a specific target element.
+ */
+export declare function checkRootColumnOverflow(column: Layout.Column): number;
+/**
+ * Fix multi-column box with `column-fill: auto` that was changed to `column-fill: balance`
+ * for layout processing, by restoring `column-fill: auto` and setting block-size to prevent overflow.
+ */
+export declare function fixAutoFillMultiColumnBox(element: HTMLElement, column: Layout.Column): void;
+export declare function fixAutoFillMultiColumnBoxes(column: Layout.Column): void;
 /**
  * Calculate the position of the "after" edge in the block-progression.
  * Returns the edge position in pixels if it was determined successfully,
@@ -87,6 +96,18 @@ export declare function removeFollowingSiblings(parentNode: Node, viewNode: Node
 export declare const SPECIAL_ATTR = "data-adapt-spec";
 export declare function isSpecial(e: Element): boolean;
 export declare function isOutOfFlow(node: Node): boolean;
+/**
+ * Check if element is out-of-flow due to CSS positioning or float.
+ * Unlike isOutOfFlow(), this does not check for special marker elements.
+ */
+export declare function isCssOutOfFlow(node: Node): boolean;
+/**
+ * Check if element has position:fixed. Used to identify running elements
+ * (position:running() rendered as position:fixed) without matching
+ * position:absolute elements. (Issue #1833, #1869, #1870)
+ */
+export declare function isFixedPositioned(node: Node): boolean;
 export declare function isSpecialNodeContext(nodeContext: Vtree.NodeContext): boolean;
 export declare function isSpecialInlineDisplay(display: string): boolean;
 export declare function findAncestorSpecialInlineNodeContext(nodeContext: Vtree.NodeContext): Vtree.NodeContext | null;
+export declare function findLastTextNodeInElement(element: Node): Node | null;

package/lib/vivliostyle/layout.d.ts

@@ -117,6 +117,7 @@ export declare class Column extends VtreeImpl.Container implements Layout.Column
     last: Node;
     viewDocument: Document;
     flowRootFormattingContext: Vtree.FormattingContext;
+    isNonFirstColumn: boolean;
     isFloat: boolean;
     isFootnote: boolean;
     startEdge: number;
@@ -140,6 +141,7 @@ export declare class Column extends VtreeImpl.Container implements Layout.Column
     pseudoParent: Column;
     nodeContextOverflowingDueToRepetitiveElements: Vtree.NodeContext | null;
     blockDistanceToBlockEndFloats: number;
+    lastLineStride: number;
     breakAtTheEdgeBeforeFloat: string | null;
     constructor(element: HTMLElement, layoutContext: Vtree.LayoutContext, clientLayout: Vtree.ClientLayout, layoutConstraint: LayoutConstraint, pageFloatLayoutContext: PageFloats.PageFloatLayoutContext);
     getTopEdge(): number;
@@ -148,6 +150,7 @@ export declare class Column extends VtreeImpl.Container implements Layout.Column
     getRightEdge(): number;
     isFloatNodeContext(nodeContext: Vtree.NodeContext): boolean;
     stopByOverflow(nodeContext: Vtree.NodeContext): boolean;
+    private almostEquals;
     isOverflown(edge: number): boolean;
     getExclusions(): GeometryUtil.Shape[];
     openAllViews(position: Vtree.NodePosition): Task.Result<Vtree.NodeContext>;
@@ -187,6 +190,7 @@ export declare class Column extends VtreeImpl.Container implements Layout.Column
      * Create exclusion floats for a column.
      */
     createFloats(): void;
+    private adjustColumnBlockSizeForBlockEndFloats;
     /**
      * @param nodeContext position after the block
      * @param checkPoints array of possible breaking points.
@@ -230,14 +234,15 @@ export declare class Column extends VtreeImpl.Container implements Layout.Column
      * Layout a single float element.
      */
     layoutFloat(nodeContext: Vtree.NodeContext): Task.Result<Vtree.NodeContext>;
-    setupFloatArea(area: PageFloatArea, floatReference: PageFloats.FloatReference, floatSide: string, anchorEdge: number | null, strategy: PageFloats.PageFloatLayoutStrategy, condition: PageFloats.PageFloatPlacementCondition): boolean;
-    createPageFloatArea(float: PageFloats.PageFloat | null, floatSide: string, anchorEdge: number | null, strategy: PageFloats.PageFloatLayoutStrategy, condition: PageFloats.PageFloatPlacementCondition): PageFloatArea | null;
+    setupFloatArea(area: PageFloatArea, floatReference: PageFloats.FloatReference, floatSide: string, anchorEdge: number | null, strategy: PageFloats.PageFloatLayoutStrategy, condition: PageFloats.PageFloatPlacementCondition): Task.Result<boolean>;
+    createPageFloatArea(float: PageFloats.PageFloat | null, floatSide: string, anchorEdge: number | null, strategy: PageFloats.PageFloatLayoutStrategy, condition: PageFloats.PageFloatPlacementCondition): Task.Result<PageFloatArea | null>;
     layoutSinglePageFloatFragment(continuations: PageFloats.PageFloatContinuation[], floatSide: string, clearSide: string | null, allowFragmented: boolean, strategy: PageFloats.PageFloatLayoutStrategy, anchorEdge: number | null, pageFloatFragment?: PageFloats.PageFloatFragment | null): Task.Result<SinglePageFloatLayoutResult>;
     layoutPageFloatInner(continuation: PageFloats.PageFloatContinuation, strategy: PageFloats.PageFloatLayoutStrategy, anchorEdge: number | null, pageFloatFragment?: PageFloats.PageFloatFragment): Task.Result<boolean>;
     /**
      * @returns Represents if the layout was succeeded or not
      */
     private layoutStashedPageFloats;
+    private findFootnoteCallElement;
     setFloatAnchorViewNode(nodeContext: Vtree.NodeContext): Vtree.NodeContext;
     resolveFloatReferenceFromColumnSpan(floatReference: PageFloats.FloatReference, columnSpan: Css.Val, nodeContext: Vtree.NodeContext): Task.Result<PageFloats.FloatReference>;
     layoutPageFloat(nodeContext: Vtree.NodeContext): Task.Result<Vtree.NodeContext>;
@@ -287,9 +292,30 @@ export declare class Column extends VtreeImpl.Container implements Layout.Column
      */
     isBreakable(flowPosition: Vtree.NodeContext): boolean;
     /**
-     * Determines if an indent value is zero
+     * Determines if a CSS length value is empty or zero.
      */
-    zeroIndent(val: string | number): boolean;
+    isZeroLength(val: string): boolean;
+    /**
+     * Check if element has non-zero block-start inset (padding + border).
+     * Handles both horizontal and vertical writing modes.
+     */
+    hasNonZeroBlockStartInset(style: CSSStyleDeclaration): boolean;
+    /**
+     * Check if element has non-zero block-end inset (padding + border).
+     * Handles both horizontal and vertical writing modes.
+     */
+    hasNonZeroBlockEndInset(style: CSSStyleDeclaration): boolean;
+    /**
+     * Temporarily suppress block-end padding/border on ancestor containers
+     * that are still being laid out (not yet complete) when using browser
+     * column breaking for overflow detection. This prevents the browser's
+     * column-breaking layout from incorrectly accounting for padding that
+     * will be removed at actual break points due to box-decoration-break:
+     * slice (the default). (Issue #1846)
+     *
+     * Returns a cleanup function that restores the original state.
+     */
+    private suppressOpenAncestorBlockEndInset;
     /**
      * @return true if overflows
      */
@@ -302,6 +328,12 @@ export declare class Column extends VtreeImpl.Container implements Layout.Column
     checkOverflowAndSaveEdgeAndBreakPosition(nodeContext: Vtree.NodeContext, trailingEdgeContexts: Vtree.NodeContext[], saveEvenOverflown: boolean, breakAtTheEdge: string | null): boolean;
     applyClearance(nodeContext: Vtree.NodeContext): boolean;
     isBFC(formattingContext: Vtree.FormattingContext): boolean;
+    /**
+     * Check if the nodeContext has a position:fixed ancestor in the view tree.
+     * Used to detect text inside running elements (position:running() rendered
+     * as position:fixed). (Issue #1833)
+     */
+    hasFixedPositionAncestor(nodeContext: Vtree.NodeContext): boolean;
     /**
      * Skips positions until either the start of unbreakable block or inline
      * content. Also sets breakBefore on the result combining break-before and
@@ -375,6 +407,7 @@ export declare class Column extends VtreeImpl.Container implements Layout.Column
 export declare class PseudoColumn {
     startNodeContexts: Vtree.NodeContext[];
     private column;
+    private readonly flowRootSourceNode;
     constructor(column: Layout.Column, viewRoot: HTMLElement, parentNodeContext: Vtree.NodeContext);
     /**
      * @param chunkPosition starting position.
@@ -389,6 +422,7 @@ export declare class PseudoColumn {
     doFinishBreakOfFragmentLayoutConstraints(positionAfter: Vtree.NodeContext): void;
     isStartNodeContext(nodeContext: Vtree.NodeContext): boolean;
     isLastAfterNodeContext(nodeContext: Vtree.NodeContext): boolean;
+    private isEffectivelyLastAfterNodeContext;
     getColumnElement(): Element;
     getColumn(): Layout.Column;
 }
@@ -410,6 +444,7 @@ export declare class ColumnLayoutRetryer extends LayoutRetryers.AbstractLayoutRe
     private initialPageBreakType;
     initialComputedBlockSize: number;
     private initialOverflown;
+    private initialLastLineStride;
     context: {
         overflownNodeContext: Vtree.NodeContext;
     };
@@ -447,4 +482,8 @@ export declare class PageFloatArea extends Column implements Layout.PageFloatAre
     convertPercentageSizesToPx(target: Element): void;
     fixFloatSizeAndPosition(nodeContext: Vtree.NodeContext): void;
     getContentInlineSize(): number;
+    getContentBlockMarginAfter(): number;
+    applyCompactFootnoteDisplay(): void;
+    private updateComputedBlockSizeForFootnoteArea;
+    private updateInlineFootnoteSeparators;
 }

package/lib/vivliostyle/ops.d.ts

@@ -104,6 +104,7 @@ export declare class StyleInstance extends Exprs.Context implements CssStyler.Fl
     };
     currentLayoutPosition: Vtree.LayoutPosition;
     layoutPositionAtPageStart: Vtree.LayoutPosition;
+    currentCascadedPageStyle: CssCascade.ElementStyle;
     lookupOffset: number;
     faces: Font.DocumentFaces;
     pageBoxInstances: {
@@ -125,6 +126,12 @@ export declare class StyleInstance extends Exprs.Context implements CssStyler.Fl
     };
     pageSheetHeight: number;
     pageSheetWidth: number;
+    private semanticFootnoteFirstRefOffsets;
+    private semanticFootnoteFirstRefOffsetsInitialized;
+    pageGroupPageCounts: {
+        [pageType: string]: Map<Element, number>;
+    };
+    currentPageGroupDocument: Document | null;
     constructor(style: Style, xmldoc: XmlDoc.XMLDocHolder, defaultLang: string | null, viewport: Vgen.Viewport, clientLayout: Vtree.ClientLayout, fontMapper: Font.Mapper, customRenderer: Vgen.CustomRenderer, fallbackMap: {
         [key: string]: string;
     }, pageNumberOffset: number, documentURLTransformer: Base.DocumentURLTransformer, counterStore: Counters.CounterStore, cmykStore: CmykStore.CmykStore, pageProgression?: Constants.PageProgression, isVersoFirstPage?: boolean);
@@ -145,6 +152,38 @@ export declare class StyleInstance extends Exprs.Context implements CssStyler.Fl
      */
     private evalSupportsSelector;
     getConsumedOffset(flowPosition: Vtree.FlowPosition): number;
+    private getNodePositionOffset;
+    private getPageStartOffset;
+    private getPageStartCounterOffsets;
+    private getPageStartElement;
+    private isForcedPageBreakValue;
+    private hasForcedPageBreakBefore;
+    private getExplicitPageType;
+    private getPageGroupPageType;
+    private getPreviousInFlowSibling;
+    private getFirstDocumentFlowElement;
+    /**
+     * Resolve the page type for the first page by examining the first in-flow
+     * element's CSS `page` property. This is needed because `currentPageType`
+     * is only set during layout (in ViewFactory), but the first page's type
+     * must be known before layout begins for correct @page rule matching.
+     *
+     * Note: This must NOT set `currentPageType` as a side effect. Setting it
+     * early would cause intermediate wrapper elements (whose page type is
+     * null/auto) to get unwanted `breakBefore: "page"` during view tree
+     * construction, since their page type would differ from `currentPageType`.
+     * The `currentPageType` will be set naturally when the content element
+     * is processed during layout. (Issue #1869, #1870)
+     */
+    private resolveFirstPageType;
+    private shouldStartPageGroup;
+    private updatePageGroupPageIndices;
+    private getFirstInFlowElementAtOrAfter;
+    private getDeepestFirstInFlowChildOffset;
+    private getFirstInFlowChildElement;
+    private isNormalFlowElement;
+    private isInlineLevelElement;
+    private getDisplayValue;
     /**
      * @param noLookAhead Do not look ahead elements that are not styled yet
      * @return document offset of the given layoutPosition
@@ -159,6 +198,9 @@ export declare class StyleInstance extends Exprs.Context implements CssStyler.Fl
     selectPageMaster(cascadedPageStyle: CssCascade.ElementStyle): PageMaster.PageMasterInstance;
     flowChunkIsAfterParentFlowForcedBreak(flowChunk: Vtree.FlowChunk): boolean;
     setFormattingContextToColumn(column: LayoutType.Column, flowName: string): void;
+    beginIsolatedRootPageFloatLayoutContext(): PageFloats.PageFloatLayoutContext;
+    endIsolatedRootPageFloatLayoutContext(originalRootPageFloatLayoutContext: PageFloats.PageFloatLayoutContext): void;
+    hasActiveRootPageFloatLayoutContext(): boolean;
     layoutDeferredPageFloats(column: LayoutType.Column): Task.Result<boolean>;
     getLastAfterPositionIfDeferredFloatsExists(column: LayoutType.Column, newPosition: Vtree.ChunkPosition | null): Vtree.ChunkPosition | null;
     /**

package/lib/vivliostyle/page-floats.d.ts

@@ -22,6 +22,19 @@ export declare class PageFloat implements PageFloats.PageFloat {
     readonly floatMinWrapBlock: Css.Numeric | null;
     order: number | null;
     id: PageFloatID | null;
+    /**
+     * Set to true when this float is created inside a page float area.
+     * Used to bypass the normal anchor check in isAllowedOnContext because
+     * the anchor node is lost after page-level invalidation. (Issue #1675)
+     */
+    insidePageFloatArea: boolean;
+    /**
+     * Reference to the parent page float that contains this float.
+     * Set when this float is created inside a page float area, allowing
+     * isAllowedOnContext to check whether the parent is still present.
+     * (Issue #1675)
+     */
+    parentPageFloat: PageFloat | null;
     constructor(nodePosition: Vtree.NodePosition, floatReference: FloatReference, floatSide: string, clearSide: string | null, flowName: string, floatMinWrapBlock: Css.Numeric | null);
     getOrder(): number;
     getId(): PageFloatID;
@@ -89,8 +102,28 @@ export declare class PageFloatLayoutContext implements PageFloats.PageFloatLayou
     private floatsDeferredFromPrevious;
     private layoutConstraints;
     private locked;
+    /**
+     * Reference to the outer column's context for page float area contexts.
+     * Used only for getParent() navigation to propagate nested page floats
+     * and footnotes to region/page level. Unlike `parent`, this does NOT
+     * affect children registration, isInvalidated() propagation, or
+     * getFloatFragmentExclusions(). (Issue #1675)
+     */
+    private outerContext;
     constructor(parent: PageFloatLayoutContext, floatReference: FloatReference | null, container: Vtree.Container, flowName: string | null, generatingNodePosition: Vtree.NodePosition | null, writingMode: Css.Val | null, direction: Css.Val | null);
+    /**
+     * Returns the effective parent context for hierarchy traversal.
+     * For normal contexts, returns `parent`. For page float area contexts
+     * (where `parent` is null), falls back to `outerContext`. (Issue #1675)
+     */
+    get effectiveParent(): PageFloatLayoutContext | null;
     private getParent;
+    /**
+     * Set the outer context for a page float area context.
+     * This shares the float store so that page floats/footnotes created inside
+     * a page float area are visible at all levels. (Issue #1675)
+     */
+    setOuterContext(outerContext: PageFloatLayoutContext): void;
     private getPreviousSiblingOf;
     private getPreviousSibling;
     getContainer(floatReference?: FloatReference): Vtree.Container;
@@ -144,7 +177,8 @@ export declare class PageFloatLayoutContext implements PageFloats.PageFloatLayou
     getFloatFragmentExclusions(): GeometryUtil.Shape[];
     private reattachFloatFragments;
     getMaxReachedAfterEdge(): number;
-    getBlockStartEdgeOfBlockEndFloats(): number;
+    getBlockEndEdgeOfBlockStartFloats(inlinePos?: number): number;
+    getBlockStartEdgeOfBlockEndFloats(inlinePos?: number): number;
     getPageFloatClearEdge(clear: string, column: LayoutType.Column): number;
     getPageFloatPlacementCondition(float: PageFloat, floatSide: string, clearSide: string | null): PageFloatPlacementCondition;
     getLayoutConstraints(): LayoutType.LayoutConstraint[];
@@ -174,7 +208,7 @@ export declare class NormalPageFloatLayoutStrategy implements PageFloatLayoutStr
     /** @override */
     findPageFloatFragment(float: PageFloat, pageFloatLayoutContext: PageFloatLayoutContext): PageFloatFragment | null;
     /** @override */
-    adjustPageFloatArea(floatArea: LayoutType.PageFloatArea, floatContainer: Vtree.Container, column: LayoutType.Column): void;
+    adjustPageFloatArea(floatArea: LayoutType.PageFloatArea, floatContainer: Vtree.Container, column: LayoutType.Column): Task.Result<void>;
     /** @override */
     forbid(float: PageFloat, pageFloatLayoutContext: PageFloatLayoutContext): void;
 }

package/lib/vivliostyle/plugin.d.ts

@@ -125,7 +125,15 @@ export declare enum HOOKS {
      *  {Array.<Vtree.NodeContext>} checkPoints
      *  {Layout.Column} column
      */
-    POST_LAYOUT_BLOCK = "POST_LAYOUT_BLOCK"
+    POST_LAYOUT_BLOCK = "POST_LAYOUT_BLOCK",
+    /**
+     * Called when pagination progresses during document load.
+     *
+     * The hook is called with an object with the following properties:
+     *  {number} fraction: Fraction of the HTML content already paginated (0-1)
+     *  {number} pages: Number of pages created so far
+     */
+    PAGINATION_PROGRESS = "PAGINATION_PROGRESS"
 }
 export type PreProcessSingleDocumentHook = (p1: Document) => any;
 export type PreProcessTextContentHook = (p1: Vtree.NodeContext, p2: string) => Task.Result<string>;
@@ -139,6 +147,10 @@ export type ResolveTextNodeBreakerHook = (p1: Vtree.NodeContext) => Layout.TextN
 export type ResolveFormattingContextHook = (p1: Vtree.NodeContext, p2: boolean, p3: Css.Val, p4: Css.Ident, p5: Css.Val, p6: boolean) => Vtree.FormattingContext;
 export type ResolveLayoutProcessorHook = (p1: Vtree.FormattingContext) => LayoutProcessor.LayoutProcessor;
 export type PostLayoutBlockHook = (p1: Vtree.NodeContext, p2: Vtree.NodeContext[], p3: Layout.Column) => void;
+export type PaginationProgressHook = (p1: {
+    fraction: number;
+    pages: number;
+}) => void;
 /**
  * Register a function to a hook with the specified name.
  * The registered function is called at appropriate timings by the core code.

package/lib/vivliostyle/pseudo-element.d.ts

@@ -29,8 +29,4 @@ export declare class PseudoelementStyler implements PseudoElement.PseudoelementS
     processContent(element: Element, styles: {
         [key: string]: Css.Val;
     }, nodeContext: Vtree.NodeContext): void;
-    /**
-     * ::marker support
-     */
-    private processMarker;
 }

package/lib/vivliostyle/semantic-footnote.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2026 Vivliostyle Foundation
+ *
+ * Vivliostyle.js is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Vivliostyle.js is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Vivliostyle.js.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @fileoverview Semantic footnote helper utilities.
+ */
+export declare function isSemanticFootnoteElement(element: Element): boolean;
+export declare function isSemanticFootnoteNoterefElement(element: Element): boolean;

package/lib/vivliostyle/table.d.ts

@@ -10,6 +10,8 @@ export declare class TableRow {
     readonly rowIndex: number;
     readonly sourceNode: Node;
     cells: TableCell[];
+    breakBefore: string | null;
+    breakAfter: string | null;
     constructor(rowIndex: number, sourceNode: Node);
     addCell(cell: TableCell): void;
     getMinimumHeight(): number;
@@ -51,6 +53,13 @@ export declare class BetweenTableRowBreakPosition extends BreakPosition.EdgeBrea
     private rowIndex;
     constructor(position: Vtree.NodeContext, breakOnEdge: string | null, overflows: boolean, columnBlockSize: number);
     findAcceptableBreak(column: Layout.Column, penalty: number): Vtree.NodeContext;
+    /**
+     * Check if any non-spanning cell in the row has content that wasn't fully
+     * rendered. This happens when page floats (footnotes) reduce available space
+     * during a retry, causing cell content to overflow within the row even though
+     * the row boundary appears acceptable. (Issue #1663)
+     */
+    private hasUnfinishedCells;
     getMinBreakPenalty(): number;
     getAcceptableCellBreakPositions(): Layout.BreakPositionAndNodeContext[];
     private getRowIndex;
@@ -161,10 +170,19 @@ export declare class TableLayoutStrategy extends LayoutUtil.EdgeSkipper {
     inHeader: boolean;
     inFooter: boolean;
     constructor(formattingContext: TableFormattingContext, column: Layout.Column);
+    startNonInlineElementNode(state: LayoutUtil.LayoutIteratorState): void | Task.Result<boolean>;
     resetColumn(): void;
     getColSpanningCellWidth(cell: TableCell): number;
     layoutCell(cell: TableCell, cellNodeContext: Vtree.NodeContext, startChunkPosition: Vtree.ChunkPosition): Task.Result<boolean>;
-    hasBrokenCellAtSlot(slotIndex: any): boolean;
+    /**
+     * Find the break position for the cell at the given slot index.
+     * Returns the break position and its index in cellBreakPositions, or null if not found.
+     * Uses sourceNode matching instead of sequential index to support layout retry (issue #1663).
+     */
+    findBrokenCellAtSlot(slotIndex: number, sourceNode: Node): {
+        position: BrokenTableCellPosition;
+        index: number;
+    } | null;
     private extractRowSpanningCellBreakPositions;
     layoutRowSpanningCellsFromPreviousFragment(state: LayoutUtil.LayoutIteratorState): Task.Result<boolean>;
     startTableRow(state: LayoutUtil.LayoutIteratorState): Task.Result<boolean>;
@@ -186,6 +204,11 @@ export declare class TableLayoutProcessor implements LayoutProcessor.LayoutProce
      */
     normalizeColGroups(formattingContext: TableFormattingContext, tableElement: Element, column: Layout.Column): void;
     doInitialLayout(nodeContext: Vtree.NodeContext, column: Layout.Column): Task.Result<Vtree.NodeContext>;
+    /**
+     * Check if any row inside the table has a forced break value
+     * (propagated from cells or set on the row itself).
+     */
+    private hasForcedBreakInRows;
     addCaptions(formattingContext: TableFormattingContext, rootViewNode: Element, firstChild: Node | null): void;
     addColGroups(formattingContext: TableFormattingContext, rootViewNode: Element, firstChild: Node | null): void;
     removeColGroups(formattingContext: TableFormattingContext, rootViewNode: Element): void;

package/lib/vivliostyle/types.d.ts

@@ -110,6 +110,7 @@ export declare namespace Layout {
         last: Node;
         viewDocument: Document;
         flowRootFormattingContext: Vtree.FormattingContext;
+        isNonFirstColumn: boolean;
         isFloat: boolean;
         isFootnote: boolean;
         startEdge: number;
@@ -142,6 +143,7 @@ export declare namespace Layout {
         pseudoParent: Column;
         nodeContextOverflowingDueToRepetitiveElements: Vtree.NodeContext | null;
         blockDistanceToBlockEndFloats: number;
+        lastLineStride: number;
         computedBlockSize: number;
         layoutContext: Vtree.LayoutContext;
         clientLayout: Vtree.ClientLayout;
@@ -235,8 +237,8 @@ export declare namespace Layout {
          * Layout a single float element.
          */
         layoutFloat(nodeContext: Vtree.NodeContext): Task.Result<Vtree.NodeContext>;
-        setupFloatArea(area: PageFloatArea, floatReference: PageFloats.FloatReference, floatSide: string, anchorEdge: number | null, strategy: PageFloats.PageFloatLayoutStrategy, condition: PageFloats.PageFloatPlacementCondition): boolean;
-        createPageFloatArea(float: PageFloats.PageFloat | null, floatSide: string, anchorEdge: number | null, strategy: PageFloats.PageFloatLayoutStrategy, condition: PageFloats.PageFloatPlacementCondition): PageFloatArea | null;
+        setupFloatArea(area: PageFloatArea, floatReference: PageFloats.FloatReference, floatSide: string, anchorEdge: number | null, strategy: PageFloats.PageFloatLayoutStrategy, condition: PageFloats.PageFloatPlacementCondition): Task.Result<boolean>;
+        createPageFloatArea(float: PageFloats.PageFloat | null, floatSide: string, anchorEdge: number | null, strategy: PageFloats.PageFloatLayoutStrategy, condition: PageFloats.PageFloatPlacementCondition): Task.Result<PageFloatArea | null>;
         layoutSinglePageFloatFragment(continuations: PageFloats.PageFloatContinuation[], floatSide: string, clearSide: string | null, allowFragmented: boolean, strategy: PageFloats.PageFloatLayoutStrategy, anchorEdge: number | null, pageFloatFragment?: PageFloats.PageFloatFragment | null): Task.Result<SinglePageFloatLayoutResult>;
         layoutPageFloatInner(continuation: PageFloats.PageFloatContinuation, strategy: PageFloats.PageFloatLayoutStrategy, anchorEdge: number | null, pageFloatFragment?: PageFloats.PageFloatFragment): Task.Result<boolean>;
         setFloatAnchorViewNode(nodeContext: Vtree.NodeContext): Vtree.NodeContext;
@@ -286,10 +288,6 @@ export declare namespace Layout {
          * Determines if a page break is acceptable at this position
          */
         isBreakable(flowPosition: Vtree.NodeContext): boolean;
-        /**
-         * Determines if an indent value is zero
-         */
-        zeroIndent(val: string | number): boolean;
         /**
          * @return true if overflows
          */
@@ -384,6 +382,7 @@ export declare namespace Layout {
         readonly parentContainer: Vtree.Container;
         convertPercentageSizesToPx(target: Element): void;
         fixFloatSizeAndPosition(nodeContext: Vtree.NodeContext): void;
+        getContentBlockMarginAfter(): number;
         getContentInlineSize(): number;
     }
 }
@@ -437,6 +436,8 @@ export declare namespace PageFloats {
     interface PageFloat {
         order: number | null;
         id: PageFloatID | null;
+        insidePageFloatArea: boolean;
+        parentPageFloat: PageFloat | null;
         readonly nodePosition: Vtree.NodePosition;
         readonly floatReference: FloatReference;
         readonly floatSide: string;
@@ -477,10 +478,12 @@ export declare namespace PageFloats {
         direction: Css.Val;
         floatFragments: PageFloatFragment[];
         readonly parent: PageFloatLayoutContext;
+        readonly effectiveParent: PageFloatLayoutContext | null;
         readonly flowName: string | null;
         readonly generatingNodePosition: Vtree.NodePosition | null;
         getContainer(floatReference?: FloatReference): Vtree.Container;
         setContainer(container: Vtree.Container): any;
+        setOuterContext(outerContext: PageFloatLayoutContext): void;
         addPageFloat(float: PageFloat): void;
         getPageFloatLayoutContext(floatReference: FloatReference): PageFloatLayoutContext;
         findPageFloatByNodePosition(nodePosition: Vtree.NodePosition): PageFloat | null;
@@ -522,7 +525,8 @@ export declare namespace PageFloats {
         setFloatAreaDimensions(area: Layout.PageFloatArea, floatReference: FloatReference, floatSide: string, anchorEdge: number | null, init: boolean, force: boolean, condition: PageFloatPlacementCondition): string | null;
         getFloatFragmentExclusions(): GeometryUtil.Shape[];
         getMaxReachedAfterEdge(): number;
-        getBlockStartEdgeOfBlockEndFloats(): number;
+        getBlockEndEdgeOfBlockStartFloats(inlinePos?: number): number;
+        getBlockStartEdgeOfBlockEndFloats(inlinePos?: number): number;
         getPageFloatClearEdge(clear: string, column: Layout.Column): number;
         getPageFloatPlacementCondition(float: PageFloat, floatSide: string, clearSide: string | null): PageFloatPlacementCondition;
         getLayoutConstraints(): Layout.LayoutConstraint[];
@@ -538,7 +542,7 @@ export declare namespace PageFloats {
         createPageFloat(nodeContext: Vtree.NodeContext, pageFloatLayoutContext: PageFloatLayoutContext, column: Layout.Column): Task.Result<PageFloat>;
         createPageFloatFragment(continuations: PageFloatContinuation[], floatSide: string, clearSide: string | null, floatArea: Layout.PageFloatArea, continues: boolean): PageFloatFragment;
         findPageFloatFragment(float: PageFloat, pageFloatLayoutContext: PageFloatLayoutContext): PageFloatFragment | null;
-        adjustPageFloatArea(floatArea: Layout.PageFloatArea, floatContainer: Vtree.Container, column: Layout.Column): any;
+        adjustPageFloatArea(floatArea: Layout.PageFloatArea, floatContainer: Vtree.Container, column: Layout.Column): Task.Result<void>;
         forbid(float: PageFloat, pageFloatLayoutContext: PageFloatLayoutContext): any;
     }
 }
@@ -707,7 +711,7 @@ export declare namespace Vtree {
          * @param target element to apply styles to
          * @return vertical
          */
-        applyFootnoteStyle(vertical: boolean, rtl: boolean, target: Element): boolean;
+        applyFootnoteStyle(vertical: boolean, rtl: boolean, target: Element): Task.Result<boolean>;
         /**
          * Peel off innermost first-XXX pseudoelement, create and create view nodes
          * after the end of that pseudoelement.
@@ -883,7 +887,6 @@ export declare namespace Vtree {
         clearSide: string | null;
         floatMinWrapBlock: Css.Numeric | null;
         columnSpan: Css.Val | null;
-        verticalAlign: string;
         captionSide: string;
         inlineBorderSpacing: number;
         blockBorderSpacing: number;