@vivliostyle/core 2.40.0 → 2.42.0

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

@@ -0,0 +1,74 @@
+/**
+ * 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.
+ *
+ * This module owns semantic-footnote-specific rules that are independent from
+ * the main view-generation flow: element/reference detection, shared marker
+ * attributes, first-reference bookkeeping, and style-merging helpers that can
+ * be driven by injected style accessors.
+ *
+ * Keep view-tree sequencing and DOM construction in vgen.ts. Extend this
+ * module when new DPUB/EPUB semantic footnote behavior can be expressed as
+ * pure reference/style helpers that do not need direct access to ViewFactory
+ * state.
+ */
+import * as Css from "./css";
+import * as Exprs from "./exprs";
+import * as Vtree from "./vtree";
+import { CssCascade } from "./types";
+export declare const SEMANTIC_FOOTNOTE_FIRST_REF_ATTR = "data-vivliostyle-footnote-first-ref";
+export declare const SEMANTIC_FOOTNOTE_REFERENCED_ATTR = "data-vivliostyle-footnote-referenced";
+type CascadeValueLike = {
+    value: Css.Val;
+    priority: number;
+    evaluate?: (context: Exprs.Context, propName: string) => Css.Val;
+    filterValue?: (visitor: unknown) => CascadeValueLike;
+};
+type ElementStyleMap = {
+    [key: string]: CssCascade.ElementStyle;
+};
+export type SemanticFootnoteStyleAccess = {
+    getStyle: (element: Element) => CssCascade.ElementStyle | null;
+    getProp: (style: CssCascade.ElementStyle | null | undefined, propName: string) => CascadeValueLike | null | undefined;
+    getStyleMap: (style: CssCascade.ElementStyle, mapName: string) => ElementStyleMap | null | undefined;
+    getMutableStyleMap: (style: CssCascade.ElementStyle, mapName: string) => ElementStyleMap;
+    createCascadeValue: (value: Css.Val, priority: number) => CascadeValueLike;
+    filterFootnoteMarkerContent: (content: CascadeValueLike, element: Element) => Css.Val;
+};
+export type SemanticFootnoteStyleState = {
+    sourceStyle: CssCascade.ElementStyle | null;
+    footnoteDisplay: Css.Val | null;
+    footnotePolicy: Css.Ident | null;
+};
+export declare function isSemanticFootnoteElement(element: Element): boolean;
+export declare function isSemanticFootnoteNoterefElement(element: Element): boolean;
+export declare function resolveSemanticFootnoteReference(element: Element, baseURL: string): string | null;
+export declare function resolveSemanticFootnoteTarget(element: Element, baseURL: string, resolveElement: (reference: string) => Element | null): Element | null;
+export declare function initializeFirstSemanticFootnoteReferenceOffsets(ownerDocument: Document, baseURL: string, getElementOffset: (element: Element) => number, firstRefOffsets: Map<string, number>, initialized: {
+    value: boolean;
+}): void;
+export declare function shouldGenerateSemanticFootnote(element: Element, baseURL: string, getElementOffset: (element: Element) => number, firstRefOffsets: Map<string, number>, initialized: {
+    value: boolean;
+}): boolean;
+export declare function mergeSemanticFootnoteIncludeStyle(element: Element, elementStyle: CssCascade.ElementStyle, shadowContext: Vtree.ShadowContext | null, baseURL: string, resolveElement: (reference: string) => Element | null, footnoteCounterAttr: string, styleAccess: SemanticFootnoteStyleAccess): CssCascade.ElementStyle;
+export declare function mergeSemanticFootnoteRootStyle(element: Element, elementStyle: CssCascade.ElementStyle, shadowContext: Vtree.ShadowContext | null, context: Exprs.Context, styleAccess: SemanticFootnoteStyleAccess): CssCascade.ElementStyle;
+export declare function getSemanticFootnoteStyleState(element: Element, shadowContext: Vtree.ShadowContext | null, styleAccess: SemanticFootnoteStyleAccess): SemanticFootnoteStyleState;
+export declare function resolveMarkerContentValue(val: Css.Val, context: Exprs.Context): Css.Val;
+export declare function refreshSemanticFootnoteMarkerContent(sourceStyle: CssCascade.ElementStyle | null, computedStyle: {
+    [key: string]: Css.Val;
+}, context: Exprs.Context): void;
+export {};

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;
@@ -476,11 +477,14 @@ export declare namespace PageFloats {
         writingMode: Css.Val;
         direction: Css.Val;
         floatFragments: PageFloatFragment[];
+        ignoreFootnoteAreaMaxHeight: boolean;
         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;
@@ -490,15 +494,18 @@ export declare namespace PageFloats {
         findPageFloatFragment(float: PageFloat): PageFloatFragment | null;
         hasFloatFragments(condition?: (p1: PageFloatFragment) => boolean): boolean;
         hasContinuingFloatFragmentsInFlow(flowName: string): boolean;
+        markPageFloatAnchorSeen(float: PageFloat): void;
         registerPageFloatAnchor(float: PageFloat, anchorViewNode: Node): void;
         collectPageFloatAnchors(): any;
         isAnchorAlreadyAppeared(floatId: PageFloatID): boolean;
         deferPageFloat(continuation: PageFloatContinuation): void;
+        removeFloatDeferredToNext(float: PageFloat): void;
         hasPrecedingFloatsDeferredToNext(float: PageFloat, ignoreReference?: boolean): boolean;
         getLastFollowingFloatInFragments(float: PageFloat): PageFloat | null;
         getDeferredPageFloatContinuations(flowName?: string | null): PageFloatContinuation[];
         getPageFloatContinuationsDeferredToNext(flowName?: string | null): PageFloatContinuation[];
         getFloatsDeferredToNextInChildContexts(): PageFloat[];
+        initFootnoteRetryFromEmptyFragment(float: PageFloat, area: Layout.PageFloatArea): boolean;
         checkAndForbidNotAllowedFloat(): boolean;
         checkAndForbidFloatFollowingDeferredFloat(): boolean;
         finish(): void;
@@ -522,7 +529,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 +546,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 +715,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 +891,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,9 +38,18 @@ 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;
+    private computedStyleParentFontSizeOverride;
+    private computedStyleParentLineHeightOverride;
     nodeContext: Vtree.NodeContext | null;
     viewRoot: Element | null;
     isFootnote: boolean;
@@ -49,9 +58,14 @@ 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 syncSemanticFootnoteCounterToTarget;
     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 +139,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;
@@ -140,6 +169,10 @@ export declare class ViewFactory extends Base.SimpleEventTarget implements Vtree
      * @returns parsed and adjusted value in px, or null if cannot parse as "px" unit, e.g. "normal"
      */
     private parsePlusLayoutUnitAdj;
+    private getFootnoteAreaInheritedMetrics;
+    private getComputedFontMetrics;
+    private getParentViewStyle;
+    private getParentComputedMetrics;
     /**
      * Get "lh" unit size in px
      * @return line-height in px, or null if cannot be determined
@@ -156,7 +189,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 +211,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;