@vivliostyle/core 2.39.1 → 2.41.0

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/toc.d.ts

@@ -19,6 +19,7 @@
  * @fileoverview Toc - Table of Contents view.
  */
 import * as Base from "./base";
+import * as CmykStore from "./cmyk-store";
 import * as Counters from "./counters";
 import * as Exprs from "./exprs";
 import * as Font from "./font";
@@ -49,12 +50,13 @@ export declare class TOCView implements Vgen.CustomRendererFactory {
     };
     readonly documentURLTransformer: Base.DocumentURLTransformer;
     readonly counterStore: Counters.CounterStore;
+    readonly cmykStore: CmykStore.CmykStore;
     pref: Exprs.Preferences;
     page: Vtree.Page;
     instance: OPS.StyleInstance;
     constructor(store: OPS.OPSDocStore, url: string, lang: string | null, clientLayout: Vtree.ClientLayout, fontMapper: Font.Mapper, pref: Exprs.Preferences, rendererFactory: Vgen.CustomRendererFactory, fallbackMap: {
         [key: string]: string;
-    }, documentURLTransformer: Base.DocumentURLTransformer, counterStore: Counters.CounterStore);
+    }, documentURLTransformer: Base.DocumentURLTransformer, counterStore: Counters.CounterStore, cmykStore: CmykStore.CmykStore);
     setAutoHeight(elem: Element, depth: number): void;
     /** @override */
     makeCustomRenderer(xmldoc: XmlDoc.XMLDocHolder): Vgen.CustomRenderer;

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;

package/lib/vivliostyle/vgen.d.ts

@@ -38,7 +38,14 @@ export declare class ViewFactory extends Base.SimpleEventTarget implements Vtree
         [key: string]: string;
     };
     readonly documentURLTransformer: Base.DocumentURLTransformer;
+    readonly pageProps?: {
+        [key: string]: CssCascade.ElementStyle;
+    };
+    readonly cascadedPageStyle?: CssCascade.ElementStyle;
+    private readonly semanticFootnoteFirstRefOffsets;
+    private readonly semanticFootnoteFirstRefOffsetsInitialized;
     private static SVG_URL_ATTRIBUTES;
+    private static FOOTNOTE_CALL_OWNER_ATTR;
     document: Document;
     exprContentListener: Vtree.ExprContentListener;
     nodeContext: Vtree.NodeContext | null;
@@ -49,9 +56,18 @@ export declare class ViewFactory extends Base.SimpleEventTarget implements Vtree
     viewNode: Node | null;
     constructor(flowName: string, context: Exprs.Context, viewport: Viewport, styler: CssStyler.Styler, regionIds: string[], xmldoc: XmlDoc.XMLDocHolder, docFaces: Font.DocumentFaces, footnoteStyle: CssCascade.ElementStyle, stylerProducer: StylerProducer, page: Vtree.Page, customRenderer: CustomRenderer, fallbackMap: {
         [key: string]: string;
-    }, documentURLTransformer: Base.DocumentURLTransformer);
+    }, documentURLTransformer: Base.DocumentURLTransformer, pageProps?: {
+        [key: string]: CssCascade.ElementStyle;
+    }, cascadedPageStyle?: CssCascade.ElementStyle, semanticFootnoteFirstRefOffsets?: Map<string, number | null>, semanticFootnoteFirstRefOffsetsInitialized?: {
+        value: boolean;
+    });
     /** @override */
     clone(): Vtree.LayoutContext;
+    private initializeSemanticFootnoteFirstRefOffsets;
+    /**
+     * True only for the first semantic footnote reference to the same target.
+     */
+    private shouldGenerateSemanticFootnote;
     createPseudoelementShadow(element: Element, isRoot: boolean, cascStyle: CssCascade.ElementStyle, computedStyle: {
         [key: string]: Css.Val;
     }, styler: CssStyler.AbstractStyler, context: Exprs.Context, parentShadow: Vtree.ShadowContext, subShadow: Vtree.ShadowContext): Vtree.ShadowContext;
@@ -125,7 +141,22 @@ export declare class ViewFactory extends Base.SimpleEventTarget implements Vtree
     setCurrent(nodeContext: Vtree.NodeContext, firstTime: boolean, atUnforcedBreak?: boolean): Task.Result<boolean>;
     processShadowContent(pos: Vtree.NodeContext): Vtree.NodeContext;
     private nextPositionInTree;
-    isTransclusion(element: Element, elementStyle: CssCascade.ElementStyle, transclusionType: string | null): boolean;
+    /**
+     * Find a footnote-call element immediately before the given view node.
+     */
+    private findImmediateFootnoteCallSibling;
+    /**
+     * True for semantic footnotes that already provide a noteref call in source
+     * (EPUB or DPUB-ARIA pattern), so an extra ::footnote-call must not be inserted.
+     */
+    private isSemanticFootnoteElement;
+    /**
+     * Insert a footnote-call NodeContext before the footnote element.
+     * The footnote-call will be processed as a normal inline element,
+     * then shadowSibling will lead to the footnote element.
+     * (Issue #868)
+     */
+    private insertFootnoteCall;
     /** @override */
     nextInTree(position: Vtree.NodeContext, atUnforcedBreak?: boolean): Task.Result<Vtree.NodeContext>;
     addImageFetchers(bg: Css.Val): void;
@@ -156,7 +187,7 @@ export declare class ViewFactory extends Base.SimpleEventTarget implements Vtree
     peelOff(nodeContext: Vtree.NodeContext, nodeOffset: number): Task.Result<Vtree.NodeContext>;
     createElement(ns: string, tag: string): Element;
     /** @override */
-    applyFootnoteStyle(vertical: boolean, rtl: boolean, target: Element): boolean;
+    applyFootnoteStyle(vertical: boolean, rtl: boolean, target: Element): Task.Result<boolean>;
     /** @override */
     processFragmentedBlockEdge(nodeContext: Vtree.NodeContext): void;
     private fixClonedBoxDecorationOverflow;
@@ -178,6 +209,7 @@ export declare const propertiesNotPassedToDOM: {
     "flow-linger": boolean;
     "flow-options": boolean;
     "flow-priority": boolean;
+    "footnote-display": boolean;
     "footnote-policy": boolean;
     "margin-break": boolean;
     page: boolean;

package/lib/vivliostyle/vtree.d.ts

@@ -123,6 +123,7 @@ export type Whitespace = Vtree.Whitespace;
  */
 export declare function whitespaceFromPropertyValue(whitespace: string): Whitespace | null;
 export declare function canIgnore(node: Node, whitespace?: Whitespace): boolean;
+export declare function canIgnoreText(text: string, whitespace?: Whitespace): boolean;
 export declare class Flow {
     readonly flowName: string;
     readonly parentFlowName: string | null;
@@ -222,7 +223,6 @@ export declare class NodeContext implements Vtree.NodeContext {
     clearSide: string | null;
     floatMinWrapBlock: Css.Numeric | null;
     columnSpan: Css.Val | null;
-    verticalAlign: string;
     captionSide: string;
     inlineBorderSpacing: number;
     blockBorderSpacing: number;