@vivliostyle/core 2.40.0 → 2.42.0

package/lib/vivliostyle/css-prop.d.ts

@@ -54,16 +54,20 @@ export declare class ShapeVisitor extends Css.Visitor {
 export declare function toShape(val: Css.Val, x: number, y: number, width: number, height: number, context: Exprs.Context): GeometryUtil.Shape;
 export declare class CountersVisitor extends Css.Visitor {
     readonly reset: boolean;
+    readonly defaultValue: number;
     counters: {
         [key: string]: number;
     };
     name: string | null;
-    constructor(reset: boolean);
+    constructor(reset: boolean, defaultValue: number);
     visitIdent(ident: Css.Ident): Css.Val;
     visitInt(num: Css.Int): Css.Val;
     visitSpaceList(list: Css.SpaceList): Css.Val;
 }
-export declare function toCounters(val: Css.Val, reset: boolean): {
+export declare function toCounters(val: Css.Val, options?: {
+    reset?: boolean;
+    defaultValue?: number;
+}): {
     [key: string]: number;
 };
 export declare class UrlTransformVisitor extends Css.FilterVisitor {

package/lib/vivliostyle/css-styler.d.ts

@@ -27,6 +27,14 @@ export declare class SlipMap {
      */
     fixedBySlipped(slipped: number): number;
 }
+type CounterSnapshot = {
+    offset: number;
+    counters: CssCascade.CounterValues;
+    changes: string[];
+    changeTypes?: {
+        [key: string]: "reset" | "set" | "increment";
+    };
+};
 export interface FlowListener {
     encounteredFlowChunk(flowChunk: Vtree.FlowChunk, flow: Vtree.Flow): void;
 }
@@ -151,6 +159,7 @@ export declare class Styler implements AbstractStyler {
     styleMap: {
         [key: string]: CssCascade.ElementStyle;
     };
+    counterSnapshots: CounterSnapshot[];
     flows: {
         [key: string]: Vtree.Flow;
     };
@@ -183,6 +192,11 @@ export declare class Styler implements AbstractStyler {
     postprocessTopStyle(elemStyle: CssCascade.ElementStyle, isBody: boolean): void;
     getTopContainerStyle(): CssCascade.ElementStyle;
     getAttrStyle(elem: Element): CssCascade.ElementStyle;
+    recordCounterSnapshot(offset: number, counters: CssCascade.CounterValues, changes?: string[], changeTypes?: {
+        [key: string]: "reset" | "set" | "increment";
+    }): void;
+    getCounterSnapshotAtOffset(offset: number): CounterSnapshot | null;
+    getLastCounterSnapshot(): CounterSnapshot | null;
     /**
      * @return currently reached offset
      */
@@ -210,3 +224,4 @@ export declare class Styler implements AbstractStyler {
     }, nodeContext: Vtree.NodeContext): void;
 }
 export declare const columnProps: string[];
+export {};

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

@@ -6,7 +6,8 @@ import { Layout } from "./types";
 declare const PageFloatFragment: typeof PageFloats.PageFloatFragment;
 export declare class Footnote extends PageFloats.PageFloat {
     readonly footnotePolicy: Css.Ident | null;
-    constructor(nodePosition: Vtree.NodePosition, floatReference: PageFloats.FloatReference, flowName: string, footnotePolicy: Css.Ident | null, floatMinWrapBlock: Css.Numeric | null);
+    readonly policyAnchorNode: Node;
+    constructor(nodePosition: Vtree.NodePosition, floatReference: PageFloats.FloatReference, flowName: string, footnotePolicy: Css.Ident | null, floatMinWrapBlock: Css.Numeric | null, policyAnchorNode: Node);
     isAllowedToPrecede(other: PageFloats.PageFloat): boolean;
 }
 /**
@@ -34,7 +35,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.
@@ -62,6 +58,19 @@ export declare function getElementClientRectAdjusted(clientLayout: Vtree.ClientL
  * This is used to prevent unnecessary blank pages.
  */
 export declare function clearForcedColumnBreaks(prevNode: Node, currNode: Node): void;
+/**
+ * Check if an element has non-root multi-column styles (column-count or
+ * column-width) set on its inline style.
+ *
+ * NOTE: Do not use `instanceof HTMLElement` for the check because it does
+ * not work when the node is inside an iframe. (Issue #1000)
+ */
+export declare function hasNonRootMultiColumnStyle(element: Element): boolean;
+/**
+ * Check if the given element or any of its descendants establishes a
+ * non-root multi-column layout (via inline style).
+ */
+export declare function containsNonRootMultiColumn(element: Element): boolean;
 /**
  * Find the nearest ancestor element that establishes a multi-column
  * layout but is not the root column element.
@@ -71,6 +80,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 +109,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,13 @@ 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 getFootnoteAfterPseudo;
+    private hasAuthorFootnoteAfterPseudo;
+    private createDefaultFootnoteAfterPseudo;
+    private getFootnoteBreakOpportunity;
+    private createFootnoteBreakOpportunity;
+    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,49 @@ export declare class PageFloatLayoutContext implements PageFloats.PageFloatLayou
     private floatsDeferredFromPrevious;
     private layoutConstraints;
     private locked;
+    /**
+     * Maximum outer block size for footnotes on this page.
+     * Set when a footnote is placed but then found to be not-allowed (anchor
+     * not reachable in multi-column). Each retry halves this value until
+     * the footnote fits or is too small to display. (Issue #1879)
+     */
+    footnoteMaxBlockSize: number | null;
+    /**
+     * When true, max-height on @footnote areas should be ignored.
+     * Set when a page contains only footnote continuation(s) and no body
+     * content. Per CSS GCPM §2.4.2, max-height should not apply in this
+     * case. (Issue #1878)
+     */
+    ignoreFootnoteAreaMaxHeight: boolean;
+    /**
+     * Tracks footnote IDs whose anchors have been registered at least once
+     * during this page's layout cycle. Unlike floatAnchors, this set
+     * survives invalidate() calls, so we can detect feedback loops where
+     * a footnote's own size pushes its anchor off the page. (Issue #1879)
+     */
+    private footnoteAnchorsSeen;
+    /**
+     * 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;
@@ -105,15 +159,22 @@ export declare class PageFloatLayoutContext implements PageFloats.PageFloatLayou
     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[];
+    private hasRootMultiColumnFootnoteContext;
+    private hasNonRootMultiColumnFootnoteContext;
+    private hasMultiColumnFootnoteContext;
+    private trySetFootnoteRetryMaxBlockSize;
+    initFootnoteRetryFromEmptyFragment(float: PageFloat, area: LayoutType.PageFloatArea): boolean;
     checkAndForbidNotAllowedFloat(): boolean;
     checkAndForbidFloatFollowingDeferredFloat(): boolean;
     finish(): void;
@@ -144,7 +205,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 +236,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/repetitive-element.d.ts

@@ -160,3 +160,10 @@ export declare class RepetitiveElementsOwnerLayoutProcessor extends LayoutProces
 export declare function appendHeaderToAncestors(nodeContext: Vtree.NodeContext, column: LayoutType.Column): void;
 export declare function appendHeader(formattingContext: RepetitiveElement.RepetitiveElementsOwnerFormattingContext, nodeContext: Vtree.NodeContext, column: LayoutType.Column): Task.Result<boolean>;
 export declare function appendFooter(formattingContext: RepetitiveElement.RepetitiveElementsOwnerFormattingContext, nodeContext: Vtree.NodeContext, column: LayoutType.Column): Task.Result<boolean>;
+/**
+ * Check whether an overflow is within the scope of the repetitive elements
+ * owner. Returns true if the overflow should trigger header/footer skipping
+ * (i.e., the overflowing node is inside the owner), false otherwise.
+ * (Issue #1873)
+ */
+export declare function isOverflowInsideRepetitiveElementsOwner(nodeContext: Vtree.NodeContext, overflownNodeContext: Vtree.NodeContext, repetitiveElements: RepetitiveElement.RepetitiveElements): boolean;