@vivliostyle/core 2.39.1 → 2.41.0

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

@@ -1,3 +1,4 @@
+import * as CmykStore from "./cmyk-store";
 import * as CounterStyle from "./counter-style";
 import * as Css from "./css";
 import * as CssParser from "./css-parser";
@@ -277,7 +278,8 @@ export declare class CheckNSTagAction extends ChainedAction {
 export declare class CheckTargetEpubTypeAction extends ChainedAction {
     readonly epubTypePatt: RegExp;
     readonly targetLocalName?: string;
-    constructor(epubTypePatt: RegExp, targetLocalName?: string);
+    readonly useRoleAttr: boolean;
+    constructor(epubTypePatt: RegExp, targetLocalName?: string, useRoleAttr?: boolean);
     apply(cascadeInstance: CascadeInstance): void;
 }
 export declare class CheckNamespaceAction extends ChainedAction {
@@ -612,9 +614,20 @@ export declare class ContentPropVisitor extends Css.FilterVisitor {
     cascade: CascadeInstance;
     element: Element;
     readonly counterResolver: CounterResolver;
-    constructor(cascade: CascadeInstance, element: Element, counterResolver: CounterResolver);
+    private readonly pseudoName?;
+    constructor(cascade: CascadeInstance, element: Element, counterResolver: CounterResolver, pseudoName?: string);
+    private getCounterStore;
+    private getPageScope;
+    /**
+     * Helper method to evaluate CSS values containing counter() and other functions,
+     * then convert to string.
+     */
+    private evaluateAndGetString;
     visitIdent(ident: Css.Ident): Css.Val;
     private format;
+    private formatCounterList;
+    private formatLastValue;
+    private buildCounterText;
     visitFuncCounter(values: Css.Val[]): Css.Val;
     visitFuncCounters(values: Css.Val[]): Css.Val;
     visitFuncTargetCounter(values: Css.Val[]): Css.Val;
@@ -670,7 +683,7 @@ export declare class Cascade {
     order: number;
     clone(): Cascade;
     insertInTable(table: ActionTable, key: string, action: CascadeAction): void;
-    createInstance(context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: any, counterStyleStore: CounterStyle.CounterStyleStore): CascadeInstance;
+    createInstance(context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: any, counterStyleStore: CounterStyle.CounterStyleStore, cmykStore: CmykStore.CmykStore): CascadeInstance;
     nextOrder(): number;
 }
 export declare class CascadeInstance {
@@ -678,6 +691,7 @@ export declare class CascadeInstance {
     readonly counterListener: CounterListener;
     readonly counterResolver: CounterResolver;
     readonly counterStyleStore: CounterStyle.CounterStyleStore;
+    readonly cmykStore: CmykStore.CmykStore;
     code: Cascade;
     stack: ConditionItem[][];
     conditions: {
@@ -696,12 +710,16 @@ export declare class CascadeInstance {
     currentPageType: string | null;
     previousPageType: string | null;
     firstPageType: string | null;
-    pageTypePageCounts: {
-        [pageType: string]: number;
+    pageTypePageIndices: {
+        [pageType: string]: number[];
     };
     isFirst: boolean;
     isRoot: boolean;
     counters: CounterValues;
+    lastCounterChanges: string[];
+    lastCounterChangeTypes: {
+        [key: string]: "reset" | "set" | "increment";
+    };
     counterScoping: {
         [key: string]: boolean;
     }[];
@@ -737,7 +755,7 @@ export declare class CascadeInstance {
     };
     dependentConditions: string[];
     elementStack: Element[];
-    constructor(cascade: Cascade, context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: string, counterStyleStore: CounterStyle.CounterStyleStore);
+    constructor(cascade: Cascade, context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: string, counterStyleStore: CounterStyle.CounterStyleStore, cmykStore: CmykStore.CmykStore);
     pushConditionItem(item: ConditionItem): void;
     increment(condition: string, viewCondition: Matchers.Matcher): void;
     decrement(condition: string, viewCondition: Matchers.Matcher): void;
@@ -757,9 +775,29 @@ export declare class CascadeInstance {
      * https://drafts.csswg.org/css-gcpm-3/#running-elements
      */
     setRunningElement(props: ElementStyle): void;
-    processPseudoelementProps(pseudoprops: ElementStyle, element: Element): void;
+    processPseudoelementProps(pseudoprops: ElementStyle, element: Element, pseudoName?: string): void;
     pushElement(styler: CssStyler.AbstractStyler, element: Element, baseStyle: ElementStyle, elementOffset: number): void;
+    private hasNonTrivialViewConditionalPseudoContent;
+    /**
+     * Properties that are valid on ::marker and should be extracted
+     * to CSS custom properties on the parent element.
+     */
+    static readonly markerAllowedProps: string[];
+    /**
+     * Extract ::marker or ::footnote-marker properties into CSS custom
+     * properties (--viv-marker-*) on the parent element's currentStyle,
+     * so that the browser's native ::marker can be controlled via polyfill CSS.
+     *
+     * For ::marker: the content is resolved from list-style-type/list-style-image
+     * if not explicitly set.  For ::footnote-marker: the content comes from
+     * ::footnote-marker { content: ... } declarations.
+     */
     processMarkerPseudoelementProps(pseudoProps: ElementStyle, element: Element, styler: CssStyler.AbstractStyler): void;
+    /**
+     * Resolve Css.Expr nodes in marker content to static values.
+     * counter() functions are evaluated to strings; URLs are kept as-is.
+     */
+    private resolveMarkerContentVal;
     /**
      * Get inherited property value
      * @param propName
@@ -768,6 +806,7 @@ export declare class CascadeInstance {
      * @returns the inherited property value, or the initial value (or null) if not found
      */
     getInheritedPropertyValue(propName: string, styler: CssStyler.AbstractStyler, element: Element): Css.Val | null;
+    resolvePseudoelementInheritedPropertyValue(pseudoProps: ElementStyle, propName: string, styler: CssStyler.AbstractStyler, element: Element): Css.Val | null;
     private applyAttrFilterInner;
     private applyAttrFilter;
     /**
@@ -778,6 +817,8 @@ export declare class CascadeInstance {
      * Calculate all calc() in property values in elementStyle
      */
     applyCalcFilter(elementStyle: ElementStyle, context: Exprs.Context): void;
+    applyCmykFilter(elementStyle: ElementStyle, element?: Element): void;
+    private applyCmykFilterInternal;
     private applyActions;
     private pop;
     popRule(): void;

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

@@ -174,6 +174,10 @@ export declare const pageRuleMasterPseudoName = "vivliostyle-page-rule-master";
  * box's name)].
  */
 export declare const marginBoxesKey: string;
+/**
+ * Key for a footnote area style map in a page style object.
+ */
+export declare const footnoteAreaKey: string;
 /**
  * Represent a page master generated for `@page` rules
  * @param style Cascaded style for `@page` rules
@@ -464,6 +468,7 @@ export declare class PageParserHandler extends CssCascade.CascadeParserHandler i
     simpleProperty(name: string, value: Css.Val, important: any): void;
     insertNonPrimary(action: CssCascade.CascadeAction): void;
     makeApplyRuleAction(specificity: number): CssCascade.ApplyRuleAction;
+    startFootnoteRule(pseudoelem: string | null): void;
     startPageMarginBoxRule(name: string): void;
 }
 /**
@@ -481,3 +486,18 @@ export declare class PageMarginBoxParserHandler extends CssParser.SlaveParserHan
     /** @override */
     simpleProperty(name: string, value: Css.Val, important: any): void;
 }
+/**
+ * Parser handler for a footnote area rule.
+ */
+export declare class PageFootnoteAreaParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
+    readonly validatorSet: CssValidator.ValidatorSet;
+    readonly areaStyle: CssCascade.ElementStyle;
+    constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, validatorSet: CssValidator.ValidatorSet, areaStyle: CssCascade.ElementStyle);
+    property(name: string, value: Css.Val, important: boolean): void;
+    /** @override */
+    invalidPropertyValue(name: string, value: Css.Val): void;
+    /** @override */
+    unknownProperty(name: string, value: Css.Val): void;
+    /** @override */
+    simpleProperty(name: string, value: Css.Val, important: any): void;
+}

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

@@ -1,3 +1,4 @@
+import * as CmykStore from "./cmyk-store";
 import * as CounterStyle from "./counter-style";
 import * as Css from "./css";
 import * as CssCascade from "./css-cascade";
@@ -26,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;
 }
@@ -150,6 +159,7 @@ export declare class Styler implements AbstractStyler {
     styleMap: {
         [key: string]: CssCascade.ElementStyle;
     };
+    counterSnapshots: CounterSnapshot[];
     flows: {
         [key: string]: Vtree.Flow;
     };
@@ -171,7 +181,7 @@ export declare class Styler implements AbstractStyler {
     bodyReached: boolean;
     constructor(xmldoc: XmlDoc.XMLDocHolder, cascade: CssCascade.Cascade, scope: Exprs.LexicalScope, context: Exprs.Context, primaryFlows: {
         [key: string]: boolean;
-    }, validatorSet: CssValidator.ValidatorSet, counterListener: CssCascade.CounterListener, counterResolver: CssCascade.CounterResolver, counterStyleStore: CounterStyle.CounterStyleStore);
+    }, validatorSet: CssValidator.ValidatorSet, counterListener: CssCascade.CounterListener, counterResolver: CssCascade.CounterResolver, counterStyleStore: CounterStyle.CounterStyleStore, cmykStore: CmykStore.CmykStore);
     hasProp(style: CssCascade.ElementStyle, map: CssValidator.ValueMap, name: string): boolean;
     transferPropsToRoot(srcStyle: CssCascade.ElementStyle, map: CssValidator.ValueMap): void;
     /**
@@ -182,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
      */
@@ -209,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

@@ -1,7 +1,9 @@
 import * as Base from "./base";
+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";
@@ -36,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>;
@@ -188,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;
@@ -207,9 +211,11 @@ export declare class OPFView implements Vgen.CustomRendererFactory {
     pref: Exprs.Preferences;
     clientLayout: Vgen.DefaultClientLayout;
     counterStore: Counters.CounterStore;
+    cmykStore: CmykStore.CmykStore;
     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;
@@ -218,10 +224,40 @@ 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
+     * spine item. This prevents corrupting the page counter state when navigating
+     * to a later spine item while rendering is in progress.
+     * (Fix for issue #1616)
+     * @param spineIndex The target spine index to navigate to
+     * @param sync If true, skip waiting (synchronous mode)
+     */
+    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
@@ -295,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

@@ -22,6 +22,7 @@
 import "./footnotes";
 import "./table";
 import * as Base from "./base";
+import * as CmykStore from "./cmyk-store";
 import * as Constants from "./constants";
 import * as Counters from "./counters";
 import * as CounterStyle from "./counter-style";
@@ -91,6 +92,7 @@ export declare class StyleInstance extends Exprs.Context implements CssStyler.Fl
     readonly pageNumberOffset: number;
     readonly documentURLTransformer: Base.DocumentURLTransformer;
     readonly counterStore: Counters.CounterStore;
+    readonly cmykStore: CmykStore.CmykStore;
     lang: string | null;
     primaryFlows: {
         [key: string]: boolean;
@@ -102,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: {
@@ -123,9 +126,15 @@ 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, pageProgression?: Constants.PageProgression, isVersoFirstPage?: boolean);
+    }, pageNumberOffset: number, documentURLTransformer: Base.DocumentURLTransformer, counterStore: Counters.CounterStore, cmykStore: CmykStore.CmykStore, pageProgression?: Constants.PageProgression, isVersoFirstPage?: boolean);
     init(): Task.Result<boolean>;
     private matchStartPageSide;
     /** @override */
@@ -143,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
@@ -157,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;
     /**