declare namespace Base {
    let emptyObj: {};
    type JSON = any;
    function jsonToString(json: JSON): string;
    function stringToJSON(str: string): JSON;
    function stripFragment(url: string): string;
    function stripFragmentAndQuery(url: string): string;
    let baseURL: string;
    function setBaseURL(value: string): void;
    let resourceBaseURL: string;
    function setResourceBaseURL(value: string): void;
    function resolveURL(relURL: string, baseURL: string): string;
    function convertSpecialURL(url: string): string;
    interface DocumentURLTransformer {
        transformFragment(fragment: string, baseURL: string): string;
        transformURL(url: string, baseURL: string): string;
        restoreURL(encoded: string): string[];
    }
    enum NS {
        FB2 = "http://www.gribuser.ru/xml/fictionbook/2.0",
        epub = "http://www.idpf.org/2007/ops",
        EV = "http://www.w3.org/2001/xml-events",
        MATHML = "http://www.w3.org/1998/Math/MathML",
        XML = "http://www.w3.org/XML/1998/namespace",
        XHTML = "http://www.w3.org/1999/xhtml",
        XLINK = "http://www.w3.org/1999/xlink",
        SHADOW = "http://www.pyroxy.com/ns/shadow",
        SVG = "http://www.w3.org/2000/svg",
        DC = "http://purl.org/dc/elements/1.1/",
        NCX = "http://www.daisy.org/z3986/2005/ncx/",
        SSE = "http://example.com/sse"
    }
    function getURLParam(name: string, opt_url?: string): string | null;
    function setURLParam(url: string, name: string, value: string): string;
    function asString(v: any): any;
    interface Comparable {
        compare(other: Comparable): number;
    }
    class PriorityQueue {
        queue: Comparable[];
        length(): number;
        add(item: Comparable): void;
        peek(): Comparable;
        remove(): Comparable;
    }
    function cssToJSProp(prefix: string, cssPropName: string): string;
    const knownPrefixes: string[];
    const propNameMap: {};
    function checkIfPropertySupported(prefix: string, prop: string): boolean;
    function getPrefixedPropertyNames(prop: string): string[] | null;
    function setCSSProperty(elem: Element, prop: string, value: string): void;
    function getCSSProperty(elem: Element, prop: string, opt_value?: string): string;
    function getLangAttribute(element: Element): string;
    class StringBuffer {
        list: string[];
        append(str: string): StringBuffer;
        clear(): void;
        toString(): string;
    }
    function escapeChar(str: string): string;
    function escapeCSSIdent(name: string): string;
    function escapeCSSStr(str: string): string;
    function lightURLEncode(str: string): string;
    function isLetter(ch: string): boolean;
    function escapeCharToHex(str: string, prefix?: string): string;
    function escapeNameStrToHex(str: string, prefix?: string): string;
    function escapeRegExp(str: string): string;
    function unescapeCharFromHex(str: string, prefix?: string): string;
    function unescapeStrFromHex(str: string, prefix?: string): string;
    function binarySearch(high: number, good: (p1: number) => boolean): number;
    function numberCompare(a: number, b: number): number;
    const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    function appendBase64(sb: StringBuffer, data: string): void;
    function indexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T;
    };
    function arrayToSet(arr: string[]): {
        [key: string]: boolean;
    };
    function multiIndexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T[];
    };
    function mapObj<P, R>(obj: {
        [key: string]: P;
    }, fn: (p1: P, p2: string) => R): {
        [key: string]: R;
    };
    function mapSize(obj: object): number;
    type Event = {
        type: string;
        target?: any;
        currentTarget?: any;
        preventDefault?: any;
        newPage?: any;
        anchorElement?: any;
        href?: any;
        content?: any;
    };
    type EventListener = (p1: Event) => void;
    class SimpleEventTarget {
        listeners: {
            [key: string]: EventListener[];
        };
        dispatchEvent(evt: Event): void;
        addEventListener(type: string, listener: EventListener, capture?: boolean): void;
        removeEventListener(type: string, listener: EventListener, capture?: boolean): void;
    }
    type EventTarget = SimpleEventTarget;
    let hasLShapeFloatBug: boolean | null;
    function checkLShapeFloatBug(body: HTMLElement): boolean;
    let hasVerticalBBoxBug: boolean | null;
    function checkVerticalBBoxBug(body: HTMLElement): boolean;
    let hasInlineBlockJustificationBug: boolean | null;
    function checkInlineBlockJustificationBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityAfterHyphenBug: boolean | null;
    function checkSoftWrapOpportunityAfterHyphenBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityByWbrBug: boolean | null;
    function checkSoftWrapOpportunityByWbrBug(body: HTMLElement): boolean;
}
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace LayoutProcessor_$0 {
    interface LayoutProcessor_$0 {
        layout(nodeContext: Vtree.NodeContext, column: Layout.Column, leadingEdge: boolean): Task.Result<Vtree.NodeContext>;
        createEdgeBreakPosition(position: Vtree.NodeContext, breakOnEdge: string | null, overflows: boolean, columnBlockSize: number): Layout.BreakPosition;
        startNonInlineElementNode(nodeContext: Vtree.NodeContext): boolean;
        afterNonInlineElementNode(nodeContext: Vtree.NodeContext, stopAtOverflow: boolean): boolean;
        finishBreak(column: Layout.Column, nodeContext: Vtree.NodeContext, forceRemoveSelf: boolean, endOfColumn: boolean): Task.Result<boolean>;
        clearOverflownViewNodes(column: Layout.Column, parentNodeContext: Vtree.NodeContext, nodeContext: Vtree.NodeContext, removeSelf: boolean): any;
    }
    class LayoutProcessorResolver {
        find(formattingContext: Vtree.FormattingContext): LayoutProcessor_$0;
    }
    class BlockLayoutProcessor implements LayoutProcessor_$0 {
        layout(nodeContext: Vtree.NodeContext, column: Layout.Column, leadingEdge: boolean): Task.Result<Vtree.NodeContext>;
        createEdgeBreakPosition(position: Vtree.NodeContext, breakOnEdge: string | null, overflows: boolean, columnBlockSize: number): Layout.BreakPosition;
        startNonInlineElementNode(nodeContext: Vtree.NodeContext): boolean;
        afterNonInlineElementNode(nodeContext: Vtree.NodeContext, stopAtOverflow: boolean): boolean;
        clearOverflownViewNodes(column: Layout.Column, parentNodeContext: Vtree.NodeContext, nodeContext: Vtree.NodeContext, removeSelf: boolean): void;
        finishBreak(column: Layout.Column, nodeContext: Vtree.NodeContext, forceRemoveSelf: boolean, endOfColumn: boolean): Task.Result<boolean>;
    }
    class BlockFormattingContext_$0 implements LayoutProcessor_$0.BlockFormattingContext_$0 {
        private readonly parent;
        formattingContextType: FormattingContextType;
        constructor(parent: Vtree.FormattingContext);
        getName(): string;
        isFirstTime(nodeContext: Vtree.NodeContext, firstTime: boolean): boolean;
        getParent(): Vtree.FormattingContext;
        saveState(): any;
        restoreState(state: any): void;
    }
    const blockLayoutProcessor: BlockLayoutProcessor;
    const isInstanceOfBlockFormattingContext_$0: typeof LayoutProcessor_$0.isInstanceOfBlockFormattingContext_$0;
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
declare namespace Base {
    let emptyObj: {};
    type JSON = any;
    function jsonToString(json: JSON): string;
    function stringToJSON(str: string): JSON;
    function stripFragment(url: string): string;
    function stripFragmentAndQuery(url: string): string;
    let baseURL: string;
    function setBaseURL(value: string): void;
    let resourceBaseURL: string;
    function setResourceBaseURL(value: string): void;
    function resolveURL(relURL: string, baseURL: string): string;
    function convertSpecialURL(url: string): string;
    interface DocumentURLTransformer {
        transformFragment(fragment: string, baseURL: string): string;
        transformURL(url: string, baseURL: string): string;
        restoreURL(encoded: string): string[];
    }
    enum NS {
        FB2 = "http://www.gribuser.ru/xml/fictionbook/2.0",
        epub = "http://www.idpf.org/2007/ops",
        EV = "http://www.w3.org/2001/xml-events",
        MATHML = "http://www.w3.org/1998/Math/MathML",
        XML = "http://www.w3.org/XML/1998/namespace",
        XHTML = "http://www.w3.org/1999/xhtml",
        XLINK = "http://www.w3.org/1999/xlink",
        SHADOW = "http://www.pyroxy.com/ns/shadow",
        SVG = "http://www.w3.org/2000/svg",
        DC = "http://purl.org/dc/elements/1.1/",
        NCX = "http://www.daisy.org/z3986/2005/ncx/",
        SSE = "http://example.com/sse"
    }
    function getURLParam(name: string, opt_url?: string): string | null;
    function setURLParam(url: string, name: string, value: string): string;
    function asString(v: any): any;
    interface Comparable {
        compare(other: Comparable): number;
    }
    class PriorityQueue {
        queue: Comparable[];
        length(): number;
        add(item: Comparable): void;
        peek(): Comparable;
        remove(): Comparable;
    }
    function cssToJSProp(prefix: string, cssPropName: string): string;
    const knownPrefixes: string[];
    const propNameMap: {};
    function checkIfPropertySupported(prefix: string, prop: string): boolean;
    function getPrefixedPropertyNames(prop: string): string[] | null;
    function setCSSProperty(elem: Element, prop: string, value: string): void;
    function getCSSProperty(elem: Element, prop: string, opt_value?: string): string;
    function getLangAttribute(element: Element): string;
    class StringBuffer {
        list: string[];
        append(str: string): StringBuffer;
        clear(): void;
        toString(): string;
    }
    function escapeChar(str: string): string;
    function escapeCSSIdent(name: string): string;
    function escapeCSSStr(str: string): string;
    function lightURLEncode(str: string): string;
    function isLetter(ch: string): boolean;
    function escapeCharToHex(str: string, prefix?: string): string;
    function escapeNameStrToHex(str: string, prefix?: string): string;
    function escapeRegExp(str: string): string;
    function unescapeCharFromHex(str: string, prefix?: string): string;
    function unescapeStrFromHex(str: string, prefix?: string): string;
    function binarySearch(high: number, good: (p1: number) => boolean): number;
    function numberCompare(a: number, b: number): number;
    const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    function appendBase64(sb: StringBuffer, data: string): void;
    function indexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T;
    };
    function arrayToSet(arr: string[]): {
        [key: string]: boolean;
    };
    function multiIndexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T[];
    };
    function mapObj<P, R>(obj: {
        [key: string]: P;
    }, fn: (p1: P, p2: string) => R): {
        [key: string]: R;
    };
    function mapSize(obj: object): number;
    type Event = {
        type: string;
        target?: any;
        currentTarget?: any;
        preventDefault?: any;
        newPage?: any;
        anchorElement?: any;
        href?: any;
        content?: any;
    };
    type EventListener = (p1: Event) => void;
    class SimpleEventTarget {
        listeners: {
            [key: string]: EventListener[];
        };
        dispatchEvent(evt: Event): void;
        addEventListener(type: string, listener: EventListener, capture?: boolean): void;
        removeEventListener(type: string, listener: EventListener, capture?: boolean): void;
    }
    type EventTarget = SimpleEventTarget;
    let hasLShapeFloatBug: boolean | null;
    function checkLShapeFloatBug(body: HTMLElement): boolean;
    let hasVerticalBBoxBug: boolean | null;
    function checkVerticalBBoxBug(body: HTMLElement): boolean;
    let hasInlineBlockJustificationBug: boolean | null;
    function checkInlineBlockJustificationBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityAfterHyphenBug: boolean | null;
    function checkSoftWrapOpportunityAfterHyphenBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityByWbrBug: boolean | null;
    function checkSoftWrapOpportunityByWbrBug(body: HTMLElement): boolean;
}
declare namespace Base {
    let emptyObj: {};
    type JSON = any;
    function jsonToString(json: JSON): string;
    function stringToJSON(str: string): JSON;
    function stripFragment(url: string): string;
    function stripFragmentAndQuery(url: string): string;
    let baseURL: string;
    function setBaseURL(value: string): void;
    let resourceBaseURL: string;
    function setResourceBaseURL(value: string): void;
    function resolveURL(relURL: string, baseURL: string): string;
    function convertSpecialURL(url: string): string;
    interface DocumentURLTransformer {
        transformFragment(fragment: string, baseURL: string): string;
        transformURL(url: string, baseURL: string): string;
        restoreURL(encoded: string): string[];
    }
    enum NS {
        FB2 = "http://www.gribuser.ru/xml/fictionbook/2.0",
        epub = "http://www.idpf.org/2007/ops",
        EV = "http://www.w3.org/2001/xml-events",
        MATHML = "http://www.w3.org/1998/Math/MathML",
        XML = "http://www.w3.org/XML/1998/namespace",
        XHTML = "http://www.w3.org/1999/xhtml",
        XLINK = "http://www.w3.org/1999/xlink",
        SHADOW = "http://www.pyroxy.com/ns/shadow",
        SVG = "http://www.w3.org/2000/svg",
        DC = "http://purl.org/dc/elements/1.1/",
        NCX = "http://www.daisy.org/z3986/2005/ncx/",
        SSE = "http://example.com/sse"
    }
    function getURLParam(name: string, opt_url?: string): string | null;
    function setURLParam(url: string, name: string, value: string): string;
    function asString(v: any): any;
    interface Comparable {
        compare(other: Comparable): number;
    }
    class PriorityQueue {
        queue: Comparable[];
        length(): number;
        add(item: Comparable): void;
        peek(): Comparable;
        remove(): Comparable;
    }
    function cssToJSProp(prefix: string, cssPropName: string): string;
    const knownPrefixes: string[];
    const propNameMap: {};
    function checkIfPropertySupported(prefix: string, prop: string): boolean;
    function getPrefixedPropertyNames(prop: string): string[] | null;
    function setCSSProperty(elem: Element, prop: string, value: string): void;
    function getCSSProperty(elem: Element, prop: string, opt_value?: string): string;
    function getLangAttribute(element: Element): string;
    class StringBuffer {
        list: string[];
        append(str: string): StringBuffer;
        clear(): void;
        toString(): string;
    }
    function escapeChar(str: string): string;
    function escapeCSSIdent(name: string): string;
    function escapeCSSStr(str: string): string;
    function lightURLEncode(str: string): string;
    function isLetter(ch: string): boolean;
    function escapeCharToHex(str: string, prefix?: string): string;
    function escapeNameStrToHex(str: string, prefix?: string): string;
    function escapeRegExp(str: string): string;
    function unescapeCharFromHex(str: string, prefix?: string): string;
    function unescapeStrFromHex(str: string, prefix?: string): string;
    function binarySearch(high: number, good: (p1: number) => boolean): number;
    function numberCompare(a: number, b: number): number;
    const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    function appendBase64(sb: StringBuffer, data: string): void;
    function indexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T;
    };
    function arrayToSet(arr: string[]): {
        [key: string]: boolean;
    };
    function multiIndexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T[];
    };
    function mapObj<P, R>(obj: {
        [key: string]: P;
    }, fn: (p1: P, p2: string) => R): {
        [key: string]: R;
    };
    function mapSize(obj: object): number;
    type Event = {
        type: string;
        target?: any;
        currentTarget?: any;
        preventDefault?: any;
        newPage?: any;
        anchorElement?: any;
        href?: any;
        content?: any;
    };
    type EventListener = (p1: Event) => void;
    class SimpleEventTarget {
        listeners: {
            [key: string]: EventListener[];
        };
        dispatchEvent(evt: Event): void;
        addEventListener(type: string, listener: EventListener, capture?: boolean): void;
        removeEventListener(type: string, listener: EventListener, capture?: boolean): void;
    }
    type EventTarget = SimpleEventTarget;
    let hasLShapeFloatBug: boolean | null;
    function checkLShapeFloatBug(body: HTMLElement): boolean;
    let hasVerticalBBoxBug: boolean | null;
    function checkVerticalBBoxBug(body: HTMLElement): boolean;
    let hasInlineBlockJustificationBug: boolean | null;
    function checkInlineBlockJustificationBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityAfterHyphenBug: boolean | null;
    function checkSoftWrapOpportunityAfterHyphenBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityByWbrBug: boolean | null;
    function checkSoftWrapOpportunityByWbrBug(body: HTMLElement): boolean;
}
declare namespace Base {
    let emptyObj: {};
    type JSON = any;
    function jsonToString(json: JSON): string;
    function stringToJSON(str: string): JSON;
    function stripFragment(url: string): string;
    function stripFragmentAndQuery(url: string): string;
    let baseURL: string;
    function setBaseURL(value: string): void;
    let resourceBaseURL: string;
    function setResourceBaseURL(value: string): void;
    function resolveURL(relURL: string, baseURL: string): string;
    function convertSpecialURL(url: string): string;
    interface DocumentURLTransformer {
        transformFragment(fragment: string, baseURL: string): string;
        transformURL(url: string, baseURL: string): string;
        restoreURL(encoded: string): string[];
    }
    enum NS {
        FB2 = "http://www.gribuser.ru/xml/fictionbook/2.0",
        epub = "http://www.idpf.org/2007/ops",
        EV = "http://www.w3.org/2001/xml-events",
        MATHML = "http://www.w3.org/1998/Math/MathML",
        XML = "http://www.w3.org/XML/1998/namespace",
        XHTML = "http://www.w3.org/1999/xhtml",
        XLINK = "http://www.w3.org/1999/xlink",
        SHADOW = "http://www.pyroxy.com/ns/shadow",
        SVG = "http://www.w3.org/2000/svg",
        DC = "http://purl.org/dc/elements/1.1/",
        NCX = "http://www.daisy.org/z3986/2005/ncx/",
        SSE = "http://example.com/sse"
    }
    function getURLParam(name: string, opt_url?: string): string | null;
    function setURLParam(url: string, name: string, value: string): string;
    function asString(v: any): any;
    interface Comparable {
        compare(other: Comparable): number;
    }
    class PriorityQueue {
        queue: Comparable[];
        length(): number;
        add(item: Comparable): void;
        peek(): Comparable;
        remove(): Comparable;
    }
    function cssToJSProp(prefix: string, cssPropName: string): string;
    const knownPrefixes: string[];
    const propNameMap: {};
    function checkIfPropertySupported(prefix: string, prop: string): boolean;
    function getPrefixedPropertyNames(prop: string): string[] | null;
    function setCSSProperty(elem: Element, prop: string, value: string): void;
    function getCSSProperty(elem: Element, prop: string, opt_value?: string): string;
    function getLangAttribute(element: Element): string;
    class StringBuffer {
        list: string[];
        append(str: string): StringBuffer;
        clear(): void;
        toString(): string;
    }
    function escapeChar(str: string): string;
    function escapeCSSIdent(name: string): string;
    function escapeCSSStr(str: string): string;
    function lightURLEncode(str: string): string;
    function isLetter(ch: string): boolean;
    function escapeCharToHex(str: string, prefix?: string): string;
    function escapeNameStrToHex(str: string, prefix?: string): string;
    function escapeRegExp(str: string): string;
    function unescapeCharFromHex(str: string, prefix?: string): string;
    function unescapeStrFromHex(str: string, prefix?: string): string;
    function binarySearch(high: number, good: (p1: number) => boolean): number;
    function numberCompare(a: number, b: number): number;
    const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    function appendBase64(sb: StringBuffer, data: string): void;
    function indexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T;
    };
    function arrayToSet(arr: string[]): {
        [key: string]: boolean;
    };
    function multiIndexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T[];
    };
    function mapObj<P, R>(obj: {
        [key: string]: P;
    }, fn: (p1: P, p2: string) => R): {
        [key: string]: R;
    };
    function mapSize(obj: object): number;
    type Event = {
        type: string;
        target?: any;
        currentTarget?: any;
        preventDefault?: any;
        newPage?: any;
        anchorElement?: any;
        href?: any;
        content?: any;
    };
    type EventListener = (p1: Event) => void;
    class SimpleEventTarget {
        listeners: {
            [key: string]: EventListener[];
        };
        dispatchEvent(evt: Event): void;
        addEventListener(type: string, listener: EventListener, capture?: boolean): void;
        removeEventListener(type: string, listener: EventListener, capture?: boolean): void;
    }
    type EventTarget = SimpleEventTarget;
    let hasLShapeFloatBug: boolean | null;
    function checkLShapeFloatBug(body: HTMLElement): boolean;
    let hasVerticalBBoxBug: boolean | null;
    function checkVerticalBBoxBug(body: HTMLElement): boolean;
    let hasInlineBlockJustificationBug: boolean | null;
    function checkInlineBlockJustificationBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityAfterHyphenBug: boolean | null;
    function checkSoftWrapOpportunityAfterHyphenBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityByWbrBug: boolean | null;
    function checkSoftWrapOpportunityByWbrBug(body: HTMLElement): boolean;
}
declare namespace Exprs {
    type Preferences = {
        fontFamily: string;
        lineHeight: number;
        margin: number;
        hyphenate: boolean;
        columnWidth: number;
        horizontal: boolean;
        nightMode: boolean;
        spreadView: boolean;
        pageBorder: number;
        enabledMediaTypes: {
            [key: string]: boolean;
        };
        defaultPaperSize?: {
            [key: string]: number;
        };
    };
    function defaultPreferences(): Preferences;
    function clonePreferences(pref: Preferences): Preferences;
    const defaultPreferencesInstance: Preferences;
    const Special: {
        PENDING: Pending;
    };
    type Result = string | number | boolean | undefined;
    type PendingResult = Special | Result;
    function letterbox(viewW: number, viewH: number, objW: number, objH: number): string;
    function cssString(str: string): string;
    function cssIdent(name: string): string;
    function makeQualifiedName(objName: string | null, memberName: string): string;
    let nextKeyIndex: number;
    class LexicalScope {
        parent: LexicalScope;
        resolver?: (p1: string, p2: boolean) => Val;
        scopeKey: string;
        children: LexicalScope[];
        zero: Const;
        one: Const;
        _true: Const;
        _false: Const;
        values: {
            [key: string]: Val;
        };
        funcs: {
            [key: string]: Val;
        };
        builtIns: {
            [key: string]: (...p1: Result[]) => Result;
        };
        constructor(parent: LexicalScope, resolver?: (p1: string, p2: boolean) => Val);
        defineBuiltInName(name: string, fn: () => Result): void;
        defineName(qualifiedName: string, val: Val): void;
        defineFunc(qualifiedName: string, val: Val): void;
        defineBuiltIn(qualifiedName: string, fn: (...p1: Result[]) => Result): void;
    }
    function isAbsoluteLengthUnit(unit: string): boolean;
    function isViewportRelativeLengthUnit(unit: string): boolean;
    function isFontRelativeLengthUnit(unit: string): boolean;
    const defaultUnitSizes: {
        [key: string]: number;
    };
    function needUnitConversion(unit: string): boolean;
    type ScopeContext = {
        [key: string]: Result;
    };
    class Context {
        readonly rootScope: LexicalScope;
        readonly viewportWidth: number;
        readonly viewportHeight: number;
        protected actualPageWidth: number | null;
        pageWidth: () => number;
        protected actualPageHeight: number | null;
        pageHeight: () => number;
        initialFontSize: number;
        rootFontSize: number | null;
        fontSize: () => number;
        pref: Preferences;
        scopes: {
            [key: string]: ScopeContext;
        };
        pageAreaWidth: number | null;
        pageAreaHeight: number | null;
        pageVertical: boolean | null;
        pubTitle: string | null;
        docTitle: string | null;
        constructor(rootScope: LexicalScope, viewportWidth: number, viewportHeight: number, fontSize: number);
        private getScopeContext;
        clearScope(scope: LexicalScope): void;
        queryUnitSize(unit: string, isRoot: boolean): number;
        evalName(scope: LexicalScope, qualifiedName: string): Val;
        evalCall(scope: LexicalScope, qualifiedName: string, params: Val[], noBuiltInEval: boolean): Val;
        evalMediaName(name: string, not: boolean): boolean;
        evalMediaTest(feature: string, value: Val): boolean;
        queryVal(scope: LexicalScope, key: string): Result | undefined;
        storeVal(scope: LexicalScope, key: string, val: Result): void;
    }
    type DependencyCache = {
        [key: string]: boolean | Special;
    };
    class Val {
        scope: LexicalScope;
        key: string;
        constructor(scope: LexicalScope);
        toString(): string;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        expand(context: Context, params: Val[]): Val;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        dependOuter(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        depend(other: Val, context: Context): boolean;
        evaluate(context: Context): Result;
        isMediaName(): boolean;
    }
    class Prefix extends Val {
        val: Val;
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Infix extends Val {
        lhs: Val;
        rhs: Val;
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Logical extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Comparison extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Additive extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Multiplicative extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Not extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class Negate extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class And extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class AndMedia extends And {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Or extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class OrMedia extends Or {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Lt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Le extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Gt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ge extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Eq extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ne extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Add extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Subtract extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Multiply extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Divide extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Modulo extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Numeric extends Val {
        num: number;
        unit: string;
        constructor(scope: LexicalScope, num: number, unit: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class Named extends Val {
        qualifiedName: string;
        constructor(scope: LexicalScope, qualifiedName: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    }
    class MediaName extends Val {
        not: boolean;
        name: string;
        value: Val;
        constructor(scope: LexicalScope, not: boolean, name: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        isMediaName(): boolean;
    }
    class Native extends Val {
        fn: () => Result;
        str: string;
        constructor(scope: LexicalScope, fn: () => Result, str: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    function appendValArray(buf: Base.StringBuffer, arr: Val[]): void;
    function expandValArray(context: Context, arr: Val[], params: Val[]): Val[];
    function evalValArray(context: Context, arr: Val[]): Result[];
    class Call extends Val {
        qualifiedName: string;
        params: Val[];
        constructor(scope: LexicalScope, qualifiedName: string, params: Val[]);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Cond extends Val {
        cond: Val;
        ifTrue: Val;
        ifFalse: Val;
        constructor(scope: LexicalScope, cond: Val, ifTrue: Val, ifFalse: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Const extends Val {
        val: Result;
        constructor(scope: LexicalScope, val: Result);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class MediaTest extends Val {
        name: MediaName;
        value: Val;
        constructor(scope: LexicalScope, name: MediaName, value: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Param extends Val {
        index: number;
        constructor(scope: LexicalScope, index: number);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    function and(scope: LexicalScope, v1: Val, v2: Val): Val;
    function add(scope: LexicalScope, v1: Val, v2: Val): Val;
    function sub(scope: LexicalScope, v1: Val, v2: Val): Val;
    function mul(scope: LexicalScope, v1: Val, v2: Val): Val;
    function div(scope: LexicalScope, v1: Val, v2: Val): Val;
}
declare namespace Base {
    let emptyObj: {};
    type JSON = any;
    function jsonToString(json: JSON): string;
    function stringToJSON(str: string): JSON;
    function stripFragment(url: string): string;
    function stripFragmentAndQuery(url: string): string;
    let baseURL: string;
    function setBaseURL(value: string): void;
    let resourceBaseURL: string;
    function setResourceBaseURL(value: string): void;
    function resolveURL(relURL: string, baseURL: string): string;
    function convertSpecialURL(url: string): string;
    interface DocumentURLTransformer {
        transformFragment(fragment: string, baseURL: string): string;
        transformURL(url: string, baseURL: string): string;
        restoreURL(encoded: string): string[];
    }
    enum NS {
        FB2 = "http://www.gribuser.ru/xml/fictionbook/2.0",
        epub = "http://www.idpf.org/2007/ops",
        EV = "http://www.w3.org/2001/xml-events",
        MATHML = "http://www.w3.org/1998/Math/MathML",
        XML = "http://www.w3.org/XML/1998/namespace",
        XHTML = "http://www.w3.org/1999/xhtml",
        XLINK = "http://www.w3.org/1999/xlink",
        SHADOW = "http://www.pyroxy.com/ns/shadow",
        SVG = "http://www.w3.org/2000/svg",
        DC = "http://purl.org/dc/elements/1.1/",
        NCX = "http://www.daisy.org/z3986/2005/ncx/",
        SSE = "http://example.com/sse"
    }
    function getURLParam(name: string, opt_url?: string): string | null;
    function setURLParam(url: string, name: string, value: string): string;
    function asString(v: any): any;
    interface Comparable {
        compare(other: Comparable): number;
    }
    class PriorityQueue {
        queue: Comparable[];
        length(): number;
        add(item: Comparable): void;
        peek(): Comparable;
        remove(): Comparable;
    }
    function cssToJSProp(prefix: string, cssPropName: string): string;
    const knownPrefixes: string[];
    const propNameMap: {};
    function checkIfPropertySupported(prefix: string, prop: string): boolean;
    function getPrefixedPropertyNames(prop: string): string[] | null;
    function setCSSProperty(elem: Element, prop: string, value: string): void;
    function getCSSProperty(elem: Element, prop: string, opt_value?: string): string;
    function getLangAttribute(element: Element): string;
    class StringBuffer {
        list: string[];
        append(str: string): StringBuffer;
        clear(): void;
        toString(): string;
    }
    function escapeChar(str: string): string;
    function escapeCSSIdent(name: string): string;
    function escapeCSSStr(str: string): string;
    function lightURLEncode(str: string): string;
    function isLetter(ch: string): boolean;
    function escapeCharToHex(str: string, prefix?: string): string;
    function escapeNameStrToHex(str: string, prefix?: string): string;
    function escapeRegExp(str: string): string;
    function unescapeCharFromHex(str: string, prefix?: string): string;
    function unescapeStrFromHex(str: string, prefix?: string): string;
    function binarySearch(high: number, good: (p1: number) => boolean): number;
    function numberCompare(a: number, b: number): number;
    const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    function appendBase64(sb: StringBuffer, data: string): void;
    function indexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T;
    };
    function arrayToSet(arr: string[]): {
        [key: string]: boolean;
    };
    function multiIndexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T[];
    };
    function mapObj<P, R>(obj: {
        [key: string]: P;
    }, fn: (p1: P, p2: string) => R): {
        [key: string]: R;
    };
    function mapSize(obj: object): number;
    type Event = {
        type: string;
        target?: any;
        currentTarget?: any;
        preventDefault?: any;
        newPage?: any;
        anchorElement?: any;
        href?: any;
        content?: any;
    };
    type EventListener = (p1: Event) => void;
    class SimpleEventTarget {
        listeners: {
            [key: string]: EventListener[];
        };
        dispatchEvent(evt: Event): void;
        addEventListener(type: string, listener: EventListener, capture?: boolean): void;
        removeEventListener(type: string, listener: EventListener, capture?: boolean): void;
    }
    type EventTarget = SimpleEventTarget;
    let hasLShapeFloatBug: boolean | null;
    function checkLShapeFloatBug(body: HTMLElement): boolean;
    let hasVerticalBBoxBug: boolean | null;
    function checkVerticalBBoxBug(body: HTMLElement): boolean;
    let hasInlineBlockJustificationBug: boolean | null;
    function checkInlineBlockJustificationBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityAfterHyphenBug: boolean | null;
    function checkSoftWrapOpportunityAfterHyphenBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityByWbrBug: boolean | null;
    function checkSoftWrapOpportunityByWbrBug(body: HTMLElement): boolean;
}
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace Exprs {
    type Preferences = {
        fontFamily: string;
        lineHeight: number;
        margin: number;
        hyphenate: boolean;
        columnWidth: number;
        horizontal: boolean;
        nightMode: boolean;
        spreadView: boolean;
        pageBorder: number;
        enabledMediaTypes: {
            [key: string]: boolean;
        };
        defaultPaperSize?: {
            [key: string]: number;
        };
    };
    function defaultPreferences(): Preferences;
    function clonePreferences(pref: Preferences): Preferences;
    const defaultPreferencesInstance: Preferences;
    const Special: {
        PENDING: Pending;
    };
    type Result = string | number | boolean | undefined;
    type PendingResult = Special | Result;
    function letterbox(viewW: number, viewH: number, objW: number, objH: number): string;
    function cssString(str: string): string;
    function cssIdent(name: string): string;
    function makeQualifiedName(objName: string | null, memberName: string): string;
    let nextKeyIndex: number;
    class LexicalScope {
        parent: LexicalScope;
        resolver?: (p1: string, p2: boolean) => Val;
        scopeKey: string;
        children: LexicalScope[];
        zero: Const;
        one: Const;
        _true: Const;
        _false: Const;
        values: {
            [key: string]: Val;
        };
        funcs: {
            [key: string]: Val;
        };
        builtIns: {
            [key: string]: (...p1: Result[]) => Result;
        };
        constructor(parent: LexicalScope, resolver?: (p1: string, p2: boolean) => Val);
        defineBuiltInName(name: string, fn: () => Result): void;
        defineName(qualifiedName: string, val: Val): void;
        defineFunc(qualifiedName: string, val: Val): void;
        defineBuiltIn(qualifiedName: string, fn: (...p1: Result[]) => Result): void;
    }
    function isAbsoluteLengthUnit(unit: string): boolean;
    function isViewportRelativeLengthUnit(unit: string): boolean;
    function isFontRelativeLengthUnit(unit: string): boolean;
    const defaultUnitSizes: {
        [key: string]: number;
    };
    function needUnitConversion(unit: string): boolean;
    type ScopeContext = {
        [key: string]: Result;
    };
    class Context {
        readonly rootScope: LexicalScope;
        readonly viewportWidth: number;
        readonly viewportHeight: number;
        protected actualPageWidth: number | null;
        pageWidth: () => number;
        protected actualPageHeight: number | null;
        pageHeight: () => number;
        initialFontSize: number;
        rootFontSize: number | null;
        fontSize: () => number;
        pref: Preferences;
        scopes: {
            [key: string]: ScopeContext;
        };
        pageAreaWidth: number | null;
        pageAreaHeight: number | null;
        pageVertical: boolean | null;
        pubTitle: string | null;
        docTitle: string | null;
        constructor(rootScope: LexicalScope, viewportWidth: number, viewportHeight: number, fontSize: number);
        private getScopeContext;
        clearScope(scope: LexicalScope): void;
        queryUnitSize(unit: string, isRoot: boolean): number;
        evalName(scope: LexicalScope, qualifiedName: string): Val;
        evalCall(scope: LexicalScope, qualifiedName: string, params: Val[], noBuiltInEval: boolean): Val;
        evalMediaName(name: string, not: boolean): boolean;
        evalMediaTest(feature: string, value: Val): boolean;
        queryVal(scope: LexicalScope, key: string): Result | undefined;
        storeVal(scope: LexicalScope, key: string, val: Result): void;
    }
    type DependencyCache = {
        [key: string]: boolean | Special;
    };
    class Val {
        scope: LexicalScope;
        key: string;
        constructor(scope: LexicalScope);
        toString(): string;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        expand(context: Context, params: Val[]): Val;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        dependOuter(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        depend(other: Val, context: Context): boolean;
        evaluate(context: Context): Result;
        isMediaName(): boolean;
    }
    class Prefix extends Val {
        val: Val;
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Infix extends Val {
        lhs: Val;
        rhs: Val;
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Logical extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Comparison extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Additive extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Multiplicative extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Not extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class Negate extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class And extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class AndMedia extends And {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Or extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class OrMedia extends Or {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Lt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Le extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Gt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ge extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Eq extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ne extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Add extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Subtract extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Multiply extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Divide extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Modulo extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Numeric extends Val {
        num: number;
        unit: string;
        constructor(scope: LexicalScope, num: number, unit: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class Named extends Val {
        qualifiedName: string;
        constructor(scope: LexicalScope, qualifiedName: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    }
    class MediaName extends Val {
        not: boolean;
        name: string;
        value: Val;
        constructor(scope: LexicalScope, not: boolean, name: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        isMediaName(): boolean;
    }
    class Native extends Val {
        fn: () => Result;
        str: string;
        constructor(scope: LexicalScope, fn: () => Result, str: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    function appendValArray(buf: Base.StringBuffer, arr: Val[]): void;
    function expandValArray(context: Context, arr: Val[], params: Val[]): Val[];
    function evalValArray(context: Context, arr: Val[]): Result[];
    class Call extends Val {
        qualifiedName: string;
        params: Val[];
        constructor(scope: LexicalScope, qualifiedName: string, params: Val[]);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Cond extends Val {
        cond: Val;
        ifTrue: Val;
        ifFalse: Val;
        constructor(scope: LexicalScope, cond: Val, ifTrue: Val, ifFalse: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Const extends Val {
        val: Result;
        constructor(scope: LexicalScope, val: Result);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class MediaTest extends Val {
        name: MediaName;
        value: Val;
        constructor(scope: LexicalScope, name: MediaName, value: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Param extends Val {
        index: number;
        constructor(scope: LexicalScope, index: number);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    function and(scope: LexicalScope, v1: Val, v2: Val): Val;
    function add(scope: LexicalScope, v1: Val, v2: Val): Val;
    function sub(scope: LexicalScope, v1: Val, v2: Val): Val;
    function mul(scope: LexicalScope, v1: Val, v2: Val): Val;
    function div(scope: LexicalScope, v1: Val, v2: Val): Val;
}
declare namespace GeometryUtil {
    class Rect {
        x1: number;
        y1: number;
        x2: number;
        y2: number;
        constructor(x1: number, y1: number, x2: number, y2: number);
    }
    class Point {
        x: number;
        y: number;
        constructor(x: number, y: number);
    }
    class Insets {
        left: number;
        top: number;
        right: number;
        bottom: number;
        constructor(left: number, top: number, right: number, bottom: number);
    }
    class Segment {
        low: Point;
        high: Point;
        winding: number;
        shapeId: number;
        constructor(low: Point, high: Point, winding: number, shapeId: number);
    }
    class Band {
        y1: number;
        y2: number;
        x1: number;
        x2: number;
        left: Element | null;
        right: Element | null;
        constructor(y1: number, y2: number, x1: number, x2: number);
    }
    function segmentCompare(s1: Segment, s2: Segment): number;
    class Shape {
        points: Point[];
        constructor(points: Point[]);
        addSegments(arr: Segment[], id: number): void;
        withOffset(offsetX: number, offsetY: number): Shape;
    }
    function shapeForEllipse(cx: number, cy: number, rx: number, ry: number): Shape;
    function shapeForRect(x1: number, y1: number, x2: number, y2: number): Shape;
    function shapeForRectObj(r: Rect): Shape;
    class BandIntersection {
        x: number;
        winding: number;
        shapeId: number;
        lowOrHigh: number;
        constructor(x: number, winding: number, shapeId: number, lowOrHigh: number);
    }
    function intersectY(s: Segment, y: number): number;
    function addBandIntersections(intersections: BandIntersection[], s: Segment, y1: number, y2: number): void;
    function mergeIntersections(intersections: BandIntersection[], includeCount: number, excludeCount: number): number[];
    function ceil(v: number, unit: number): number;
    function floor(v: number, unit: number): number;
    function rotatePoint(point: Point): Point;
    function rotateBox(box: Rect): Rect;
    function unrotateBox(box: Rect): Rect;
    function rotateShape(shape: Shape): Shape;
    function shapesToBands(box: Rect, include: Shape[], exclude: Shape[], granularity: number, snapHeight: number, vertical: boolean): Band[];
    function normalize(box: Rect, bands: Band[]): void;
    function findBand(bands: Band[], y: number): number;
    function findUppermostFullyOpenRect(bands: Band[], rect: Rect): Rect | null;
    function findBottommostFullyOpenRect(bands: Band[], rect: Rect): Rect | null;
    function positionFloat(box: Rect, bands: Band[], floatBox: Rect, side: string): boolean;
    function addFloatToBands(box: Rect, bands: Band[], floatBox: Rect, floatBands: Band[], side: string): void;
}
declare namespace Base {
    let emptyObj: {};
    type JSON = any;
    function jsonToString(json: JSON): string;
    function stringToJSON(str: string): JSON;
    function stripFragment(url: string): string;
    function stripFragmentAndQuery(url: string): string;
    let baseURL: string;
    function setBaseURL(value: string): void;
    let resourceBaseURL: string;
    function setResourceBaseURL(value: string): void;
    function resolveURL(relURL: string, baseURL: string): string;
    function convertSpecialURL(url: string): string;
    interface DocumentURLTransformer {
        transformFragment(fragment: string, baseURL: string): string;
        transformURL(url: string, baseURL: string): string;
        restoreURL(encoded: string): string[];
    }
    enum NS {
        FB2 = "http://www.gribuser.ru/xml/fictionbook/2.0",
        epub = "http://www.idpf.org/2007/ops",
        EV = "http://www.w3.org/2001/xml-events",
        MATHML = "http://www.w3.org/1998/Math/MathML",
        XML = "http://www.w3.org/XML/1998/namespace",
        XHTML = "http://www.w3.org/1999/xhtml",
        XLINK = "http://www.w3.org/1999/xlink",
        SHADOW = "http://www.pyroxy.com/ns/shadow",
        SVG = "http://www.w3.org/2000/svg",
        DC = "http://purl.org/dc/elements/1.1/",
        NCX = "http://www.daisy.org/z3986/2005/ncx/",
        SSE = "http://example.com/sse"
    }
    function getURLParam(name: string, opt_url?: string): string | null;
    function setURLParam(url: string, name: string, value: string): string;
    function asString(v: any): any;
    interface Comparable {
        compare(other: Comparable): number;
    }
    class PriorityQueue {
        queue: Comparable[];
        length(): number;
        add(item: Comparable): void;
        peek(): Comparable;
        remove(): Comparable;
    }
    function cssToJSProp(prefix: string, cssPropName: string): string;
    const knownPrefixes: string[];
    const propNameMap: {};
    function checkIfPropertySupported(prefix: string, prop: string): boolean;
    function getPrefixedPropertyNames(prop: string): string[] | null;
    function setCSSProperty(elem: Element, prop: string, value: string): void;
    function getCSSProperty(elem: Element, prop: string, opt_value?: string): string;
    function getLangAttribute(element: Element): string;
    class StringBuffer {
        list: string[];
        append(str: string): StringBuffer;
        clear(): void;
        toString(): string;
    }
    function escapeChar(str: string): string;
    function escapeCSSIdent(name: string): string;
    function escapeCSSStr(str: string): string;
    function lightURLEncode(str: string): string;
    function isLetter(ch: string): boolean;
    function escapeCharToHex(str: string, prefix?: string): string;
    function escapeNameStrToHex(str: string, prefix?: string): string;
    function escapeRegExp(str: string): string;
    function unescapeCharFromHex(str: string, prefix?: string): string;
    function unescapeStrFromHex(str: string, prefix?: string): string;
    function binarySearch(high: number, good: (p1: number) => boolean): number;
    function numberCompare(a: number, b: number): number;
    const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    function appendBase64(sb: StringBuffer, data: string): void;
    function indexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T;
    };
    function arrayToSet(arr: string[]): {
        [key: string]: boolean;
    };
    function multiIndexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T[];
    };
    function mapObj<P, R>(obj: {
        [key: string]: P;
    }, fn: (p1: P, p2: string) => R): {
        [key: string]: R;
    };
    function mapSize(obj: object): number;
    type Event = {
        type: string;
        target?: any;
        currentTarget?: any;
        preventDefault?: any;
        newPage?: any;
        anchorElement?: any;
        href?: any;
        content?: any;
    };
    type EventListener = (p1: Event) => void;
    class SimpleEventTarget {
        listeners: {
            [key: string]: EventListener[];
        };
        dispatchEvent(evt: Event): void;
        addEventListener(type: string, listener: EventListener, capture?: boolean): void;
        removeEventListener(type: string, listener: EventListener, capture?: boolean): void;
    }
    type EventTarget = SimpleEventTarget;
    let hasLShapeFloatBug: boolean | null;
    function checkLShapeFloatBug(body: HTMLElement): boolean;
    let hasVerticalBBoxBug: boolean | null;
    function checkVerticalBBoxBug(body: HTMLElement): boolean;
    let hasInlineBlockJustificationBug: boolean | null;
    function checkInlineBlockJustificationBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityAfterHyphenBug: boolean | null;
    function checkSoftWrapOpportunityAfterHyphenBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityByWbrBug: boolean | null;
    function checkSoftWrapOpportunityByWbrBug(body: HTMLElement): boolean;
}
declare namespace CssCascade_$0 {
    interface ElementStyle_$0 extends CssCascade.ElementStyle_$0 {
    }
    const inheritedProps: {
        azimuth: boolean;
        "border-collapse": boolean;
        "border-spacing": boolean;
        "caption-side": boolean;
        "clip-rule": boolean;
        color: boolean;
        "color-interpolation": boolean;
        "color-rendering": boolean;
        cursor: boolean;
        direction: boolean;
        elevation: boolean;
        "empty-cells": boolean;
        fill: boolean;
        "fill-opacity": boolean;
        "fill-rule": boolean;
        "font-kerning": boolean;
        "font-size": boolean;
        "font-size-adjust": boolean;
        "font-family": boolean;
        "font-feature-settings": boolean;
        "font-style": boolean;
        "font-stretch": boolean;
        "font-variant": boolean;
        "font-weight": boolean;
        "glyph-orientation-vertical": boolean;
        hyphens: boolean;
        "hyphenate-character": boolean;
        "hyphenate-limit-chars": boolean;
        "hyphenate-limit-last": boolean;
        "image-rendering": boolean;
        "image-resolution": boolean;
        "letter-spacing": boolean;
        "line-break": boolean;
        "line-height": boolean;
        "list-style-image": boolean;
        "list-style-position": boolean;
        "list-style-type": boolean;
        marker: boolean;
        "marker-end": boolean;
        "marker-mid": boolean;
        "marker-start": boolean;
        orphans: boolean;
        "overflow-wrap": boolean;
        "paint-order": boolean;
        "pointer-events": boolean;
        "pitch-range": boolean;
        quotes: boolean;
        richness: boolean;
        "ruby-align": boolean;
        "ruby-position": boolean;
        "speak-header": boolean;
        "speak-numeral": boolean;
        "speak-punctuation": boolean;
        "speech-rate": boolean;
        "shape-rendering": boolean;
        stress: boolean;
        stroke: boolean;
        "stroke-dasharray": boolean;
        "stroke-dashoffset": boolean;
        "stroke-linecap": boolean;
        "stroke-linejoin": boolean;
        "stroke-miterlimit": boolean;
        "stroke-opacity": boolean;
        "stroke-width": boolean;
        "tab-size": boolean;
        "text-align": boolean;
        "text-align-last": boolean;
        "text-anchor": boolean;
        "text-decoration-skip": boolean;
        "text-emphasis-color": boolean;
        "text-emphasis-position": boolean;
        "text-emphasis-style": boolean;
        "text-combine-upright": boolean;
        "text-indent": boolean;
        "text-justify": boolean;
        "text-rendering": boolean;
        "text-size-adjust": boolean;
        "text-transform": boolean;
        "text-underline-position": boolean;
        visibility: boolean;
        "voice-family": boolean;
        volume: boolean;
        "white-space": boolean;
        widows: boolean;
        "word-break": boolean;
        "word-spacing": boolean;
        "word-wrap": boolean;
        "writing-mode": boolean;
    };
    const polyfilledInheritedProps: string[];
    function getPolyfilledInheritedProps(): string[];
    const supportedNamespaces: {
        "http://www.idpf.org/2007/ops": boolean;
        "http://www.w3.org/1999/xhtml": boolean;
        "http://www.w3.org/2000/svg": boolean;
    };
    const coupledPatterns: string[];
    const coupledExtentPatterns: string[];
    const geomNames: {
        [key: string]: boolean;
    };
    function buildCouplingMap(sideMap: {
        [key: string]: string;
    }, extentMap: {
        [key: string]: string;
    }): {
        [key: string]: string;
    };
    const couplingMapVert: {
        [key: string]: string;
    };
    const couplingMapHor: {
        [key: string]: string;
    };
    const couplingMapVertRtl: {
        [key: string]: string;
    };
    const couplingMapHorRtl: {
        [key: string]: string;
    };
    class CascadeValue {
        readonly value: Css.Val;
        readonly priority: number;
        constructor(value: Css.Val, priority: number);
        getBaseValue(): CascadeValue;
        filterValue(visitor: Css.Visitor): CascadeValue;
        increaseSpecificity(specificity: number): CascadeValue;
        evaluate(context: Exprs.Context, propName: string): Css.Val;
        isEnabled(context: Exprs.Context): boolean;
    }
    class ConditionalCascadeValue extends CascadeValue {
        readonly condition: Exprs.Val;
        constructor(value: Css.Val, priority: number, condition: Exprs.Val);
        getBaseValue(): CascadeValue;
        filterValue(visitor: Css.Visitor): CascadeValue;
        increaseSpecificity(specificity: number): CascadeValue;
        isEnabled(context: Exprs.Context): boolean;
    }
    function cascadeValues(context: Exprs.Context, tv: CascadeValue, av: CascadeValue): CascadeValue;
    type ElementStyleMap = {
        [key: string]: ElementStyle_$0;
    };
    const SPECIALS: {
        "region-id": boolean;
        "fragment-selector-id": boolean;
    };
    function isSpecialName(name: string): boolean;
    function isMapName(name: string): boolean;
    function isPropName(name: string): boolean;
    function isInherited(name: string): boolean;
    function getProp(style: ElementStyle_$0, name: string): CascadeValue;
    function setProp(style: ElementStyle_$0, name: string, value: CascadeValue): any;
    function getStyleMap(style: ElementStyle_$0, name: string): ElementStyleMap;
    function getMutableStyleMap(style: ElementStyle_$0, name: string): ElementStyleMap;
    const getViewConditionalStyleMap: (style: ElementStyle_$0) => {
        matcher: Matchers.Matcher;
        styles: ElementStyleMap;
    }[];
    function getSpecial(style: ElementStyle_$0, name: string): CascadeValue[];
    function getMutableSpecial(style: ElementStyle_$0, name: string): CascadeValue[];
    function mergeIn(context: Exprs.Context, target: ElementStyle_$0, style: ElementStyle_$0, specificity: number, pseudoelement: string | null, regionId: string | null, viewConditionMatcher: Matchers.Matcher | null): void;
    function mergeAll(context: Exprs.Context, styles: ElementStyle_$0[]): ElementStyle_$0;
    function chainActions(chain: ChainedAction[], action: CascadeAction): CascadeAction;
    class InheritanceVisitor extends Css.FilterVisitor {
        readonly props: ElementStyle_$0;
        readonly context: Exprs.Context;
        propName: string;
        constructor(props: ElementStyle_$0, context: Exprs.Context);
        setPropName(name: string): void;
        private getFontSize;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function convertFontRelativeLengthToPx(numeric: Css.Numeric, baseFontSize: number, context: Exprs.Context): Css.Numeric;
    function convertFontSizeToPx(numeric: Css.Numeric, parentFontSize: number, context: Exprs.Context): Css.Numeric;
    type ActionTable = {
        [key: string]: CascadeAction;
    };
    class CascadeAction {
        apply(cascadeInstance: CascadeInstance): void;
        mergeWith(other: CascadeAction): CascadeAction;
        clone(): CascadeAction;
    }
    class ConditionItemAction extends CascadeAction {
        readonly conditionItem: ConditionItem;
        constructor(conditionItem: ConditionItem);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CompoundAction extends CascadeAction {
        readonly list: CascadeAction[];
        constructor(list: CascadeAction[]);
        apply(cascadeInstance: CascadeInstance): void;
        mergeWith(other: CascadeAction): CascadeAction;
        clone(): CascadeAction;
    }
    class ApplyRuleAction extends CascadeAction {
        readonly style: ElementStyle_$0;
        readonly specificity: number;
        readonly pseudoelement: string | null;
        readonly regionId: string | null;
        readonly viewConditionId: string | null;
        constructor(style: ElementStyle_$0, specificity: number, pseudoelement: string | null, regionId: string | null, viewConditionId: string | null);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class ChainedAction extends CascadeAction {
        chained: CascadeAction;
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckClassAction extends ChainedAction {
        readonly className: string;
        constructor(className: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckIdAction extends ChainedAction {
        readonly id: string;
        constructor(id: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckLocalNameAction extends ChainedAction {
        readonly localName: string;
        constructor(localName: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckNSTagAction extends ChainedAction {
        readonly ns: string;
        readonly localName: string;
        constructor(ns: string, localName: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckTargetEpubTypeAction extends ChainedAction {
        readonly epubTypePatt: RegExp;
        constructor(epubTypePatt: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckNamespaceAction extends ChainedAction {
        readonly ns: string;
        constructor(ns: string);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckAttributePresentAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        constructor(ns: string, name: string);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckAttributeEqAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        readonly value: string;
        constructor(ns: string, name: string, value: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckNamespaceSupportedAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        constructor(ns: string, name: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckAttributeRegExpAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        readonly regexp: RegExp;
        constructor(ns: string, name: string, regexp: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckLangAction extends ChainedAction {
        readonly langRegExp: RegExp;
        constructor(langRegExp: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class IsFirstAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsRootAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthAction extends ChainedAction {
        readonly a: number;
        readonly b: number;
        constructor(a: number, b: number);
        matchANPlusB(order: number): boolean;
    }
    class IsNthSiblingAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthSiblingOfTypeAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthLastSiblingAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthLastSiblingOfTypeAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsEmptyAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsEnabledAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsDisabledAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsCheckedAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class CheckConditionAction extends ChainedAction {
        readonly condition: string;
        constructor(condition: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class CheckAppliedAction extends CascadeAction {
        applied: boolean;
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        clone(): CascadeAction;
    }
    class NegateActionsSet extends ChainedAction {
        checkAppliedAction: CheckAppliedAction;
        firstAction: CascadeAction;
        constructor(list: ChainedAction[]);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    interface ConditionItem {
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AbstractConditionItem {
        readonly condition: string;
        readonly viewConditionId: string | null;
        readonly viewCondition: Matchers.Matcher;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        increment(cascadeInstance: CascadeInstance): void;
        decrement(cascadeInstance: CascadeInstance): void;
        buildViewConditionMatcher(cascadeInstance: CascadeInstance): Matchers.Matcher;
    }
    class DescendantConditionItem extends AbstractConditionItem implements ConditionItem {
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class ChildConditionItem extends AbstractConditionItem implements ConditionItem {
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AdjacentSiblingConditionItem extends AbstractConditionItem implements ConditionItem {
        fired: boolean;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class FollowingSiblingConditionItem extends AbstractConditionItem implements ConditionItem {
        fired: boolean;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AfterPseudoelementItem implements ConditionItem {
        readonly afterprop: ElementStyle_$0;
        readonly element: Element;
        constructor(afterprop: ElementStyle_$0, element: Element);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class RestoreLangItem implements ConditionItem {
        readonly lang: string;
        constructor(lang: string);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class QuotesScopeItem implements ConditionItem {
        readonly oldQuotes: Css.Str[];
        constructor(oldQuotes: Css.Str[]);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    type CounterValues = {
        [key: string]: number[];
    };
    interface CounterListener {
        countersOfId(id: string, counters: CounterValues): any;
        getExprContentListener(): Vtree_$0.ExprContentListener;
    }
    interface CounterResolver {
        getPageCounterVal(name: string, format: (p1: number | null) => string): Exprs.Val;
        getPageCountersVal(name: string, format: (p1: number[]) => string): Exprs.Val;
        getTargetCounterVal(url: string, name: string, format: (p1: number | null) => string): Exprs.Val;
        getTargetCountersVal(url: string, name: string, format: (p1: number[]) => string): Exprs.Val;
        setStyler(styler: any): any;
    }
    class AttrValueFilterVisitor extends Css.FilterVisitor {
        element: Element;
        constructor(element: Element);
        private createValueFromString;
        visitFunc(func: Css.Func): Css.Val;
    }
    class ContentPropVisitor extends Css.FilterVisitor {
        cascade: CascadeInstance;
        element: Element;
        readonly counterResolver: CounterResolver;
        constructor(cascade: CascadeInstance, element: Element, counterResolver: CounterResolver);
        visitIdent(ident: Css.Ident): Css.Val;
        private format;
        visitFuncCounter(values: Css.Val[]): Css.Val;
        visitFuncCounters(values: Css.Val[]): Css.Val;
        visitFuncTargetCounter(values: Css.Val[]): Css.Val;
        visitFuncTargetCounters(values: Css.Val[]): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
    }
    function roman(num: number): string;
    const additiveNumbering: {
        roman: (string | number)[];
        armenian: (string | number)[];
        georgian: (string | number)[];
        hebrew: (string | number)[];
    };
    const alphabeticNumbering: {
        latin: string;
        alpha: string;
        greek: string;
        russian: string;
    };
    const fixed: {
        square: string;
        disc: string;
        circle: string;
        none: string;
    };
    function additiveFormat(entries: any[], num: number): string;
    function expandAlphabet(str: string): string[] | null;
    function alphabeticFormat(alphabetStr: string, num: number): string;
    type ChineseNumbering = {
        digits: string;
        markers: string;
        negative: string;
        formal: boolean;
    };
    const chineseTradInformal: ChineseNumbering;
    function chineseCounter(num: number, numbering: ChineseNumbering): string;
    const ORDER_INCREMENT: number;
    function copyTable(src: ActionTable, dst: ActionTable): void;
    class Cascade {
        nsCount: number;
        nsPrefix: {
            [key: string]: string;
        };
        tags: ActionTable;
        nstags: ActionTable;
        epubtypes: ActionTable;
        classes: ActionTable;
        ids: ActionTable;
        pagetypes: ActionTable;
        order: number;
        clone(): Cascade;
        insertInTable(table: ActionTable, key: string, action: CascadeAction): void;
        createInstance(context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: any): CascadeInstance;
        nextOrder(): number;
    }
    class CascadeInstance {
        readonly context: Exprs.Context;
        readonly counterListener: CounterListener;
        readonly counterResolver: CounterResolver;
        code: Cascade;
        stack: ConditionItem[][];
        conditions: {
            [key: string]: number;
        };
        currentElement: Element | null;
        currentElementOffset: number | null;
        currentStyle: ElementStyle_$0 | null;
        currentClassNames: string[] | null;
        currentLocalName: string;
        currentNamespace: string;
        currentId: string;
        currentXmlId: string;
        currentNSTag: string;
        currentEpubTypes: string[] | null;
        currentPageType: string | null;
        isFirst: boolean;
        isRoot: boolean;
        counters: {
            [key: string]: number[];
        };
        counterScoping: {
            [key: string]: boolean;
        }[];
        quotes: Css.Str[];
        quoteDepth: number;
        lang: string;
        siblingOrderStack: number[];
        currentSiblingOrder: number;
        siblingTypeCountsStack: {
            [key: string]: {
                [key: string]: number;
            };
        }[];
        currentSiblingTypeCounts: {
            [key: string]: {
                [key: string]: number;
            };
        };
        currentFollowingSiblingOrder: number | null;
        followingSiblingOrderStack: (number | null)[];
        followingSiblingTypeCountsStack: {
            [key: string]: {
                [key: string]: number;
            };
        }[];
        currentFollowingSiblingTypeCounts: {
            [key: string]: {
                [key: string]: number;
            };
        };
        viewConditions: {
            [key: string]: Matchers.Matcher[];
        };
        dependentConditions: string[];
        elementStack: Element[];
        currentDoc?: Document | null;
        constructor(cascade: Cascade, context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: string);
        pushConditionItem(item: ConditionItem): void;
        increment(condition: string, viewCondition: Matchers.Matcher): void;
        decrement(condition: string, viewCondition: Matchers.Matcher): void;
        buildViewConditionMatcher(viewConditionId: string | null): Matchers.Matcher;
        applyAction(table: ActionTable, key: string): void;
        pushRule(classes: string[], pageType: string | null, baseStyle: ElementStyle_$0): void;
        defineCounter(counterName: string, value: number): void;
        pushCounters(props: ElementStyle_$0): void;
        popCounters(): void;
        processPseudoelementProps(pseudoprops: ElementStyle_$0, element: Element): void;
        pushElement(element: Element, baseStyle: ElementStyle_$0, elementOffset: number): void;
        private applyAttrFilterInner;
        private applyAttrFilter;
        private applyActions;
        private pop;
        popRule(): void;
        popElement(element: Element): void;
    }
    const EMPTY: any[];
    const pseudoNames: string[];
    enum ParseState {
        TOP = 0,
        SELECTOR = 1,
        RULE = 2
    }
    let uaBaseCascade: Cascade;
    function setUABaseCascade(value: Cascade): void;
    class CascadeParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
        readonly condition: Exprs.Val;
        readonly regionId: string | null;
        readonly validatorSet: CssValidator.ValidatorSet;
        chain: ChainedAction[];
        specificity: number;
        elementStyle: ElementStyle_$0;
        conditionCount: number;
        pseudoelement: string | null;
        footnoteContent: boolean;
        cascade: Cascade;
        state: ParseState;
        viewConditionId: string | null;
        insideSelectorRule: ParseState;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, condition: Exprs.Val, parent: CascadeParserHandler, regionId: string | null, validatorSet: CssValidator.ValidatorSet, topLevel: boolean);
        insertNonPrimary(action: CascadeAction): void;
        processChain(action: CascadeAction): void;
        isInsideSelectorRule(mnemonics: string): boolean;
        tagSelector(ns: string | null, name: string | null): void;
        classSelector(name: string): void;
        pseudoclassSelector(name: string, params: (number | string)[]): void;
        pseudoelementSelector(name: string, params: (number | string)[]): void;
        idSelector(id: string): void;
        attributeSelector(ns: string, name: string, op: CssTokenizer.TokenType, value: string | null): void;
        descendantSelector(): void;
        childSelector(): void;
        adjacentSiblingSelector(): void;
        followingSiblingSelector(): void;
        nextSelector(): void;
        startSelectorRule(): void;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        startStylesheet(flavor: CssParser.StylesheetFlavor): void;
        startRuleBody(): void;
        endRule(): void;
        finishChain(): void;
        makeApplyRuleAction(specificity: number): ApplyRuleAction;
        special(name: string, value: Css.Val): void;
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
        finish(): Cascade;
        startFuncWithSelector(funcName: string): void;
    }
    const nthSelectorActionClasses: {
        [key: string]: typeof IsNthAction;
    };
    let conditionCount: number;
    class NotParameterParserHandler extends CascadeParserHandler {
        readonly parent: CascadeParserHandler;
        parentChain: ChainedAction[];
        constructor(parent: CascadeParserHandler);
        startFuncWithSelector(funcName: string): void;
        startRuleBody(): void;
        nextSelector(): void;
        endFuncWithSelector(): void;
        error(mnemonics: string, token: CssTokenizer.Token): void;
    }
    class DefineParserHandler extends CssParser.SlaveParserHandler {
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler);
        property(name: string, value: Css.Val, important: boolean): void;
    }
    class PropSetParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
        readonly condition: Exprs.Val;
        readonly elementStyle: ElementStyle_$0;
        readonly validatorSet: CssValidator.ValidatorSet;
        order: number;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, condition: Exprs.Val, elementStyle: ElementStyle_$0, validatorSet: CssValidator.ValidatorSet);
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    class PropertyParserHandler extends CssParser.ErrorHandler implements CssValidator.PropertyReceiver {
        readonly validatorSet: CssValidator.ValidatorSet;
        elementStyle: ElementStyle_$0;
        order: number;
        constructor(scope: Exprs.LexicalScope, validatorSet: CssValidator.ValidatorSet);
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    function forEachViewConditionalStyles(style: ElementStyle_$0, callback: (p1: ElementStyle_$0) => any): void;
    function mergeViewConditionalStyles(cascMap: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, style: ElementStyle_$0): void;
    function parseStyleAttribute_$0(scope: Exprs.LexicalScope, validatorSet: CssValidator.ValidatorSet, baseURL: string, styleAttrValue: string): ElementStyle_$0;
    function isVertical(cascaded: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, vertical: boolean): boolean;
    function isRtl(cascaded: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, rtl: boolean): boolean;
    function flattenCascadedStyle(style: ElementStyle_$0, context: Exprs.Context, regionIds: string[], isFootnote: boolean, nodeContext: Vtree_$0.NodeContext): {
        [key: string]: CascadeValue;
    };
    function forEachStylesInRegion(style: ElementStyle_$0, regionIds: string[], isFootnote: boolean, callback: (p1: string, p2: ElementStyle_$0) => any): void;
    function mergeStyle(to: {
        [key: string]: CascadeValue;
    }, from: ElementStyle_$0, context: Exprs.Context): void;
    const convertToPhysical: <T>(src: {
        [key: string]: CascadeValue;
    }, dest: {
        [key: string]: T;
    }, vertical: boolean, rtl: boolean, transform: (p1: string, p2: CascadeValue) => T) => void;
}
declare namespace Exprs {
    type Preferences = {
        fontFamily: string;
        lineHeight: number;
        margin: number;
        hyphenate: boolean;
        columnWidth: number;
        horizontal: boolean;
        nightMode: boolean;
        spreadView: boolean;
        pageBorder: number;
        enabledMediaTypes: {
            [key: string]: boolean;
        };
        defaultPaperSize?: {
            [key: string]: number;
        };
    };
    function defaultPreferences(): Preferences;
    function clonePreferences(pref: Preferences): Preferences;
    const defaultPreferencesInstance: Preferences;
    const Special: {
        PENDING: Pending;
    };
    type Result = string | number | boolean | undefined;
    type PendingResult = Special | Result;
    function letterbox(viewW: number, viewH: number, objW: number, objH: number): string;
    function cssString(str: string): string;
    function cssIdent(name: string): string;
    function makeQualifiedName(objName: string | null, memberName: string): string;
    let nextKeyIndex: number;
    class LexicalScope {
        parent: LexicalScope;
        resolver?: (p1: string, p2: boolean) => Val;
        scopeKey: string;
        children: LexicalScope[];
        zero: Const;
        one: Const;
        _true: Const;
        _false: Const;
        values: {
            [key: string]: Val;
        };
        funcs: {
            [key: string]: Val;
        };
        builtIns: {
            [key: string]: (...p1: Result[]) => Result;
        };
        constructor(parent: LexicalScope, resolver?: (p1: string, p2: boolean) => Val);
        defineBuiltInName(name: string, fn: () => Result): void;
        defineName(qualifiedName: string, val: Val): void;
        defineFunc(qualifiedName: string, val: Val): void;
        defineBuiltIn(qualifiedName: string, fn: (...p1: Result[]) => Result): void;
    }
    function isAbsoluteLengthUnit(unit: string): boolean;
    function isViewportRelativeLengthUnit(unit: string): boolean;
    function isFontRelativeLengthUnit(unit: string): boolean;
    const defaultUnitSizes: {
        [key: string]: number;
    };
    function needUnitConversion(unit: string): boolean;
    type ScopeContext = {
        [key: string]: Result;
    };
    class Context {
        readonly rootScope: LexicalScope;
        readonly viewportWidth: number;
        readonly viewportHeight: number;
        protected actualPageWidth: number | null;
        pageWidth: () => number;
        protected actualPageHeight: number | null;
        pageHeight: () => number;
        initialFontSize: number;
        rootFontSize: number | null;
        fontSize: () => number;
        pref: Preferences;
        scopes: {
            [key: string]: ScopeContext;
        };
        pageAreaWidth: number | null;
        pageAreaHeight: number | null;
        pageVertical: boolean | null;
        pubTitle: string | null;
        docTitle: string | null;
        constructor(rootScope: LexicalScope, viewportWidth: number, viewportHeight: number, fontSize: number);
        private getScopeContext;
        clearScope(scope: LexicalScope): void;
        queryUnitSize(unit: string, isRoot: boolean): number;
        evalName(scope: LexicalScope, qualifiedName: string): Val;
        evalCall(scope: LexicalScope, qualifiedName: string, params: Val[], noBuiltInEval: boolean): Val;
        evalMediaName(name: string, not: boolean): boolean;
        evalMediaTest(feature: string, value: Val): boolean;
        queryVal(scope: LexicalScope, key: string): Result | undefined;
        storeVal(scope: LexicalScope, key: string, val: Result): void;
    }
    type DependencyCache = {
        [key: string]: boolean | Special;
    };
    class Val {
        scope: LexicalScope;
        key: string;
        constructor(scope: LexicalScope);
        toString(): string;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        expand(context: Context, params: Val[]): Val;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        dependOuter(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        depend(other: Val, context: Context): boolean;
        evaluate(context: Context): Result;
        isMediaName(): boolean;
    }
    class Prefix extends Val {
        val: Val;
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Infix extends Val {
        lhs: Val;
        rhs: Val;
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Logical extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Comparison extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Additive extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Multiplicative extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Not extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class Negate extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class And extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class AndMedia extends And {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Or extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class OrMedia extends Or {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Lt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Le extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Gt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ge extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Eq extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ne extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Add extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Subtract extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Multiply extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Divide extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Modulo extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Numeric extends Val {
        num: number;
        unit: string;
        constructor(scope: LexicalScope, num: number, unit: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class Named extends Val {
        qualifiedName: string;
        constructor(scope: LexicalScope, qualifiedName: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    }
    class MediaName extends Val {
        not: boolean;
        name: string;
        value: Val;
        constructor(scope: LexicalScope, not: boolean, name: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        isMediaName(): boolean;
    }
    class Native extends Val {
        fn: () => Result;
        str: string;
        constructor(scope: LexicalScope, fn: () => Result, str: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    function appendValArray(buf: Base.StringBuffer, arr: Val[]): void;
    function expandValArray(context: Context, arr: Val[], params: Val[]): Val[];
    function evalValArray(context: Context, arr: Val[]): Result[];
    class Call extends Val {
        qualifiedName: string;
        params: Val[];
        constructor(scope: LexicalScope, qualifiedName: string, params: Val[]);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Cond extends Val {
        cond: Val;
        ifTrue: Val;
        ifFalse: Val;
        constructor(scope: LexicalScope, cond: Val, ifTrue: Val, ifFalse: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Const extends Val {
        val: Result;
        constructor(scope: LexicalScope, val: Result);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class MediaTest extends Val {
        name: MediaName;
        value: Val;
        constructor(scope: LexicalScope, name: MediaName, value: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Param extends Val {
        index: number;
        constructor(scope: LexicalScope, index: number);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    function and(scope: LexicalScope, v1: Val, v2: Val): Val;
    function add(scope: LexicalScope, v1: Val, v2: Val): Val;
    function sub(scope: LexicalScope, v1: Val, v2: Val): Val;
    function mul(scope: LexicalScope, v1: Val, v2: Val): Val;
    function div(scope: LexicalScope, v1: Val, v2: Val): Val;
}
declare namespace Vgen {
    const frontEdgeBlackListHor: {
        [key: string]: string;
    };
    const frontEdgeBlackListVert: {
        [key: string]: string;
    };
    const frontEdgeUnforcedBreakBlackListHor: {
        [key: string]: string;
    };
    const frontEdgeUnforcedBreakBlackListVert: {
        [key: string]: string;
    };
    type CustomRenderer = (p1: Element, p2: Element, p3: {
        [key: string]: Css.Val;
    }) => Task.Result<Element>;
    interface CustomRendererFactory {
        makeCustomRenderer(xmldoc: XmlDoc.XMLDocHolder): CustomRenderer;
    }
    function initIFrame(iframe: HTMLIFrameElement): void;
    interface StylerProducer {
        getStylerForDoc(xmldoc: XmlDoc.XMLDocHolder): CssStyler_$0.AbstractStyler;
    }
    class ViewFactory extends Base.SimpleEventTarget implements Vtree_$0.LayoutContext {
        readonly flowName: string;
        readonly context: Exprs.Context;
        readonly viewport: Viewport;
        readonly styler: CssStyler_$0.Styler;
        readonly regionIds: string[];
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly docFaces: Font.DocumentFaces;
        readonly footnoteStyle: CssCascade_$0.ElementStyle;
        readonly stylerProducer: StylerProducer;
        readonly page: Vtree_$0.Page;
        readonly customRenderer: CustomRenderer;
        readonly fallbackMap: {
            [key: string]: string;
        };
        readonly documentURLTransformer: Base.DocumentURLTransformer;
        private static SVG_URL_ATTRIBUTES;
        document: Document;
        exprContentListener: Vtree_$0.ExprContentListener;
        nodeContext: Vtree_$0.NodeContext | null;
        viewRoot: Element | null;
        isFootnote: boolean;
        sourceNode: Node | null;
        offsetInNode: number;
        viewNode: Node | null;
        constructor(flowName: string, context: Exprs.Context, viewport: Viewport, styler: CssStyler_$0.Styler, regionIds: string[], xmldoc: XmlDoc.XMLDocHolder, docFaces: Font.DocumentFaces, footnoteStyle: CssCascade_$0.ElementStyle, stylerProducer: StylerProducer, page: Vtree_$0.Page, customRenderer: CustomRenderer, fallbackMap: {
            [key: string]: string;
        }, documentURLTransformer: Base.DocumentURLTransformer);
        clone(): Vtree_$0.LayoutContext;
        createPseudoelementShadow(element: Element, isRoot: boolean, cascStyle: CssCascade_$0.ElementStyle, computedStyle: {
            [key: string]: Css.Val;
        }, styler: CssStyler_$0.AbstractStyler, context: Exprs.Context, parentShadow: Vtree_$0.ShadowContext, subShadow: Vtree_$0.ShadowContext): Vtree_$0.ShadowContext;
        getPseudoMap(cascStyle: CssCascade_$0.ElementStyle, regionIds: string[], isFootnote: boolean, nodeContext: Vtree_$0.NodeContext, context: Exprs.Context): {};
        createRefShadow(href: string, type: Vtree_$0.ShadowType, element: Element, parentShadow: Vtree_$0.ShadowContext, subShadow: Vtree_$0.ShadowContext): Task.Result<Vtree_$0.ShadowContext>;
        createShadows(element: Element, isRoot: any, cascStyle: CssCascade_$0.ElementStyle, computedStyle: {
            [key: string]: Css.Val;
        }, styler: CssStyler_$0.AbstractStyler, context: Exprs.Context, shadowContext: Vtree_$0.ShadowContext): Task.Result<Vtree_$0.ShadowContext>;
        setViewRoot(viewRoot: Element, isFootnote: boolean): void;
        computeStyle(vertical: boolean, rtl: boolean, style: CssCascade_$0.ElementStyle, computedStyle: {
            [key: string]: Css.Val;
        }): boolean;
        private inheritFromSourceParent;
        resolveURL(url: string): string;
        inheritLangAttribute(): void;
        transferPolyfilledInheritedProps(computedStyle: {
            [key: string]: Css.Val;
        }): void;
        resolveFormattingContext(nodeContext: Vtree_$0.NodeContext, firstTime: boolean, display: Css.Ident, position: Css.Ident, float: Css.Ident, isRoot: boolean): void;
        private createElementView;
        private processAfterIfcontinues;
        isSVGUrlAttribute(attributeName: string): boolean;
        modifyElemDimensionWithImageResolution(images: {
            image: HTMLElement;
            element: HTMLElement;
            fetcher: TaskUtil.Fetcher<string>;
        }[], imageResolution: number, computedStyle: {
            [key: string]: Css.Val;
        }, isVertical: boolean): void;
        private preprocessElementStyle;
        private findAndProcessRepeatingElements;
        private processRepeatOnBreak;
        private createTextNodeView;
        private preprocessTextContent;
        createNodeView(firstTime: boolean, atUnforcedBreak: boolean): Task.Result<boolean>;
        setCurrent(nodeContext: Vtree_$0.NodeContext, firstTime: boolean, atUnforcedBreak?: boolean): Task.Result<boolean>;
        processShadowContent(pos: Vtree_$0.NodeContext): Vtree_$0.NodeContext;
        private nextPositionInTree;
        isTransclusion(element: Element, elementStyle: CssCascade_$0.ElementStyle, transclusionType: string | null): boolean;
        nextInTree(position: Vtree_$0.NodeContext, atUnforcedBreak?: boolean): Task.Result<Vtree_$0.NodeContext>;
        addImageFetchers(bg: Css.Val): void;
        applyComputedStyles(target: Element, computedStyle: {
            [key: string]: Css.Val;
        }): void;
        applyPseudoelementStyle(nodeContext: Vtree_$0.NodeContext, pseudoName: string, target: Element): void;
        peelOff(nodeContext: Vtree_$0.NodeContext, nodeOffset: number): Task.Result<Vtree_$0.NodeContext>;
        createElement(ns: string, tag: string): Element;
        applyFootnoteStyle(vertical: boolean, rtl: boolean, target: Element): boolean;
        processFragmentedBlockEdge(nodeContext: Vtree_$0.NodeContext): void;
        convertLengthToPx(numeric: Css.Numeric, viewNode: Node, clientLayout: Vtree_$0.ClientLayout): number | Css.Numeric;
        isSameNodePositionStep(step1: Vtree_$0.NodePositionStep, step2: Vtree_$0.NodePositionStep): boolean;
        isSameNodePosition(nodePosition1: Vtree_$0.NodePosition, nodePosition2: Vtree_$0.NodePosition): boolean;
        isPseudoelement(elem: any): boolean;
    }
    const fb2Remap: {
        a: string;
        sub: string;
        sup: string;
        table: string;
        tr: string;
        td: string;
        th: string;
        code: string;
        body: string;
        p: string;
        v: string;
        date: string;
        emphasis: string;
        strong: string;
        style: string;
        strikethrough: string;
    };
    const propertiesNotPassedToDOM: {
        "box-decoration-break": boolean;
        "float-min-wrap-block": boolean;
        "float-reference": boolean;
        "flow-into": boolean;
        "flow-linger": boolean;
        "flow-options": boolean;
        "flow-priority": boolean;
        "footnote-policy": boolean;
        page: boolean;
    };
    class DefaultClientLayout implements Vtree_$0.ClientLayout {
        layoutBox: Element;
        window: Window;
        constructor(viewport: Viewport);
        private subtractOffsets;
        getRangeClientRects(range: Range): ClientRect[];
        getElementClientRect(element: Element): ClientRect;
        getElementComputedStyle(element: Element): CSSStyleDeclaration;
    }
    class Viewport {
        readonly window: Window;
        readonly fontSize: number;
        document: Document;
        root: HTMLElement;
        private outerZoomBox;
        contentContainer: HTMLElement;
        layoutBox: Element;
        width: number;
        height: number;
        constructor(window: Window, fontSize: number, opt_root?: HTMLElement, opt_width?: number, opt_height?: number);
        resetZoom(): void;
        zoom(width: number, height: number, scale: number): void;
        clear(): void;
    }
}
declare namespace Vtree_$0 {
    const delayedProps: {
        transform: boolean;
        "transform-origin": boolean;
    };
    const delayedPropsIfRelativePositioned: {
        top: boolean;
        bottom: boolean;
        left: boolean;
        right: boolean;
    };
    class DelayedItem {
        target: Element;
        name: string;
        value: Css.Val;
        constructor(target: Element, name: string, value: Css.Val);
    }
    type PageHyperlinkEvent = {
        type: string;
        target: any;
        currentTarget: any;
        anchorElement: Element;
        href: string;
    };
    type Trigger = {
        observer: string;
        event: string;
        action: string;
        ref: string;
    };
    const actions: {
        show: (obj: any) => void;
        hide: (obj: any) => void;
        play: (obj: any) => void;
        pause: (obj: any) => void;
        resume: (obj: any) => void;
        mute: (obj: any) => void;
        unmute: (obj: any) => void;
    };
    function makeListener(refs: Element[], action: string): EventListener | null;
    class Page extends Base.SimpleEventTarget {
        readonly container: HTMLElement;
        readonly bleedBox: HTMLElement;
        private static AUTO_PAGE_WIDTH_ATTRIBUTE;
        private static AUTO_PAGE_HEIGHT_ATTRIBUTE;
        pageAreaElement: HTMLElement | null;
        delayedItems: DelayedItem[];
        hrefHandler: (e: Event) => void;
        elementsById: {
            [key: string]: Element[];
        };
        dimensions: {
            width: number;
            height: number;
        };
        isFirstPage: boolean;
        isLastPage: boolean;
        isAutoPageWidth: boolean;
        isAutoPageHeight: boolean;
        spineIndex: number;
        position: LayoutPosition;
        offset: number;
        side: Constants.PageSide | null;
        fetchers: TaskUtil.Fetcher<{}>[];
        marginBoxes: {
            top: {
                [key: string]: Container_$0;
            };
            bottom: {
                [key: string]: Container_$0;
            };
            left: {
                [key: string]: Container_$0;
            };
            right: {
                [key: string]: Container_$0;
            };
        };
        constructor(container: HTMLElement, bleedBox: HTMLElement);
        setAutoPageWidth(isAuto: boolean): void;
        setAutoPageHeight(isAuto: boolean): void;
        registerElementWithId(element: Element, id: string): void;
        finish(triggers: Trigger[], clientLayout: ClientLayout_$0): void;
        zoom(scale: number): void;
        getPageAreaElement(): HTMLElement;
    }
    type Spread = {
        left: Page;
        right: Page;
    };
    const SPECIAL_ATTR = "data-adapt-spec";
    const Whitespace_$0: typeof Vtree.Whitespace_$0;
    type Whitespace_$0 = Vtree.Whitespace_$0;
    function whitespaceFromPropertyValue(whitespace: string): Whitespace_$0 | null;
    function canIgnore(node: Node, whitespace: Whitespace_$0): boolean;
    class Flow {
        readonly flowName: string;
        readonly parentFlowName: string | null;
        forcedBreakOffsets: number[];
        formattingContext: FormattingContext_$0 | null;
        constructor(flowName: string, parentFlowName: string | null);
    }
    class FlowChunk {
        flowName: string;
        element: Element;
        startOffset: number;
        priority: number;
        linger: number;
        exclusive: boolean;
        repeated: boolean;
        last: boolean;
        breakBefore: string | null;
        startPage: number;
        constructor(flowName: string, element: Element, startOffset: number, priority: number, linger: number, exclusive: boolean, repeated: boolean, last: boolean, breakBefore: string | null);
        isBetter(other: FlowChunk): boolean;
    }
    type ClientRect_$0 = Vtree.ClientRect_$0;
    function clientrectIncreasingTop(r1: ClientRect_$0, r2: ClientRect_$0): number;
    function clientrectDecreasingRight(r1: ClientRect_$0, r2: ClientRect_$0): number;
    type ClientLayout_$0 = Vtree.ClientLayout_$0;
    type LayoutContext_$0 = Vtree.LayoutContext_$0;
    type FormattingContext_$0 = Vtree.FormattingContext_$0;
    function eachAncestorFormattingContext(nodeContext: NodeContext_$0, callback: (p1: FormattingContext_$0) => any): void;
    type NodePositionStep_$0 = Vtree.NodePositionStep_$0;
    function isSameNodePositionStep(nps1: NodePositionStep_$0, nps2: NodePositionStep_$0): boolean;
    type NodePosition_$0 = Vtree.NodePosition_$0;
    function isSameNodePosition(np1: NodePosition_$0 | null, np2: NodePosition_$0 | null): boolean;
    function newNodePositionFromNode(node: Node): NodePosition_$0;
    function newNodePositionFromNodeContext(nodeContext: Vtree.NodeContext_$0, initialFragmentIndex: number | null): NodePosition_$0;
    function makeNodeContextFromNodePositionStep(step: NodePositionStep_$0, parent: Vtree.NodeContext_$0): NodeContext_$0;
    const ShadowType_$0: typeof Vtree.ShadowType_$0;
    type ShadowType_$0 = Vtree.ShadowType_$0;
    class ShadowContext_$0 implements Vtree.ShadowContext_$0 {
        readonly owner: Element;
        readonly root: Element;
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly parentShadow: ShadowContext_$0;
        readonly type: ShadowType_$0;
        readonly styler: object;
        subShadow: ShadowContext_$0;
        constructor(owner: Element, root: Element, xmldoc: XmlDoc.XMLDocHolder, parentShadow: ShadowContext_$0, superShadow: ShadowContext_$0, type: ShadowType_$0, styler: object);
        equals(other: ShadowContext_$0): boolean;
    }
    function isSameShadowContext(sc1: ShadowContext_$0, sc2: ShadowContext_$0): boolean;
    class FirstPseudo_$0 implements Vtree.FirstPseudo_$0 {
        readonly outer: FirstPseudo_$0;
        readonly count: number;
        constructor(outer: FirstPseudo_$0, count: number);
    }
    class NodeContext_$0 implements Vtree.NodeContext_$0 {
        sourceNode: Node;
        parent: NodeContext_$0;
        boxOffset: number;
        offsetInNode: number;
        after: boolean;
        shadowType: ShadowType_$0;
        shadowContext: ShadowContext_$0;
        nodeShadow: ShadowContext_$0;
        shadowSibling: NodeContext_$0;
        shared: boolean;
        inline: boolean;
        overflow: boolean;
        breakPenalty: number;
        display: string | null;
        floatReference: PageFloats.FloatReference;
        floatSide: string | null;
        clearSide: string | null;
        floatMinWrapBlock: Css.Numeric | null;
        columnSpan: Css.Val | null;
        verticalAlign: string;
        captionSide: string;
        inlineBorderSpacing: number;
        blockBorderSpacing: number;
        flexContainer: boolean;
        whitespace: Whitespace_$0;
        hyphenateCharacter: string | null;
        breakWord: boolean;
        establishesBFC: boolean;
        containingBlockForAbsolute: boolean;
        breakBefore: string | null;
        breakAfter: string | null;
        viewNode: Node;
        clearSpacer: Node;
        inheritedProps: {
            [key: string]: number | string | Css.Val;
        };
        vertical: boolean;
        direction: string;
        firstPseudo: FirstPseudo_$0;
        lang: string | null;
        preprocessedTextContent: Diff.Change[] | null;
        formattingContext: FormattingContext_$0;
        repeatOnBreak: string | null;
        pluginProps: {
            [key: string]: string | number | undefined | null | (number | null)[];
        };
        fragmentIndex: number;
        afterIfContinues: Selectors.AfterIfContinues;
        footnotePolicy: Css.Ident | null;
        constructor(sourceNode: Node, parent: NodeContext_$0, boxOffset: number);
        resetView(): void;
        private cloneItem;
        modify(): NodeContext_$0;
        copy(): NodeContext_$0;
        clone(): NodeContext_$0;
        toNodePositionStep(): NodePositionStep_$0;
        toNodePosition(): NodePosition_$0;
        isInsideBFC(): boolean;
        getContainingBlockForAbsolute(): NodeContext_$0;
        walkUpBlocks(callback: (p1: NodeContext_$0) => any): void;
        belongsTo(formattingContext: FormattingContext_$0): boolean;
    }
    class ChunkPosition_$0 implements Vtree.ChunkPosition_$0 {
        primary: NodePosition_$0;
        floats: NodePosition_$0[];
        constructor(primary: NodePosition_$0);
        clone(): ChunkPosition_$0;
        isSamePosition(other: ChunkPosition_$0): boolean;
    }
    class FlowChunkPosition {
        chunkPosition: ChunkPosition_$0;
        readonly flowChunk: FlowChunk;
        constructor(chunkPosition: ChunkPosition_$0, flowChunk: FlowChunk);
        clone(): FlowChunkPosition;
        isSamePosition(other: FlowChunkPosition): boolean;
    }
    class FlowPosition {
        positions: FlowChunkPosition[];
        startSide: string;
        breakAfter: string | null;
        clone(): FlowPosition;
        isSamePosition(other: FlowPosition): boolean;
        hasContent(offset: number): boolean;
    }
    class LayoutPosition {
        page: number;
        flows: {
            [key: string]: Flow;
        };
        flowPositions: {
            [key: string]: FlowPosition;
        };
        highestSeenOffset: number;
        highestSeenNode: Node;
        lookupPositionOffset: number;
        clone(): LayoutPosition;
        isSamePosition(other: LayoutPosition): boolean;
        hasContent(name: string, offset: number): boolean;
        startSideOfFlow(name: string): string;
        firstFlowChunkOfFlow(name: string): FlowChunk | null;
    }
    class Container_$0 implements Vtree.Container_$0 {
        element: Element;
        left: number;
        top: number;
        marginLeft: number;
        marginRight: number;
        marginTop: number;
        marginBottom: number;
        borderLeft: number;
        borderRight: number;
        borderTop: number;
        borderBottom: number;
        paddingLeft: number;
        paddingRight: number;
        paddingTop: number;
        paddingBottom: number;
        width: number;
        height: number;
        originX: number;
        originY: number;
        exclusions: GeometryUtil.Shape[];
        innerShape: GeometryUtil.Shape;
        computedBlockSize: number;
        snapWidth: number;
        snapHeight: number;
        snapOffsetX: number;
        snapOffsetY: number;
        vertical: boolean;
        constructor(element: Element);
        getInsetTop(): number;
        getInsetBottom(): number;
        getInsetLeft(): number;
        getInsetRight(): number;
        getInsetBefore(): number;
        getInsetAfter(): number;
        getInsetStart(): number;
        getInsetEnd(): number;
        getBeforeEdge(box: ClientRect_$0): number;
        getAfterEdge(box: ClientRect_$0): number;
        getStartEdge(box: ClientRect_$0): number;
        getEndEdge(box: ClientRect_$0): number;
        getInlineSize(box: ClientRect_$0): number;
        getBoxSize(box: ClientRect_$0): number;
        getBoxDir(): number;
        getInlineDir(): number;
        copyFrom(other: Container_$0): void;
        setVerticalPosition(top: number, height: number): void;
        setHorizontalPosition(left: number, width: number): void;
        setBlockPosition(start: number, extent: number): void;
        setInlinePosition(start: number, extent: number): void;
        clear(): void;
        getInnerShape(): GeometryUtil.Shape;
        getInnerRect(): GeometryUtil.Rect;
        getPaddingRect(): GeometryUtil.Rect;
        getOuterShape(outerShapeProp: Css.Val, context: Exprs.Context): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
    }
    type ExprContentListener_$0 = Vtree.ExprContentListener_$0;
    class ContentPropertyHandler extends Css.Visitor {
        readonly elem: Element;
        readonly context: Exprs.Context;
        readonly rootContentValue: Css.Val;
        readonly exprContentListener: ExprContentListener_$0;
        constructor(elem: Element, context: Exprs.Context, rootContentValue: Css.Val, exprContentListener: ExprContentListener_$0);
        private visitStrInner;
        visitStr(str: Css.Str): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function nonTrivialContent(val: Css.Val): boolean;
}
declare namespace Base {
    let emptyObj: {};
    type JSON = any;
    function jsonToString(json: JSON): string;
    function stringToJSON(str: string): JSON;
    function stripFragment(url: string): string;
    function stripFragmentAndQuery(url: string): string;
    let baseURL: string;
    function setBaseURL(value: string): void;
    let resourceBaseURL: string;
    function setResourceBaseURL(value: string): void;
    function resolveURL(relURL: string, baseURL: string): string;
    function convertSpecialURL(url: string): string;
    interface DocumentURLTransformer {
        transformFragment(fragment: string, baseURL: string): string;
        transformURL(url: string, baseURL: string): string;
        restoreURL(encoded: string): string[];
    }
    enum NS {
        FB2 = "http://www.gribuser.ru/xml/fictionbook/2.0",
        epub = "http://www.idpf.org/2007/ops",
        EV = "http://www.w3.org/2001/xml-events",
        MATHML = "http://www.w3.org/1998/Math/MathML",
        XML = "http://www.w3.org/XML/1998/namespace",
        XHTML = "http://www.w3.org/1999/xhtml",
        XLINK = "http://www.w3.org/1999/xlink",
        SHADOW = "http://www.pyroxy.com/ns/shadow",
        SVG = "http://www.w3.org/2000/svg",
        DC = "http://purl.org/dc/elements/1.1/",
        NCX = "http://www.daisy.org/z3986/2005/ncx/",
        SSE = "http://example.com/sse"
    }
    function getURLParam(name: string, opt_url?: string): string | null;
    function setURLParam(url: string, name: string, value: string): string;
    function asString(v: any): any;
    interface Comparable {
        compare(other: Comparable): number;
    }
    class PriorityQueue {
        queue: Comparable[];
        length(): number;
        add(item: Comparable): void;
        peek(): Comparable;
        remove(): Comparable;
    }
    function cssToJSProp(prefix: string, cssPropName: string): string;
    const knownPrefixes: string[];
    const propNameMap: {};
    function checkIfPropertySupported(prefix: string, prop: string): boolean;
    function getPrefixedPropertyNames(prop: string): string[] | null;
    function setCSSProperty(elem: Element, prop: string, value: string): void;
    function getCSSProperty(elem: Element, prop: string, opt_value?: string): string;
    function getLangAttribute(element: Element): string;
    class StringBuffer {
        list: string[];
        append(str: string): StringBuffer;
        clear(): void;
        toString(): string;
    }
    function escapeChar(str: string): string;
    function escapeCSSIdent(name: string): string;
    function escapeCSSStr(str: string): string;
    function lightURLEncode(str: string): string;
    function isLetter(ch: string): boolean;
    function escapeCharToHex(str: string, prefix?: string): string;
    function escapeNameStrToHex(str: string, prefix?: string): string;
    function escapeRegExp(str: string): string;
    function unescapeCharFromHex(str: string, prefix?: string): string;
    function unescapeStrFromHex(str: string, prefix?: string): string;
    function binarySearch(high: number, good: (p1: number) => boolean): number;
    function numberCompare(a: number, b: number): number;
    const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    function appendBase64(sb: StringBuffer, data: string): void;
    function indexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T;
    };
    function arrayToSet(arr: string[]): {
        [key: string]: boolean;
    };
    function multiIndexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T[];
    };
    function mapObj<P, R>(obj: {
        [key: string]: P;
    }, fn: (p1: P, p2: string) => R): {
        [key: string]: R;
    };
    function mapSize(obj: object): number;
    type Event = {
        type: string;
        target?: any;
        currentTarget?: any;
        preventDefault?: any;
        newPage?: any;
        anchorElement?: any;
        href?: any;
        content?: any;
    };
    type EventListener = (p1: Event) => void;
    class SimpleEventTarget {
        listeners: {
            [key: string]: EventListener[];
        };
        dispatchEvent(evt: Event): void;
        addEventListener(type: string, listener: EventListener, capture?: boolean): void;
        removeEventListener(type: string, listener: EventListener, capture?: boolean): void;
    }
    type EventTarget = SimpleEventTarget;
    let hasLShapeFloatBug: boolean | null;
    function checkLShapeFloatBug(body: HTMLElement): boolean;
    let hasVerticalBBoxBug: boolean | null;
    function checkVerticalBBoxBug(body: HTMLElement): boolean;
    let hasInlineBlockJustificationBug: boolean | null;
    function checkInlineBlockJustificationBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityAfterHyphenBug: boolean | null;
    function checkSoftWrapOpportunityAfterHyphenBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityByWbrBug: boolean | null;
    function checkSoftWrapOpportunityByWbrBug(body: HTMLElement): boolean;
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
declare namespace Base {
    let emptyObj: {};
    type JSON = any;
    function jsonToString(json: JSON): string;
    function stringToJSON(str: string): JSON;
    function stripFragment(url: string): string;
    function stripFragmentAndQuery(url: string): string;
    let baseURL: string;
    function setBaseURL(value: string): void;
    let resourceBaseURL: string;
    function setResourceBaseURL(value: string): void;
    function resolveURL(relURL: string, baseURL: string): string;
    function convertSpecialURL(url: string): string;
    interface DocumentURLTransformer {
        transformFragment(fragment: string, baseURL: string): string;
        transformURL(url: string, baseURL: string): string;
        restoreURL(encoded: string): string[];
    }
    enum NS {
        FB2 = "http://www.gribuser.ru/xml/fictionbook/2.0",
        epub = "http://www.idpf.org/2007/ops",
        EV = "http://www.w3.org/2001/xml-events",
        MATHML = "http://www.w3.org/1998/Math/MathML",
        XML = "http://www.w3.org/XML/1998/namespace",
        XHTML = "http://www.w3.org/1999/xhtml",
        XLINK = "http://www.w3.org/1999/xlink",
        SHADOW = "http://www.pyroxy.com/ns/shadow",
        SVG = "http://www.w3.org/2000/svg",
        DC = "http://purl.org/dc/elements/1.1/",
        NCX = "http://www.daisy.org/z3986/2005/ncx/",
        SSE = "http://example.com/sse"
    }
    function getURLParam(name: string, opt_url?: string): string | null;
    function setURLParam(url: string, name: string, value: string): string;
    function asString(v: any): any;
    interface Comparable {
        compare(other: Comparable): number;
    }
    class PriorityQueue {
        queue: Comparable[];
        length(): number;
        add(item: Comparable): void;
        peek(): Comparable;
        remove(): Comparable;
    }
    function cssToJSProp(prefix: string, cssPropName: string): string;
    const knownPrefixes: string[];
    const propNameMap: {};
    function checkIfPropertySupported(prefix: string, prop: string): boolean;
    function getPrefixedPropertyNames(prop: string): string[] | null;
    function setCSSProperty(elem: Element, prop: string, value: string): void;
    function getCSSProperty(elem: Element, prop: string, opt_value?: string): string;
    function getLangAttribute(element: Element): string;
    class StringBuffer {
        list: string[];
        append(str: string): StringBuffer;
        clear(): void;
        toString(): string;
    }
    function escapeChar(str: string): string;
    function escapeCSSIdent(name: string): string;
    function escapeCSSStr(str: string): string;
    function lightURLEncode(str: string): string;
    function isLetter(ch: string): boolean;
    function escapeCharToHex(str: string, prefix?: string): string;
    function escapeNameStrToHex(str: string, prefix?: string): string;
    function escapeRegExp(str: string): string;
    function unescapeCharFromHex(str: string, prefix?: string): string;
    function unescapeStrFromHex(str: string, prefix?: string): string;
    function binarySearch(high: number, good: (p1: number) => boolean): number;
    function numberCompare(a: number, b: number): number;
    const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    function appendBase64(sb: StringBuffer, data: string): void;
    function indexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T;
    };
    function arrayToSet(arr: string[]): {
        [key: string]: boolean;
    };
    function multiIndexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T[];
    };
    function mapObj<P, R>(obj: {
        [key: string]: P;
    }, fn: (p1: P, p2: string) => R): {
        [key: string]: R;
    };
    function mapSize(obj: object): number;
    type Event = {
        type: string;
        target?: any;
        currentTarget?: any;
        preventDefault?: any;
        newPage?: any;
        anchorElement?: any;
        href?: any;
        content?: any;
    };
    type EventListener = (p1: Event) => void;
    class SimpleEventTarget {
        listeners: {
            [key: string]: EventListener[];
        };
        dispatchEvent(evt: Event): void;
        addEventListener(type: string, listener: EventListener, capture?: boolean): void;
        removeEventListener(type: string, listener: EventListener, capture?: boolean): void;
    }
    type EventTarget = SimpleEventTarget;
    let hasLShapeFloatBug: boolean | null;
    function checkLShapeFloatBug(body: HTMLElement): boolean;
    let hasVerticalBBoxBug: boolean | null;
    function checkVerticalBBoxBug(body: HTMLElement): boolean;
    let hasInlineBlockJustificationBug: boolean | null;
    function checkInlineBlockJustificationBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityAfterHyphenBug: boolean | null;
    function checkSoftWrapOpportunityAfterHyphenBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityByWbrBug: boolean | null;
    function checkSoftWrapOpportunityByWbrBug(body: HTMLElement): boolean;
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
declare namespace TaskUtil {
    class Fetcher<T> {
        readonly fetch: () => Task.Result<T>;
        name: string;
        arrived: boolean;
        resource: T;
        task: Task.Task;
        piggybacks: ((p1: any) => void)[] | null;
        constructor(fetch: () => Task.Result<T>, opt_name?: string);
        start(): void;
        piggyback(fn: (p1: T) => void): void;
        get(): Task.Result<T>;
        hasArrived(): boolean;
    }
    const waitForFetchers: <T>(fetchers: Fetcher<T>[]) => Task.Result<boolean>;
    function loadElement(elem: Element, src: string): Fetcher<string>;
}
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace CssTokenizer {
    interface TokenizerHandler {
        error(mnemonics: string, token: Token): void;
    }
    function escapeParseSingle(str: string): string;
    function escapeParse(str: string): string;
    enum TokenType {
        EOF = 0,
        IDENT = 1,
        STR = 2,
        NUMERIC = 3,
        NUM = 4,
        INT = 5,
        FUNC = 6,
        HASH = 7,
        URL = 8,
        CLASS = 9,
        O_PAR = 10,
        C_PAR = 11,
        O_BRC = 12,
        C_BRC = 13,
        O_BRK = 14,
        C_BRK = 15,
        COMMA = 16,
        SEMICOL = 17,
        COLON = 18,
        SLASH = 19,
        AT = 20,
        PERCENT = 21,
        QMARK = 22,
        PLUS = 23,
        MINUS = 24,
        BAR_BAR = 25,
        AMP_AMP = 26,
        BANG = 31,
        DOLLAR = 32,
        HAT = 33,
        BAR = 34,
        TILDE = 35,
        STAR = 36,
        GT = 37,
        LT = 38,
        EQ = 39,
        BANG_EQ = 41,
        DOLLAR_EQ = 42,
        HAT_EQ = 43,
        BAR_EQ = 44,
        TILDE_EQ = 45,
        STAR_EQ = 46,
        GT_EQ = 47,
        LT_EQ = 48,
        EQ_EQ = 49,
        COL_COL = 50,
        INVALID = 51,
        LAST = 51
    }
    class Token {
        type: TokenType;
        precededBySpace: boolean;
        num: number;
        text: string;
        position: number;
        constructor();
    }
    enum Action {
        SPACE = 1,
        INT = 2,
        IDENT = 3,
        BANG = 4,
        HASH = 6,
        DOLLAR = 7,
        PERCENT = 8,
        AMP = 9,
        O_PAR = 10,
        C_PAR = 11,
        STAR = 12,
        PLUS = 13,
        COMMA = 14,
        MINUS = 15,
        DOT = 16,
        SLASH = 17,
        COLON = 18,
        SEMICOL = 19,
        LT = 20,
        EQ = 21,
        GT = 22,
        QMARK = 23,
        AT = 24,
        O_BRK = 25,
        C_BRK = 26,
        O_BRC = 27,
        C_BRC = 28,
        BSLASH = 29,
        HAT = 30,
        BAR = 31,
        TILDE = 32,
        STR1 = 33,
        STR2 = 34,
        END = 35,
        EQTAIL = 36,
        ENDINT = 37,
        ENDNUM = 38,
        CONT = 39,
        UNIT = 40,
        PCUNIT = 41,
        NUMBER = 42,
        ENDIDNT = 43,
        IDNTESC = 44,
        ENDIDES = 45,
        ENDSTR = 46,
        ENDESTR = 47,
        STR1ESC = 48,
        STR2ESC = 49,
        BAR_BAR = 50,
        AMP_AMP = 51,
        FUNC = 52,
        FUNCES = 53,
        COMMENT = 54,
        COMMST = 55,
        ENDNOTK = 56,
        MINMIN = 57,
        TOINT = 58,
        TONUM = 59,
        TOIDENT = 60,
        TOIDES = 61,
        KILL1 = 62,
        KILL2 = 63,
        URL = 64,
        URL1 = 65,
        URL2 = 66,
        ENDURL = 67,
        TERMURL = 68,
        FINURL = 69,
        LT_BG = 70,
        LT_BG_M = 71,
        INVALID = 72,
        CHKPOSS = 73,
        CHKPOSN = 74,
        URLESC = 75,
        IDESCH = 76,
        COL_COL = 77,
        TOCLASS = 78,
        CHKSP = 79,
        EOF = 80
    }
    function makeActions(def: Action, spec: Action[]): Action[];
    const actionsNormal: Action[];
    const actionsIdent: Action[];
    const actionsNumOrClass: Action[];
    const actionsMinus: Action[];
    const actionsIdentEsc: Action[];
    const actionsInt: Action[];
    const actionsNumber: Action[];
    const actionsCheckEq: Action[];
    const actionsColon: Action[];
    const actionsBar: Action[];
    const actionsAmp: Action[];
    const actionsSlash: Action[];
    const actionsComment: Action[];
    const actionsCommentStar: Action[];
    const actionsMinusMinus: Action[];
    const actionsLt: Action[];
    const actionsLtBang: Action[];
    const actionsLtBangMinus: Action[];
    const actionsIdentEscChr: Action[];
    const actionsStr1: Action[];
    const actionsStr2: Action[];
    const actionsStr1Esc: Action[];
    const actionsStr2Esc: Action[];
    const actionsURL: Action[];
    const actionsURLInside: Action[];
    const actionsURLInside1: Action[];
    const actionsURLInside2: Action[];
    const actionsURLTail: Action[];
    const INITIAL_INDEX_MASK = 15;
    class Tokenizer {
        input: string;
        readonly handler: TokenizerHandler;
        indexMask: number;
        buffer: Token[];
        head: number;
        tail: number;
        curr: number;
        position: number;
        constructor(input: string, handler: TokenizerHandler);
        token(): Token;
        nthToken(n: number): Token;
        consume(): void;
        mark(): void;
        reset(): void;
        unmark(): void;
        hasMark(): boolean;
        private reallocate;
        private error;
        private fillBuffer;
    }
}
declare namespace Exprs {
    type Preferences = {
        fontFamily: string;
        lineHeight: number;
        margin: number;
        hyphenate: boolean;
        columnWidth: number;
        horizontal: boolean;
        nightMode: boolean;
        spreadView: boolean;
        pageBorder: number;
        enabledMediaTypes: {
            [key: string]: boolean;
        };
        defaultPaperSize?: {
            [key: string]: number;
        };
    };
    function defaultPreferences(): Preferences;
    function clonePreferences(pref: Preferences): Preferences;
    const defaultPreferencesInstance: Preferences;
    const Special: {
        PENDING: Pending;
    };
    type Result = string | number | boolean | undefined;
    type PendingResult = Special | Result;
    function letterbox(viewW: number, viewH: number, objW: number, objH: number): string;
    function cssString(str: string): string;
    function cssIdent(name: string): string;
    function makeQualifiedName(objName: string | null, memberName: string): string;
    let nextKeyIndex: number;
    class LexicalScope {
        parent: LexicalScope;
        resolver?: (p1: string, p2: boolean) => Val;
        scopeKey: string;
        children: LexicalScope[];
        zero: Const;
        one: Const;
        _true: Const;
        _false: Const;
        values: {
            [key: string]: Val;
        };
        funcs: {
            [key: string]: Val;
        };
        builtIns: {
            [key: string]: (...p1: Result[]) => Result;
        };
        constructor(parent: LexicalScope, resolver?: (p1: string, p2: boolean) => Val);
        defineBuiltInName(name: string, fn: () => Result): void;
        defineName(qualifiedName: string, val: Val): void;
        defineFunc(qualifiedName: string, val: Val): void;
        defineBuiltIn(qualifiedName: string, fn: (...p1: Result[]) => Result): void;
    }
    function isAbsoluteLengthUnit(unit: string): boolean;
    function isViewportRelativeLengthUnit(unit: string): boolean;
    function isFontRelativeLengthUnit(unit: string): boolean;
    const defaultUnitSizes: {
        [key: string]: number;
    };
    function needUnitConversion(unit: string): boolean;
    type ScopeContext = {
        [key: string]: Result;
    };
    class Context {
        readonly rootScope: LexicalScope;
        readonly viewportWidth: number;
        readonly viewportHeight: number;
        protected actualPageWidth: number | null;
        pageWidth: () => number;
        protected actualPageHeight: number | null;
        pageHeight: () => number;
        initialFontSize: number;
        rootFontSize: number | null;
        fontSize: () => number;
        pref: Preferences;
        scopes: {
            [key: string]: ScopeContext;
        };
        pageAreaWidth: number | null;
        pageAreaHeight: number | null;
        pageVertical: boolean | null;
        pubTitle: string | null;
        docTitle: string | null;
        constructor(rootScope: LexicalScope, viewportWidth: number, viewportHeight: number, fontSize: number);
        private getScopeContext;
        clearScope(scope: LexicalScope): void;
        queryUnitSize(unit: string, isRoot: boolean): number;
        evalName(scope: LexicalScope, qualifiedName: string): Val;
        evalCall(scope: LexicalScope, qualifiedName: string, params: Val[], noBuiltInEval: boolean): Val;
        evalMediaName(name: string, not: boolean): boolean;
        evalMediaTest(feature: string, value: Val): boolean;
        queryVal(scope: LexicalScope, key: string): Result | undefined;
        storeVal(scope: LexicalScope, key: string, val: Result): void;
    }
    type DependencyCache = {
        [key: string]: boolean | Special;
    };
    class Val {
        scope: LexicalScope;
        key: string;
        constructor(scope: LexicalScope);
        toString(): string;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        expand(context: Context, params: Val[]): Val;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        dependOuter(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        depend(other: Val, context: Context): boolean;
        evaluate(context: Context): Result;
        isMediaName(): boolean;
    }
    class Prefix extends Val {
        val: Val;
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Infix extends Val {
        lhs: Val;
        rhs: Val;
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Logical extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Comparison extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Additive extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Multiplicative extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Not extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class Negate extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class And extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class AndMedia extends And {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Or extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class OrMedia extends Or {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Lt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Le extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Gt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ge extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Eq extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ne extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Add extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Subtract extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Multiply extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Divide extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Modulo extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Numeric extends Val {
        num: number;
        unit: string;
        constructor(scope: LexicalScope, num: number, unit: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class Named extends Val {
        qualifiedName: string;
        constructor(scope: LexicalScope, qualifiedName: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    }
    class MediaName extends Val {
        not: boolean;
        name: string;
        value: Val;
        constructor(scope: LexicalScope, not: boolean, name: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        isMediaName(): boolean;
    }
    class Native extends Val {
        fn: () => Result;
        str: string;
        constructor(scope: LexicalScope, fn: () => Result, str: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    function appendValArray(buf: Base.StringBuffer, arr: Val[]): void;
    function expandValArray(context: Context, arr: Val[], params: Val[]): Val[];
    function evalValArray(context: Context, arr: Val[]): Result[];
    class Call extends Val {
        qualifiedName: string;
        params: Val[];
        constructor(scope: LexicalScope, qualifiedName: string, params: Val[]);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Cond extends Val {
        cond: Val;
        ifTrue: Val;
        ifFalse: Val;
        constructor(scope: LexicalScope, cond: Val, ifTrue: Val, ifFalse: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Const extends Val {
        val: Result;
        constructor(scope: LexicalScope, val: Result);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class MediaTest extends Val {
        name: MediaName;
        value: Val;
        constructor(scope: LexicalScope, name: MediaName, value: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Param extends Val {
        index: number;
        constructor(scope: LexicalScope, index: number);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    function and(scope: LexicalScope, v1: Val, v2: Val): Val;
    function add(scope: LexicalScope, v1: Val, v2: Val): Val;
    function sub(scope: LexicalScope, v1: Val, v2: Val): Val;
    function mul(scope: LexicalScope, v1: Val, v2: Val): Val;
    function div(scope: LexicalScope, v1: Val, v2: Val): Val;
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace CssParser {
    const SPECIFICITY_USER_AGENT: number;
    const SPECIFICITY_USER: number;
    const SPECIFICITY_AUTHOR: number;
    const SPECIFICITY_STYLE: number;
    const SPECIFICITY_STYLE_IMPORTANT: number;
    const SPECIFICITY_AUTHOR_IMPORTANT: number;
    const SPECIFICITY_USER_IMPORTANT: number;
    enum StylesheetFlavor {
        USER_AGENT = "UA",
        USER = "User",
        AUTHOR = "Author"
    }
    function colorFromHash(text: string): Css.Color;
    class ParserHandler implements CssTokenizer.TokenizerHandler {
        scope: Exprs.LexicalScope;
        flavor: StylesheetFlavor;
        constructor(scope: Exprs.LexicalScope);
        getCurrentToken(): CssTokenizer.Token;
        getScope(): Exprs.LexicalScope;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        startStylesheet(flavor: StylesheetFlavor): void;
        tagSelector(ns: string | null, name: string | null): void;
        classSelector(name: string): void;
        pseudoclassSelector(name: string, params: (number | string)[]): void;
        pseudoelementSelector(name: string, params: (number | string)[]): void;
        idSelector(id: string): void;
        attributeSelector(ns: string, name: string, op: CssTokenizer.TokenType, value: string | null): void;
        descendantSelector(): void;
        childSelector(): void;
        adjacentSiblingSelector(): void;
        followingSiblingSelector(): void;
        nextSelector(): void;
        startSelectorRule(): void;
        startFontFaceRule(): void;
        startFootnoteRule(pseudoelem: string | null): void;
        startViewportRule(): void;
        startDefineRule(): void;
        startRegionRule(): void;
        startPageRule(): void;
        startPageMarginBoxRule(name: string): void;
        startWhenRule(expr: Css.Expr): void;
        startMediaRule(expr: Css.Expr): void;
        startFlowRule(flowName: string): void;
        startPageTemplateRule(): void;
        startPageMasterRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionGroupRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startRuleBody(): void;
        property(name: string, value: Css.Val, important: boolean): void;
        endRule(): void;
        startFuncWithSelector(funcName: string): void;
        endFuncWithSelector(): void;
        getImportantSpecificity(): number;
        getBaseSpecificity(): number;
    }
    class DispatchParserHandler extends ParserHandler {
        stack: ParserHandler[];
        tokenizer: CssTokenizer.Tokenizer;
        slave: ParserHandler;
        constructor();
        pushHandler(slave: ParserHandler): void;
        popHandler(): void;
        getCurrentToken(): CssTokenizer.Token;
        getScope(): Exprs.LexicalScope;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        errorMsg(mnemonics: string, token: CssTokenizer.Token): void;
        startStylesheet(flavor: StylesheetFlavor): void;
        tagSelector(ns: string | null, name: string | null): void;
        classSelector(name: string): void;
        pseudoclassSelector(name: string, params: (number | string)[]): void;
        pseudoelementSelector(name: string, params: (number | string)[]): void;
        idSelector(id: string): void;
        attributeSelector(ns: string, name: string, op: CssTokenizer.TokenType, value: string | null): void;
        descendantSelector(): void;
        childSelector(): void;
        adjacentSiblingSelector(): void;
        followingSiblingSelector(): void;
        nextSelector(): void;
        startSelectorRule(): void;
        startFontFaceRule(): void;
        startFootnoteRule(pseudoelem: string | null): void;
        startViewportRule(): void;
        startDefineRule(): void;
        startRegionRule(): void;
        startPageRule(): void;
        startPageMarginBoxRule(name: string): void;
        startWhenRule(expr: Css.Expr): void;
        startFlowRule(flowName: string): void;
        startPageTemplateRule(): void;
        startPageMasterRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionGroupRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startRuleBody(): void;
        property(name: string, value: Css.Val, important: boolean): void;
        endRule(): void;
        startFuncWithSelector(funcName: string): void;
        endFuncWithSelector(): void;
    }
    class SkippingParserHandler extends ParserHandler {
        owner: DispatchParserHandler;
        readonly topLevel: any;
        depth: number;
        flavor: StylesheetFlavor;
        constructor(scope: Exprs.LexicalScope, owner: DispatchParserHandler, topLevel: any);
        getCurrentToken(): CssTokenizer.Token;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        startRuleBody(): void;
        endRule(): void;
    }
    class SlaveParserHandler extends SkippingParserHandler {
        constructor(scope: Exprs.LexicalScope, owner: DispatchParserHandler, topLevel: boolean);
        report(message: string): void;
        reportAndSkip(message: string): void;
        startSelectorRule(): void;
        startFontFaceRule(): void;
        startFootnoteRule(pseudoelem: string | null): void;
        startViewportRule(): void;
        startDefineRule(): void;
        startRegionRule(): void;
        startPageRule(): void;
        startWhenRule(expr: Css.Expr): void;
        startFlowRule(flowName: string): void;
        startPageTemplateRule(): void;
        startPageMasterRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionGroupRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startFuncWithSelector(funcName: string): void;
        endFuncWithSelector(): void;
        property(name: string, value: Css.Val, important: boolean): void;
    }
    const actionsBase: Action_$0[];
    const actionsStyleAttribute: Action_$0[];
    const actionsSelector: Action_$0[];
    const actionsSelectorInFunc: Action_$0[];
    const actionsSelectorCont: Action_$0[];
    const actionsSelectorStart: Action_$0[];
    const actionsPropVal: Action_$0[];
    const actionsExprVal: Action_$0[];
    const actionsExprOp: Action_$0[];
    const actionsError: Action_$0[];
    const actionsErrorDecl: Action_$0[];
    const actionsErrorSelector: Action_$0[];
    const priority: number[];
    enum Action_$0 {
        SELECTOR_NAME_1 = 1,
        SELECTOR_NAME = 2,
        SELECTOR_ANY_1 = 3,
        SELECTOR_ANY = 4,
        SELECTOR_ID_1 = 5,
        SELECTOR_ID = 6,
        SELECTOR_CLASS_1 = 7,
        SELECTOR_CLASS = 8,
        SELECTOR_ATTR_1 = 9,
        SELECTOR_ATTR = 10,
        SELECTOR_CHILD = 11,
        SELECTOR_SIBLING = 12,
        SELECTOR_BODY = 13,
        SELECTOR_PSEUDOCLASS = 14,
        VAL_IDENT = 15,
        VAL_HASH = 16,
        VAL_NUM = 17,
        VAL_INT = 18,
        VAL_NUMERIC = 19,
        VAL_STR = 20,
        VAL_URL = 21,
        VAL_COMMA = 22,
        VAL_SLASH = 23,
        VAL_FUNC = 24,
        VAL_C_PAR = 25,
        VAL_END = 26,
        RULE_END = 27,
        IDENT = 28,
        SELECTOR_START = 29,
        AT = 30,
        EXPR_IDENT = 31,
        EXPR_NUM = 32,
        EXPR_NUMERIC = 33,
        EXPR_STR = 34,
        EXPR_PARAM = 35,
        EXPR_PREFIX = 36,
        EXPR_INFIX = 37,
        EXPR_FUNC = 38,
        EXPR_C_PAR = 39,
        EXPR_O_PAR = 40,
        SELECTOR_NEXT = 41,
        SELECTOR_PSEUDOELEM = 42,
        EXPR_O_BRC = 43,
        VAL_FINISH = 44,
        EXPR_INFIX_NAME = 45,
        PROP = 46,
        VAL_BANG = 47,
        VAL_BRC = 48,
        EXPR_SEMICOL = 49,
        ERROR_PUSH = 50,
        ERROR_POP = 51,
        ERROR_POP_DECL = 52,
        ERROR_SEMICOL = 53,
        VAL_PLUS = 54,
        SELECTOR_PSEUDOCLASS_1 = 55,
        SELECTOR_FOLLOWING_SIBLING = 56,
        DONE = 200
    }
    const OP_MEDIA_AND: number;
    enum ExprContext {
        PROP = 0,
        WHEN = 1,
        MEDIA = 2,
        IMPORT = 3
    }
    class Parser {
        actions: Action_$0[];
        tokenizer: CssTokenizer.Tokenizer;
        readonly handler: ParserHandler;
        baseURL: string;
        valStack: any[];
        namespacePrefixToURI: {
            [key: string]: string;
        };
        defaultNamespaceURI: string | null;
        propName: string | null;
        propImportant: boolean;
        exprContext: ExprContext;
        result: Css.Val;
        importReady: boolean;
        importURL: string | null;
        importCondition: Css.Expr;
        errorBrackets: number[];
        ruleStack: string[];
        regionRule: boolean;
        pageRule: boolean;
        constructor(actions: Action_$0[], tokenizer: CssTokenizer.Tokenizer, handler: ParserHandler, baseURL: string);
        extractVals(sep: string, index: number): Css.Val[];
        valStackReduce(sep: string, token: CssTokenizer.Token): Css.Val;
        exprError(mnemonics: string, token: CssTokenizer.Token): void;
        exprStackReduce(op: number, token: CssTokenizer.Token): boolean;
        readPseudoParams(): (number | string)[];
        private readNthPseudoParams;
        makeCondition(classes: string | null, condition: Exprs.Val): Css.Expr;
        isInsidePropertyOnlyRule(): boolean;
        runParser(count: number, parsingValue: any, parsingStyleAttr: boolean, parsingMediaQuery: any, parsingFunctionParam: any): boolean;
    }
    class ErrorHandler extends ParserHandler {
        readonly scope: Exprs.LexicalScope;
        constructor(scope: Exprs.LexicalScope);
        error(mnemonics: string, token: CssTokenizer.Token): void;
        getScope(): Exprs.LexicalScope;
    }
    function parseStylesheet(tokenizer: CssTokenizer.Tokenizer, handler: ParserHandler, baseURL: string, classes: string | null, media: string | null): Task.Result<boolean>;
    function parseStylesheetFromText(text: string, handler: ParserHandler, baseURL: string, classes: string | null, media: string | null): Task.Result<boolean>;
    function parseStylesheetFromURL(url: string, handler: ParserHandler, classes: string | null, media: string | null): Task.Result<boolean>;
    function parseValue(scope: Exprs.LexicalScope, tokenizer: CssTokenizer.Tokenizer, baseURL: string): Css.Val;
    function parseStyleAttribute(tokenizer: CssTokenizer.Tokenizer, handler: ParserHandler, baseURL: string): void;
    function parseMediaQuery(tokenizer: CssTokenizer.Tokenizer, handler: ParserHandler, baseURL: string): Css.Expr;
    const numProp: {
        [key: string]: boolean;
    };
    function takesOnlyNum(propName: string): boolean;
    function evaluateExprToCSS(context: Exprs.Context, val: Exprs.Val, propName: string): Css.Val;
    function evaluateCSSToCSS(context: Exprs.Context, val: Css.Val, propName: string): Css.Val;
}
declare namespace CssTokenizer {
    interface TokenizerHandler {
        error(mnemonics: string, token: Token): void;
    }
    function escapeParseSingle(str: string): string;
    function escapeParse(str: string): string;
    enum TokenType {
        EOF = 0,
        IDENT = 1,
        STR = 2,
        NUMERIC = 3,
        NUM = 4,
        INT = 5,
        FUNC = 6,
        HASH = 7,
        URL = 8,
        CLASS = 9,
        O_PAR = 10,
        C_PAR = 11,
        O_BRC = 12,
        C_BRC = 13,
        O_BRK = 14,
        C_BRK = 15,
        COMMA = 16,
        SEMICOL = 17,
        COLON = 18,
        SLASH = 19,
        AT = 20,
        PERCENT = 21,
        QMARK = 22,
        PLUS = 23,
        MINUS = 24,
        BAR_BAR = 25,
        AMP_AMP = 26,
        BANG = 31,
        DOLLAR = 32,
        HAT = 33,
        BAR = 34,
        TILDE = 35,
        STAR = 36,
        GT = 37,
        LT = 38,
        EQ = 39,
        BANG_EQ = 41,
        DOLLAR_EQ = 42,
        HAT_EQ = 43,
        BAR_EQ = 44,
        TILDE_EQ = 45,
        STAR_EQ = 46,
        GT_EQ = 47,
        LT_EQ = 48,
        EQ_EQ = 49,
        COL_COL = 50,
        INVALID = 51,
        LAST = 51
    }
    class Token {
        type: TokenType;
        precededBySpace: boolean;
        num: number;
        text: string;
        position: number;
        constructor();
    }
    enum Action {
        SPACE = 1,
        INT = 2,
        IDENT = 3,
        BANG = 4,
        HASH = 6,
        DOLLAR = 7,
        PERCENT = 8,
        AMP = 9,
        O_PAR = 10,
        C_PAR = 11,
        STAR = 12,
        PLUS = 13,
        COMMA = 14,
        MINUS = 15,
        DOT = 16,
        SLASH = 17,
        COLON = 18,
        SEMICOL = 19,
        LT = 20,
        EQ = 21,
        GT = 22,
        QMARK = 23,
        AT = 24,
        O_BRK = 25,
        C_BRK = 26,
        O_BRC = 27,
        C_BRC = 28,
        BSLASH = 29,
        HAT = 30,
        BAR = 31,
        TILDE = 32,
        STR1 = 33,
        STR2 = 34,
        END = 35,
        EQTAIL = 36,
        ENDINT = 37,
        ENDNUM = 38,
        CONT = 39,
        UNIT = 40,
        PCUNIT = 41,
        NUMBER = 42,
        ENDIDNT = 43,
        IDNTESC = 44,
        ENDIDES = 45,
        ENDSTR = 46,
        ENDESTR = 47,
        STR1ESC = 48,
        STR2ESC = 49,
        BAR_BAR = 50,
        AMP_AMP = 51,
        FUNC = 52,
        FUNCES = 53,
        COMMENT = 54,
        COMMST = 55,
        ENDNOTK = 56,
        MINMIN = 57,
        TOINT = 58,
        TONUM = 59,
        TOIDENT = 60,
        TOIDES = 61,
        KILL1 = 62,
        KILL2 = 63,
        URL = 64,
        URL1 = 65,
        URL2 = 66,
        ENDURL = 67,
        TERMURL = 68,
        FINURL = 69,
        LT_BG = 70,
        LT_BG_M = 71,
        INVALID = 72,
        CHKPOSS = 73,
        CHKPOSN = 74,
        URLESC = 75,
        IDESCH = 76,
        COL_COL = 77,
        TOCLASS = 78,
        CHKSP = 79,
        EOF = 80
    }
    function makeActions(def: Action, spec: Action[]): Action[];
    const actionsNormal: Action[];
    const actionsIdent: Action[];
    const actionsNumOrClass: Action[];
    const actionsMinus: Action[];
    const actionsIdentEsc: Action[];
    const actionsInt: Action[];
    const actionsNumber: Action[];
    const actionsCheckEq: Action[];
    const actionsColon: Action[];
    const actionsBar: Action[];
    const actionsAmp: Action[];
    const actionsSlash: Action[];
    const actionsComment: Action[];
    const actionsCommentStar: Action[];
    const actionsMinusMinus: Action[];
    const actionsLt: Action[];
    const actionsLtBang: Action[];
    const actionsLtBangMinus: Action[];
    const actionsIdentEscChr: Action[];
    const actionsStr1: Action[];
    const actionsStr2: Action[];
    const actionsStr1Esc: Action[];
    const actionsStr2Esc: Action[];
    const actionsURL: Action[];
    const actionsURLInside: Action[];
    const actionsURLInside1: Action[];
    const actionsURLInside2: Action[];
    const actionsURLTail: Action[];
    const INITIAL_INDEX_MASK = 15;
    class Tokenizer {
        input: string;
        readonly handler: TokenizerHandler;
        indexMask: number;
        buffer: Token[];
        head: number;
        tail: number;
        curr: number;
        position: number;
        constructor(input: string, handler: TokenizerHandler);
        token(): Token;
        nthToken(n: number): Token;
        consume(): void;
        mark(): void;
        reset(): void;
        unmark(): void;
        hasMark(): boolean;
        private reallocate;
        private error;
        private fillBuffer;
    }
}
declare namespace CssValidator {
    interface PropertyReceiver {
        unknownProperty(name: string, value: Css.Val): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    class Node {
        validator: PropertyValidator;
        success: Node;
        failure: Node;
        code: number;
        constructor(validator: PropertyValidator);
        isSpecial(): boolean;
        markAsStartGroup(): void;
        isStartGroup(): boolean;
        markAsEndGroup(): void;
        isEndGroup(): boolean;
        markAsStartAlternate(index: number): void;
        isStartAlternate(): boolean;
        markAsEndAlternate(index: number): void;
        isEndAlternate(): boolean;
        getAlternate(): number;
    }
    class Connection {
        where: number;
        success: boolean;
        what: number;
        constructor(where: number, success: boolean);
    }
    enum Add_$0 {
        FOLLOW = 1,
        OPTIONAL = 2,
        REPEATED = 3,
        ALTERNATE = 4
    }
    class ValidatingGroup {
        nodes: Node[];
        connections: Connection[];
        match: number[];
        nomatch: number[];
        error: number[];
        emptyHead: boolean;
        connect(arr: number[], nodeIndex: number): void;
        clone(): ValidatingGroup;
        private addSpecialToArr;
        endSpecialGroup(): void;
        startSpecialGroup(): void;
        endClause(clause: number): void;
        startClause(clause: number): void;
        addPrimitive(validator: PropertyValidator): void;
        isSimple(): boolean;
        isPrimitive(): boolean;
        addGroup(group: ValidatingGroup, how: Add_$0): void;
        finish(successTerminal: Node, failTerminal: Node): Node;
    }
    const ALLOW_EMPTY = 1;
    const ALLOW_STR = 2;
    const ALLOW_IDENT = 4;
    const ALLOW_POS_NUMERIC = 8;
    const ALLOW_POS_NUM = 16;
    const ALLOW_POS_INT = 32;
    const ALLOW_COLOR = 64;
    const ALLOW_URL = 128;
    const ALLOW_NEGATIVE = 256;
    const ALLOW_ZERO = 512;
    const ALLOW_ZERO_PERCENT = 1024;
    const ALLOW_SLASH = 2048;
    type ValueMap = {
        [key: string]: Css.Val;
    };
    class PropertyValidator extends Css.Visitor {
        constructor();
        validateForShorthand(values: Css.Val[], index: number): Css.Val[];
    }
    class PrimitiveValidator extends PropertyValidator {
        readonly allowed: number;
        readonly idents: ValueMap;
        readonly units: ValueMap;
        constructor(allowed: number, idents: ValueMap, units: ValueMap);
        visitEmpty(empty: Css.Val): Css.Val;
        visitSlash(slash: Css.Val): Css.Val;
        visitStr(str: Css.Str): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitNum(num: Css.Num): Css.Val;
        visitInt(num: Css.Int): Css.Val;
        visitColor(color: Css.Color): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
        combine(other: PrimitiveValidator): PrimitiveValidator;
    }
    const ALWAYS_FAIL: PrimitiveValidator;
    class ListValidator extends PropertyValidator {
        successTerminal: Node;
        failureTerminal: Node;
        first: Node;
        constructor(group: ValidatingGroup);
        validateList(arr: Css.Val[], slice: boolean, startIndex: number): Css.Val[];
        validateSingle(inval: Css.Val): Css.Val;
        visitEmpty(empty: Css.Val): Css.Val;
        visitSlash(slash: Css.Val): Css.Val;
        visitStr(str: Css.Str): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitNum(num: Css.Num): Css.Val;
        visitInt(num: Css.Int): Css.Val;
        visitColor(color: Css.Color): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    class SpaceListValidator extends ListValidator {
        constructor(group: ValidatingGroup);
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        validateForShorthand(values: Css.Val[], index: number): Css.Val[];
    }
    class CommaListValidator extends ListValidator {
        constructor(group: ValidatingGroup);
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        validateForShorthand(values: Css.Val[], index: number): Css.Val[];
    }
    class FuncValidator extends ListValidator {
        readonly name: string;
        constructor(name: string, group: ValidatingGroup);
        validateSingle(inval: Css.Val): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
    }
    class ShorthandSyntaxNode {
        tryParse(values: Css.Val[], index: number, shorthandValidator: ShorthandValidator): number;
        success(rval: Css.Val, shorthandValidator: ShorthandValidator): void;
    }
    class ShorthandSyntaxProperty extends ShorthandSyntaxNode {
        readonly name: string;
        validator: PropertyValidator;
        constructor(validatorSet: ValidatorSet, name: string);
        tryParse(values: Css.Val[], index: number, shorthandValidator: ShorthandValidator): number;
        success(rval: Css.Val, shorthandValidator: ShorthandValidator): void;
    }
    class ShorthandSyntaxPropertyN extends ShorthandSyntaxProperty {
        readonly names: string[];
        constructor(validatorSet: ValidatorSet, names: string[]);
        success(rval: Css.Val, shorthandValidator: ShorthandValidator): void;
    }
    class ShorthandSyntaxCompound extends ShorthandSyntaxNode {
        readonly nodes: ShorthandSyntaxNode[];
        readonly slash: boolean;
        constructor(nodes: ShorthandSyntaxNode[], slash: boolean);
        tryParse(values: Css.Val[], index: number, shorthandValidator: ShorthandValidator): number;
    }
    class ShorthandValidator extends Css.Visitor {
        syntax: ShorthandSyntaxNode[];
        propList: string[];
        error: boolean;
        values: ValueMap;
        validatorSet: ValidatorSet;
        setOwner(validatorSet: ValidatorSet): void;
        syntaxNodeForProperty(name: string): ShorthandSyntaxNode;
        clone(): this;
        init(syntax: ShorthandSyntaxNode[], propList: string[]): void;
        finish(important: boolean, receiver: PropertyReceiver): boolean;
        propagateInherit(important: boolean, receiver: PropertyReceiver): void;
        validateList(list: Css.Val[]): number;
        validateSingle(val: Css.Val): Css.Val;
        visitEmpty(empty: Css.Val): Css.Val;
        visitStr(str: Css.Str): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitNum(num: Css.Num): Css.Val;
        visitInt(num: Css.Int): Css.Val;
        visitColor(color: Css.Color): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    class SimpleShorthandValidator extends ShorthandValidator {
        constructor();
        validateList(list: Css.Val[]): number;
    }
    class InsetsShorthandValidator extends ShorthandValidator {
        constructor();
        validateList(list: Css.Val[]): number;
        createSyntaxNode(): ShorthandSyntaxPropertyN;
    }
    class InsetsSlashShorthandValidator extends ShorthandValidator {
        constructor();
        validateList(list: Css.Val[]): number;
    }
    class CommaShorthandValidator extends SimpleShorthandValidator {
        constructor();
        mergeIn(acc: {
            [key: string]: Css.Val[];
        }, values: ValueMap): void;
        visitCommaList(list: Css.CommaList): Css.Val;
    }
    class FontShorthandValidator extends SimpleShorthandValidator {
        constructor();
        init(syntax: ShorthandSyntaxNode[], propList: string[]): void;
        validateList(list: Css.Val[]): number;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
    }
    const shorthandValidators: {
        [key: string]: typeof ShorthandValidator;
    };
    class ValidatorSet {
        validators: {
            [key: string]: PropertyValidator;
        };
        prefixes: {
            [key: string]: {
                [key: string]: boolean;
            };
        };
        defaultValues: ValueMap;
        namedValidators: {
            [key: string]: ValidatingGroup;
        };
        systemFonts: {
            [key: string]: ValueMap;
        };
        shorthands: {
            [key: string]: ShorthandValidator;
        };
        layoutProps: ValueMap;
        backgroundProps: ValueMap;
        private addReplacement;
        private newGroup;
        private addCounts;
        private primitive;
        private newFunc;
        initBuiltInValidators(): void;
        private isBuiltIn;
        private readNameAndPrefixes;
        private parseValidators;
        private parseDefaults;
        private parseShorthands;
        parse(text: string): void;
        makePropSet(propList: string[]): ValueMap;
        validatePropertyAndHandleShorthand(name: string, value: Css.Val, important: boolean, receiver: PropertyReceiver): void;
    }
    function baseValidatorSet(): ValidatorSet;
}
declare namespace Exprs {
    type Preferences = {
        fontFamily: string;
        lineHeight: number;
        margin: number;
        hyphenate: boolean;
        columnWidth: number;
        horizontal: boolean;
        nightMode: boolean;
        spreadView: boolean;
        pageBorder: number;
        enabledMediaTypes: {
            [key: string]: boolean;
        };
        defaultPaperSize?: {
            [key: string]: number;
        };
    };
    function defaultPreferences(): Preferences;
    function clonePreferences(pref: Preferences): Preferences;
    const defaultPreferencesInstance: Preferences;
    const Special: {
        PENDING: Pending;
    };
    type Result = string | number | boolean | undefined;
    type PendingResult = Special | Result;
    function letterbox(viewW: number, viewH: number, objW: number, objH: number): string;
    function cssString(str: string): string;
    function cssIdent(name: string): string;
    function makeQualifiedName(objName: string | null, memberName: string): string;
    let nextKeyIndex: number;
    class LexicalScope {
        parent: LexicalScope;
        resolver?: (p1: string, p2: boolean) => Val;
        scopeKey: string;
        children: LexicalScope[];
        zero: Const;
        one: Const;
        _true: Const;
        _false: Const;
        values: {
            [key: string]: Val;
        };
        funcs: {
            [key: string]: Val;
        };
        builtIns: {
            [key: string]: (...p1: Result[]) => Result;
        };
        constructor(parent: LexicalScope, resolver?: (p1: string, p2: boolean) => Val);
        defineBuiltInName(name: string, fn: () => Result): void;
        defineName(qualifiedName: string, val: Val): void;
        defineFunc(qualifiedName: string, val: Val): void;
        defineBuiltIn(qualifiedName: string, fn: (...p1: Result[]) => Result): void;
    }
    function isAbsoluteLengthUnit(unit: string): boolean;
    function isViewportRelativeLengthUnit(unit: string): boolean;
    function isFontRelativeLengthUnit(unit: string): boolean;
    const defaultUnitSizes: {
        [key: string]: number;
    };
    function needUnitConversion(unit: string): boolean;
    type ScopeContext = {
        [key: string]: Result;
    };
    class Context {
        readonly rootScope: LexicalScope;
        readonly viewportWidth: number;
        readonly viewportHeight: number;
        protected actualPageWidth: number | null;
        pageWidth: () => number;
        protected actualPageHeight: number | null;
        pageHeight: () => number;
        initialFontSize: number;
        rootFontSize: number | null;
        fontSize: () => number;
        pref: Preferences;
        scopes: {
            [key: string]: ScopeContext;
        };
        pageAreaWidth: number | null;
        pageAreaHeight: number | null;
        pageVertical: boolean | null;
        pubTitle: string | null;
        docTitle: string | null;
        constructor(rootScope: LexicalScope, viewportWidth: number, viewportHeight: number, fontSize: number);
        private getScopeContext;
        clearScope(scope: LexicalScope): void;
        queryUnitSize(unit: string, isRoot: boolean): number;
        evalName(scope: LexicalScope, qualifiedName: string): Val;
        evalCall(scope: LexicalScope, qualifiedName: string, params: Val[], noBuiltInEval: boolean): Val;
        evalMediaName(name: string, not: boolean): boolean;
        evalMediaTest(feature: string, value: Val): boolean;
        queryVal(scope: LexicalScope, key: string): Result | undefined;
        storeVal(scope: LexicalScope, key: string, val: Result): void;
    }
    type DependencyCache = {
        [key: string]: boolean | Special;
    };
    class Val {
        scope: LexicalScope;
        key: string;
        constructor(scope: LexicalScope);
        toString(): string;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        expand(context: Context, params: Val[]): Val;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        dependOuter(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        depend(other: Val, context: Context): boolean;
        evaluate(context: Context): Result;
        isMediaName(): boolean;
    }
    class Prefix extends Val {
        val: Val;
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Infix extends Val {
        lhs: Val;
        rhs: Val;
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Logical extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Comparison extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Additive extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Multiplicative extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Not extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class Negate extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class And extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class AndMedia extends And {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Or extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class OrMedia extends Or {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Lt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Le extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Gt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ge extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Eq extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ne extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Add extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Subtract extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Multiply extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Divide extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Modulo extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Numeric extends Val {
        num: number;
        unit: string;
        constructor(scope: LexicalScope, num: number, unit: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class Named extends Val {
        qualifiedName: string;
        constructor(scope: LexicalScope, qualifiedName: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    }
    class MediaName extends Val {
        not: boolean;
        name: string;
        value: Val;
        constructor(scope: LexicalScope, not: boolean, name: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        isMediaName(): boolean;
    }
    class Native extends Val {
        fn: () => Result;
        str: string;
        constructor(scope: LexicalScope, fn: () => Result, str: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    function appendValArray(buf: Base.StringBuffer, arr: Val[]): void;
    function expandValArray(context: Context, arr: Val[], params: Val[]): Val[];
    function evalValArray(context: Context, arr: Val[]): Result[];
    class Call extends Val {
        qualifiedName: string;
        params: Val[];
        constructor(scope: LexicalScope, qualifiedName: string, params: Val[]);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Cond extends Val {
        cond: Val;
        ifTrue: Val;
        ifFalse: Val;
        constructor(scope: LexicalScope, cond: Val, ifTrue: Val, ifFalse: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Const extends Val {
        val: Result;
        constructor(scope: LexicalScope, val: Result);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class MediaTest extends Val {
        name: MediaName;
        value: Val;
        constructor(scope: LexicalScope, name: MediaName, value: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Param extends Val {
        index: number;
        constructor(scope: LexicalScope, index: number);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    function and(scope: LexicalScope, v1: Val, v2: Val): Val;
    function add(scope: LexicalScope, v1: Val, v2: Val): Val;
    function sub(scope: LexicalScope, v1: Val, v2: Val): Val;
    function mul(scope: LexicalScope, v1: Val, v2: Val): Val;
    function div(scope: LexicalScope, v1: Val, v2: Val): Val;
}
declare namespace Matchers {
    function matchANPlusB(order: number, a: number, b: number): boolean;
    interface Matcher {
        matches(): boolean;
    }
    class AnyMatcher implements Matcher {
        readonly matchers: Matcher[];
        constructor(matchers: Matcher[]);
        matches(): boolean;
    }
    class AllMatcher implements Matcher {
        readonly matchers: Matcher[];
        constructor(matchers: Matcher[]);
        matches(): boolean;
    }
    class NthFragmentMatcher implements Matcher {
        readonly elementOffset: number;
        readonly a: number;
        readonly b: number;
        static fragmentIndices: {};
        registerFragmentIndex(elementOffset: number, fragmentIndex: number, priority: number): void;
        clearFragmentIndices(): void;
        constructor(elementOffset: number, a: number, b: number);
        matches(): boolean;
    }
    class MatcherBuilder {
        buildViewConditionMatcher(elementOffset: number, viewCondition: string): Matcher;
        buildAllMatcher(matchers: Matcher[]): Matcher;
        buildAnyMatcher(matchers: Matcher[]): Matcher;
    }
}
declare namespace Vtree_$0 {
    const delayedProps: {
        transform: boolean;
        "transform-origin": boolean;
    };
    const delayedPropsIfRelativePositioned: {
        top: boolean;
        bottom: boolean;
        left: boolean;
        right: boolean;
    };
    class DelayedItem {
        target: Element;
        name: string;
        value: Css.Val;
        constructor(target: Element, name: string, value: Css.Val);
    }
    type PageHyperlinkEvent = {
        type: string;
        target: any;
        currentTarget: any;
        anchorElement: Element;
        href: string;
    };
    type Trigger = {
        observer: string;
        event: string;
        action: string;
        ref: string;
    };
    const actions: {
        show: (obj: any) => void;
        hide: (obj: any) => void;
        play: (obj: any) => void;
        pause: (obj: any) => void;
        resume: (obj: any) => void;
        mute: (obj: any) => void;
        unmute: (obj: any) => void;
    };
    function makeListener(refs: Element[], action: string): EventListener | null;
    class Page extends Base.SimpleEventTarget {
        readonly container: HTMLElement;
        readonly bleedBox: HTMLElement;
        private static AUTO_PAGE_WIDTH_ATTRIBUTE;
        private static AUTO_PAGE_HEIGHT_ATTRIBUTE;
        pageAreaElement: HTMLElement | null;
        delayedItems: DelayedItem[];
        hrefHandler: (e: Event) => void;
        elementsById: {
            [key: string]: Element[];
        };
        dimensions: {
            width: number;
            height: number;
        };
        isFirstPage: boolean;
        isLastPage: boolean;
        isAutoPageWidth: boolean;
        isAutoPageHeight: boolean;
        spineIndex: number;
        position: LayoutPosition;
        offset: number;
        side: Constants.PageSide | null;
        fetchers: TaskUtil.Fetcher<{}>[];
        marginBoxes: {
            top: {
                [key: string]: Container_$0;
            };
            bottom: {
                [key: string]: Container_$0;
            };
            left: {
                [key: string]: Container_$0;
            };
            right: {
                [key: string]: Container_$0;
            };
        };
        constructor(container: HTMLElement, bleedBox: HTMLElement);
        setAutoPageWidth(isAuto: boolean): void;
        setAutoPageHeight(isAuto: boolean): void;
        registerElementWithId(element: Element, id: string): void;
        finish(triggers: Trigger[], clientLayout: ClientLayout_$0): void;
        zoom(scale: number): void;
        getPageAreaElement(): HTMLElement;
    }
    type Spread = {
        left: Page;
        right: Page;
    };
    const SPECIAL_ATTR = "data-adapt-spec";
    const Whitespace_$0: typeof Vtree.Whitespace_$0;
    type Whitespace_$0 = Vtree.Whitespace_$0;
    function whitespaceFromPropertyValue(whitespace: string): Whitespace_$0 | null;
    function canIgnore(node: Node, whitespace: Whitespace_$0): boolean;
    class Flow {
        readonly flowName: string;
        readonly parentFlowName: string | null;
        forcedBreakOffsets: number[];
        formattingContext: FormattingContext_$0 | null;
        constructor(flowName: string, parentFlowName: string | null);
    }
    class FlowChunk {
        flowName: string;
        element: Element;
        startOffset: number;
        priority: number;
        linger: number;
        exclusive: boolean;
        repeated: boolean;
        last: boolean;
        breakBefore: string | null;
        startPage: number;
        constructor(flowName: string, element: Element, startOffset: number, priority: number, linger: number, exclusive: boolean, repeated: boolean, last: boolean, breakBefore: string | null);
        isBetter(other: FlowChunk): boolean;
    }
    type ClientRect_$0 = Vtree.ClientRect_$0;
    function clientrectIncreasingTop(r1: ClientRect_$0, r2: ClientRect_$0): number;
    function clientrectDecreasingRight(r1: ClientRect_$0, r2: ClientRect_$0): number;
    type ClientLayout_$0 = Vtree.ClientLayout_$0;
    type LayoutContext_$0 = Vtree.LayoutContext_$0;
    type FormattingContext_$0 = Vtree.FormattingContext_$0;
    function eachAncestorFormattingContext(nodeContext: NodeContext_$0, callback: (p1: FormattingContext_$0) => any): void;
    type NodePositionStep_$0 = Vtree.NodePositionStep_$0;
    function isSameNodePositionStep(nps1: NodePositionStep_$0, nps2: NodePositionStep_$0): boolean;
    type NodePosition_$0 = Vtree.NodePosition_$0;
    function isSameNodePosition(np1: NodePosition_$0 | null, np2: NodePosition_$0 | null): boolean;
    function newNodePositionFromNode(node: Node): NodePosition_$0;
    function newNodePositionFromNodeContext(nodeContext: Vtree.NodeContext_$0, initialFragmentIndex: number | null): NodePosition_$0;
    function makeNodeContextFromNodePositionStep(step: NodePositionStep_$0, parent: Vtree.NodeContext_$0): NodeContext_$0;
    const ShadowType_$0: typeof Vtree.ShadowType_$0;
    type ShadowType_$0 = Vtree.ShadowType_$0;
    class ShadowContext_$0 implements Vtree.ShadowContext_$0 {
        readonly owner: Element;
        readonly root: Element;
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly parentShadow: ShadowContext_$0;
        readonly type: ShadowType_$0;
        readonly styler: object;
        subShadow: ShadowContext_$0;
        constructor(owner: Element, root: Element, xmldoc: XmlDoc.XMLDocHolder, parentShadow: ShadowContext_$0, superShadow: ShadowContext_$0, type: ShadowType_$0, styler: object);
        equals(other: ShadowContext_$0): boolean;
    }
    function isSameShadowContext(sc1: ShadowContext_$0, sc2: ShadowContext_$0): boolean;
    class FirstPseudo_$0 implements Vtree.FirstPseudo_$0 {
        readonly outer: FirstPseudo_$0;
        readonly count: number;
        constructor(outer: FirstPseudo_$0, count: number);
    }
    class NodeContext_$0 implements Vtree.NodeContext_$0 {
        sourceNode: Node;
        parent: NodeContext_$0;
        boxOffset: number;
        offsetInNode: number;
        after: boolean;
        shadowType: ShadowType_$0;
        shadowContext: ShadowContext_$0;
        nodeShadow: ShadowContext_$0;
        shadowSibling: NodeContext_$0;
        shared: boolean;
        inline: boolean;
        overflow: boolean;
        breakPenalty: number;
        display: string | null;
        floatReference: PageFloats.FloatReference;
        floatSide: string | null;
        clearSide: string | null;
        floatMinWrapBlock: Css.Numeric | null;
        columnSpan: Css.Val | null;
        verticalAlign: string;
        captionSide: string;
        inlineBorderSpacing: number;
        blockBorderSpacing: number;
        flexContainer: boolean;
        whitespace: Whitespace_$0;
        hyphenateCharacter: string | null;
        breakWord: boolean;
        establishesBFC: boolean;
        containingBlockForAbsolute: boolean;
        breakBefore: string | null;
        breakAfter: string | null;
        viewNode: Node;
        clearSpacer: Node;
        inheritedProps: {
            [key: string]: number | string | Css.Val;
        };
        vertical: boolean;
        direction: string;
        firstPseudo: FirstPseudo_$0;
        lang: string | null;
        preprocessedTextContent: Diff.Change[] | null;
        formattingContext: FormattingContext_$0;
        repeatOnBreak: string | null;
        pluginProps: {
            [key: string]: string | number | undefined | null | (number | null)[];
        };
        fragmentIndex: number;
        afterIfContinues: Selectors.AfterIfContinues;
        footnotePolicy: Css.Ident | null;
        constructor(sourceNode: Node, parent: NodeContext_$0, boxOffset: number);
        resetView(): void;
        private cloneItem;
        modify(): NodeContext_$0;
        copy(): NodeContext_$0;
        clone(): NodeContext_$0;
        toNodePositionStep(): NodePositionStep_$0;
        toNodePosition(): NodePosition_$0;
        isInsideBFC(): boolean;
        getContainingBlockForAbsolute(): NodeContext_$0;
        walkUpBlocks(callback: (p1: NodeContext_$0) => any): void;
        belongsTo(formattingContext: FormattingContext_$0): boolean;
    }
    class ChunkPosition_$0 implements Vtree.ChunkPosition_$0 {
        primary: NodePosition_$0;
        floats: NodePosition_$0[];
        constructor(primary: NodePosition_$0);
        clone(): ChunkPosition_$0;
        isSamePosition(other: ChunkPosition_$0): boolean;
    }
    class FlowChunkPosition {
        chunkPosition: ChunkPosition_$0;
        readonly flowChunk: FlowChunk;
        constructor(chunkPosition: ChunkPosition_$0, flowChunk: FlowChunk);
        clone(): FlowChunkPosition;
        isSamePosition(other: FlowChunkPosition): boolean;
    }
    class FlowPosition {
        positions: FlowChunkPosition[];
        startSide: string;
        breakAfter: string | null;
        clone(): FlowPosition;
        isSamePosition(other: FlowPosition): boolean;
        hasContent(offset: number): boolean;
    }
    class LayoutPosition {
        page: number;
        flows: {
            [key: string]: Flow;
        };
        flowPositions: {
            [key: string]: FlowPosition;
        };
        highestSeenOffset: number;
        highestSeenNode: Node;
        lookupPositionOffset: number;
        clone(): LayoutPosition;
        isSamePosition(other: LayoutPosition): boolean;
        hasContent(name: string, offset: number): boolean;
        startSideOfFlow(name: string): string;
        firstFlowChunkOfFlow(name: string): FlowChunk | null;
    }
    class Container_$0 implements Vtree.Container_$0 {
        element: Element;
        left: number;
        top: number;
        marginLeft: number;
        marginRight: number;
        marginTop: number;
        marginBottom: number;
        borderLeft: number;
        borderRight: number;
        borderTop: number;
        borderBottom: number;
        paddingLeft: number;
        paddingRight: number;
        paddingTop: number;
        paddingBottom: number;
        width: number;
        height: number;
        originX: number;
        originY: number;
        exclusions: GeometryUtil.Shape[];
        innerShape: GeometryUtil.Shape;
        computedBlockSize: number;
        snapWidth: number;
        snapHeight: number;
        snapOffsetX: number;
        snapOffsetY: number;
        vertical: boolean;
        constructor(element: Element);
        getInsetTop(): number;
        getInsetBottom(): number;
        getInsetLeft(): number;
        getInsetRight(): number;
        getInsetBefore(): number;
        getInsetAfter(): number;
        getInsetStart(): number;
        getInsetEnd(): number;
        getBeforeEdge(box: ClientRect_$0): number;
        getAfterEdge(box: ClientRect_$0): number;
        getStartEdge(box: ClientRect_$0): number;
        getEndEdge(box: ClientRect_$0): number;
        getInlineSize(box: ClientRect_$0): number;
        getBoxSize(box: ClientRect_$0): number;
        getBoxDir(): number;
        getInlineDir(): number;
        copyFrom(other: Container_$0): void;
        setVerticalPosition(top: number, height: number): void;
        setHorizontalPosition(left: number, width: number): void;
        setBlockPosition(start: number, extent: number): void;
        setInlinePosition(start: number, extent: number): void;
        clear(): void;
        getInnerShape(): GeometryUtil.Shape;
        getInnerRect(): GeometryUtil.Rect;
        getPaddingRect(): GeometryUtil.Rect;
        getOuterShape(outerShapeProp: Css.Val, context: Exprs.Context): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
    }
    type ExprContentListener_$0 = Vtree.ExprContentListener_$0;
    class ContentPropertyHandler extends Css.Visitor {
        readonly elem: Element;
        readonly context: Exprs.Context;
        readonly rootContentValue: Css.Val;
        readonly exprContentListener: ExprContentListener_$0;
        constructor(elem: Element, context: Exprs.Context, rootContentValue: Css.Val, exprContentListener: ExprContentListener_$0);
        private visitStrInner;
        visitStr(str: Css.Str): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function nonTrivialContent(val: Css.Val): boolean;
}
declare namespace Vtree_$0 {
    const delayedProps: {
        transform: boolean;
        "transform-origin": boolean;
    };
    const delayedPropsIfRelativePositioned: {
        top: boolean;
        bottom: boolean;
        left: boolean;
        right: boolean;
    };
    class DelayedItem {
        target: Element;
        name: string;
        value: Css.Val;
        constructor(target: Element, name: string, value: Css.Val);
    }
    type PageHyperlinkEvent = {
        type: string;
        target: any;
        currentTarget: any;
        anchorElement: Element;
        href: string;
    };
    type Trigger = {
        observer: string;
        event: string;
        action: string;
        ref: string;
    };
    const actions: {
        show: (obj: any) => void;
        hide: (obj: any) => void;
        play: (obj: any) => void;
        pause: (obj: any) => void;
        resume: (obj: any) => void;
        mute: (obj: any) => void;
        unmute: (obj: any) => void;
    };
    function makeListener(refs: Element[], action: string): EventListener | null;
    class Page extends Base.SimpleEventTarget {
        readonly container: HTMLElement;
        readonly bleedBox: HTMLElement;
        private static AUTO_PAGE_WIDTH_ATTRIBUTE;
        private static AUTO_PAGE_HEIGHT_ATTRIBUTE;
        pageAreaElement: HTMLElement | null;
        delayedItems: DelayedItem[];
        hrefHandler: (e: Event) => void;
        elementsById: {
            [key: string]: Element[];
        };
        dimensions: {
            width: number;
            height: number;
        };
        isFirstPage: boolean;
        isLastPage: boolean;
        isAutoPageWidth: boolean;
        isAutoPageHeight: boolean;
        spineIndex: number;
        position: LayoutPosition;
        offset: number;
        side: Constants.PageSide | null;
        fetchers: TaskUtil.Fetcher<{}>[];
        marginBoxes: {
            top: {
                [key: string]: Container_$0;
            };
            bottom: {
                [key: string]: Container_$0;
            };
            left: {
                [key: string]: Container_$0;
            };
            right: {
                [key: string]: Container_$0;
            };
        };
        constructor(container: HTMLElement, bleedBox: HTMLElement);
        setAutoPageWidth(isAuto: boolean): void;
        setAutoPageHeight(isAuto: boolean): void;
        registerElementWithId(element: Element, id: string): void;
        finish(triggers: Trigger[], clientLayout: ClientLayout_$0): void;
        zoom(scale: number): void;
        getPageAreaElement(): HTMLElement;
    }
    type Spread = {
        left: Page;
        right: Page;
    };
    const SPECIAL_ATTR = "data-adapt-spec";
    const Whitespace_$0: typeof Vtree.Whitespace_$0;
    type Whitespace_$0 = Vtree.Whitespace_$0;
    function whitespaceFromPropertyValue(whitespace: string): Whitespace_$0 | null;
    function canIgnore(node: Node, whitespace: Whitespace_$0): boolean;
    class Flow {
        readonly flowName: string;
        readonly parentFlowName: string | null;
        forcedBreakOffsets: number[];
        formattingContext: FormattingContext_$0 | null;
        constructor(flowName: string, parentFlowName: string | null);
    }
    class FlowChunk {
        flowName: string;
        element: Element;
        startOffset: number;
        priority: number;
        linger: number;
        exclusive: boolean;
        repeated: boolean;
        last: boolean;
        breakBefore: string | null;
        startPage: number;
        constructor(flowName: string, element: Element, startOffset: number, priority: number, linger: number, exclusive: boolean, repeated: boolean, last: boolean, breakBefore: string | null);
        isBetter(other: FlowChunk): boolean;
    }
    type ClientRect_$0 = Vtree.ClientRect_$0;
    function clientrectIncreasingTop(r1: ClientRect_$0, r2: ClientRect_$0): number;
    function clientrectDecreasingRight(r1: ClientRect_$0, r2: ClientRect_$0): number;
    type ClientLayout_$0 = Vtree.ClientLayout_$0;
    type LayoutContext_$0 = Vtree.LayoutContext_$0;
    type FormattingContext_$0 = Vtree.FormattingContext_$0;
    function eachAncestorFormattingContext(nodeContext: NodeContext_$0, callback: (p1: FormattingContext_$0) => any): void;
    type NodePositionStep_$0 = Vtree.NodePositionStep_$0;
    function isSameNodePositionStep(nps1: NodePositionStep_$0, nps2: NodePositionStep_$0): boolean;
    type NodePosition_$0 = Vtree.NodePosition_$0;
    function isSameNodePosition(np1: NodePosition_$0 | null, np2: NodePosition_$0 | null): boolean;
    function newNodePositionFromNode(node: Node): NodePosition_$0;
    function newNodePositionFromNodeContext(nodeContext: Vtree.NodeContext_$0, initialFragmentIndex: number | null): NodePosition_$0;
    function makeNodeContextFromNodePositionStep(step: NodePositionStep_$0, parent: Vtree.NodeContext_$0): NodeContext_$0;
    const ShadowType_$0: typeof Vtree.ShadowType_$0;
    type ShadowType_$0 = Vtree.ShadowType_$0;
    class ShadowContext_$0 implements Vtree.ShadowContext_$0 {
        readonly owner: Element;
        readonly root: Element;
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly parentShadow: ShadowContext_$0;
        readonly type: ShadowType_$0;
        readonly styler: object;
        subShadow: ShadowContext_$0;
        constructor(owner: Element, root: Element, xmldoc: XmlDoc.XMLDocHolder, parentShadow: ShadowContext_$0, superShadow: ShadowContext_$0, type: ShadowType_$0, styler: object);
        equals(other: ShadowContext_$0): boolean;
    }
    function isSameShadowContext(sc1: ShadowContext_$0, sc2: ShadowContext_$0): boolean;
    class FirstPseudo_$0 implements Vtree.FirstPseudo_$0 {
        readonly outer: FirstPseudo_$0;
        readonly count: number;
        constructor(outer: FirstPseudo_$0, count: number);
    }
    class NodeContext_$0 implements Vtree.NodeContext_$0 {
        sourceNode: Node;
        parent: NodeContext_$0;
        boxOffset: number;
        offsetInNode: number;
        after: boolean;
        shadowType: ShadowType_$0;
        shadowContext: ShadowContext_$0;
        nodeShadow: ShadowContext_$0;
        shadowSibling: NodeContext_$0;
        shared: boolean;
        inline: boolean;
        overflow: boolean;
        breakPenalty: number;
        display: string | null;
        floatReference: PageFloats.FloatReference;
        floatSide: string | null;
        clearSide: string | null;
        floatMinWrapBlock: Css.Numeric | null;
        columnSpan: Css.Val | null;
        verticalAlign: string;
        captionSide: string;
        inlineBorderSpacing: number;
        blockBorderSpacing: number;
        flexContainer: boolean;
        whitespace: Whitespace_$0;
        hyphenateCharacter: string | null;
        breakWord: boolean;
        establishesBFC: boolean;
        containingBlockForAbsolute: boolean;
        breakBefore: string | null;
        breakAfter: string | null;
        viewNode: Node;
        clearSpacer: Node;
        inheritedProps: {
            [key: string]: number | string | Css.Val;
        };
        vertical: boolean;
        direction: string;
        firstPseudo: FirstPseudo_$0;
        lang: string | null;
        preprocessedTextContent: Diff.Change[] | null;
        formattingContext: FormattingContext_$0;
        repeatOnBreak: string | null;
        pluginProps: {
            [key: string]: string | number | undefined | null | (number | null)[];
        };
        fragmentIndex: number;
        afterIfContinues: Selectors.AfterIfContinues;
        footnotePolicy: Css.Ident | null;
        constructor(sourceNode: Node, parent: NodeContext_$0, boxOffset: number);
        resetView(): void;
        private cloneItem;
        modify(): NodeContext_$0;
        copy(): NodeContext_$0;
        clone(): NodeContext_$0;
        toNodePositionStep(): NodePositionStep_$0;
        toNodePosition(): NodePosition_$0;
        isInsideBFC(): boolean;
        getContainingBlockForAbsolute(): NodeContext_$0;
        walkUpBlocks(callback: (p1: NodeContext_$0) => any): void;
        belongsTo(formattingContext: FormattingContext_$0): boolean;
    }
    class ChunkPosition_$0 implements Vtree.ChunkPosition_$0 {
        primary: NodePosition_$0;
        floats: NodePosition_$0[];
        constructor(primary: NodePosition_$0);
        clone(): ChunkPosition_$0;
        isSamePosition(other: ChunkPosition_$0): boolean;
    }
    class FlowChunkPosition {
        chunkPosition: ChunkPosition_$0;
        readonly flowChunk: FlowChunk;
        constructor(chunkPosition: ChunkPosition_$0, flowChunk: FlowChunk);
        clone(): FlowChunkPosition;
        isSamePosition(other: FlowChunkPosition): boolean;
    }
    class FlowPosition {
        positions: FlowChunkPosition[];
        startSide: string;
        breakAfter: string | null;
        clone(): FlowPosition;
        isSamePosition(other: FlowPosition): boolean;
        hasContent(offset: number): boolean;
    }
    class LayoutPosition {
        page: number;
        flows: {
            [key: string]: Flow;
        };
        flowPositions: {
            [key: string]: FlowPosition;
        };
        highestSeenOffset: number;
        highestSeenNode: Node;
        lookupPositionOffset: number;
        clone(): LayoutPosition;
        isSamePosition(other: LayoutPosition): boolean;
        hasContent(name: string, offset: number): boolean;
        startSideOfFlow(name: string): string;
        firstFlowChunkOfFlow(name: string): FlowChunk | null;
    }
    class Container_$0 implements Vtree.Container_$0 {
        element: Element;
        left: number;
        top: number;
        marginLeft: number;
        marginRight: number;
        marginTop: number;
        marginBottom: number;
        borderLeft: number;
        borderRight: number;
        borderTop: number;
        borderBottom: number;
        paddingLeft: number;
        paddingRight: number;
        paddingTop: number;
        paddingBottom: number;
        width: number;
        height: number;
        originX: number;
        originY: number;
        exclusions: GeometryUtil.Shape[];
        innerShape: GeometryUtil.Shape;
        computedBlockSize: number;
        snapWidth: number;
        snapHeight: number;
        snapOffsetX: number;
        snapOffsetY: number;
        vertical: boolean;
        constructor(element: Element);
        getInsetTop(): number;
        getInsetBottom(): number;
        getInsetLeft(): number;
        getInsetRight(): number;
        getInsetBefore(): number;
        getInsetAfter(): number;
        getInsetStart(): number;
        getInsetEnd(): number;
        getBeforeEdge(box: ClientRect_$0): number;
        getAfterEdge(box: ClientRect_$0): number;
        getStartEdge(box: ClientRect_$0): number;
        getEndEdge(box: ClientRect_$0): number;
        getInlineSize(box: ClientRect_$0): number;
        getBoxSize(box: ClientRect_$0): number;
        getBoxDir(): number;
        getInlineDir(): number;
        copyFrom(other: Container_$0): void;
        setVerticalPosition(top: number, height: number): void;
        setHorizontalPosition(left: number, width: number): void;
        setBlockPosition(start: number, extent: number): void;
        setInlinePosition(start: number, extent: number): void;
        clear(): void;
        getInnerShape(): GeometryUtil.Shape;
        getInnerRect(): GeometryUtil.Rect;
        getPaddingRect(): GeometryUtil.Rect;
        getOuterShape(outerShapeProp: Css.Val, context: Exprs.Context): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
    }
    type ExprContentListener_$0 = Vtree.ExprContentListener_$0;
    class ContentPropertyHandler extends Css.Visitor {
        readonly elem: Element;
        readonly context: Exprs.Context;
        readonly rootContentValue: Css.Val;
        readonly exprContentListener: ExprContentListener_$0;
        constructor(elem: Element, context: Exprs.Context, rootContentValue: Css.Val, exprContentListener: ExprContentListener_$0);
        private visitStrInner;
        visitStr(str: Css.Str): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function nonTrivialContent(val: Css.Val): boolean;
}
declare namespace Base {
    let emptyObj: {};
    type JSON = any;
    function jsonToString(json: JSON): string;
    function stringToJSON(str: string): JSON;
    function stripFragment(url: string): string;
    function stripFragmentAndQuery(url: string): string;
    let baseURL: string;
    function setBaseURL(value: string): void;
    let resourceBaseURL: string;
    function setResourceBaseURL(value: string): void;
    function resolveURL(relURL: string, baseURL: string): string;
    function convertSpecialURL(url: string): string;
    interface DocumentURLTransformer {
        transformFragment(fragment: string, baseURL: string): string;
        transformURL(url: string, baseURL: string): string;
        restoreURL(encoded: string): string[];
    }
    enum NS {
        FB2 = "http://www.gribuser.ru/xml/fictionbook/2.0",
        epub = "http://www.idpf.org/2007/ops",
        EV = "http://www.w3.org/2001/xml-events",
        MATHML = "http://www.w3.org/1998/Math/MathML",
        XML = "http://www.w3.org/XML/1998/namespace",
        XHTML = "http://www.w3.org/1999/xhtml",
        XLINK = "http://www.w3.org/1999/xlink",
        SHADOW = "http://www.pyroxy.com/ns/shadow",
        SVG = "http://www.w3.org/2000/svg",
        DC = "http://purl.org/dc/elements/1.1/",
        NCX = "http://www.daisy.org/z3986/2005/ncx/",
        SSE = "http://example.com/sse"
    }
    function getURLParam(name: string, opt_url?: string): string | null;
    function setURLParam(url: string, name: string, value: string): string;
    function asString(v: any): any;
    interface Comparable {
        compare(other: Comparable): number;
    }
    class PriorityQueue {
        queue: Comparable[];
        length(): number;
        add(item: Comparable): void;
        peek(): Comparable;
        remove(): Comparable;
    }
    function cssToJSProp(prefix: string, cssPropName: string): string;
    const knownPrefixes: string[];
    const propNameMap: {};
    function checkIfPropertySupported(prefix: string, prop: string): boolean;
    function getPrefixedPropertyNames(prop: string): string[] | null;
    function setCSSProperty(elem: Element, prop: string, value: string): void;
    function getCSSProperty(elem: Element, prop: string, opt_value?: string): string;
    function getLangAttribute(element: Element): string;
    class StringBuffer {
        list: string[];
        append(str: string): StringBuffer;
        clear(): void;
        toString(): string;
    }
    function escapeChar(str: string): string;
    function escapeCSSIdent(name: string): string;
    function escapeCSSStr(str: string): string;
    function lightURLEncode(str: string): string;
    function isLetter(ch: string): boolean;
    function escapeCharToHex(str: string, prefix?: string): string;
    function escapeNameStrToHex(str: string, prefix?: string): string;
    function escapeRegExp(str: string): string;
    function unescapeCharFromHex(str: string, prefix?: string): string;
    function unescapeStrFromHex(str: string, prefix?: string): string;
    function binarySearch(high: number, good: (p1: number) => boolean): number;
    function numberCompare(a: number, b: number): number;
    const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    function appendBase64(sb: StringBuffer, data: string): void;
    function indexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T;
    };
    function arrayToSet(arr: string[]): {
        [key: string]: boolean;
    };
    function multiIndexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T[];
    };
    function mapObj<P, R>(obj: {
        [key: string]: P;
    }, fn: (p1: P, p2: string) => R): {
        [key: string]: R;
    };
    function mapSize(obj: object): number;
    type Event = {
        type: string;
        target?: any;
        currentTarget?: any;
        preventDefault?: any;
        newPage?: any;
        anchorElement?: any;
        href?: any;
        content?: any;
    };
    type EventListener = (p1: Event) => void;
    class SimpleEventTarget {
        listeners: {
            [key: string]: EventListener[];
        };
        dispatchEvent(evt: Event): void;
        addEventListener(type: string, listener: EventListener, capture?: boolean): void;
        removeEventListener(type: string, listener: EventListener, capture?: boolean): void;
    }
    type EventTarget = SimpleEventTarget;
    let hasLShapeFloatBug: boolean | null;
    function checkLShapeFloatBug(body: HTMLElement): boolean;
    let hasVerticalBBoxBug: boolean | null;
    function checkVerticalBBoxBug(body: HTMLElement): boolean;
    let hasInlineBlockJustificationBug: boolean | null;
    function checkInlineBlockJustificationBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityAfterHyphenBug: boolean | null;
    function checkSoftWrapOpportunityAfterHyphenBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityByWbrBug: boolean | null;
    function checkSoftWrapOpportunityByWbrBug(body: HTMLElement): boolean;
}
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace Diff {
    type Change = (number | string)[];
    function diffChars(originalText: string, newText: string): Change[];
    function restoreOriginalText(changes: Change[]): any;
    function restoreNewText(changes: Change[]): any;
    function resolveNewIndex(changes: Change[], oldIndex: number): number;
    function resolveOriginalIndex(changes: Change[], newIndex: number): number;
    function resolveIndex(changes: Change[], index: number, coef: number): number;
}
declare namespace Exprs {
    type Preferences = {
        fontFamily: string;
        lineHeight: number;
        margin: number;
        hyphenate: boolean;
        columnWidth: number;
        horizontal: boolean;
        nightMode: boolean;
        spreadView: boolean;
        pageBorder: number;
        enabledMediaTypes: {
            [key: string]: boolean;
        };
        defaultPaperSize?: {
            [key: string]: number;
        };
    };
    function defaultPreferences(): Preferences;
    function clonePreferences(pref: Preferences): Preferences;
    const defaultPreferencesInstance: Preferences;
    const Special: {
        PENDING: Pending;
    };
    type Result = string | number | boolean | undefined;
    type PendingResult = Special | Result;
    function letterbox(viewW: number, viewH: number, objW: number, objH: number): string;
    function cssString(str: string): string;
    function cssIdent(name: string): string;
    function makeQualifiedName(objName: string | null, memberName: string): string;
    let nextKeyIndex: number;
    class LexicalScope {
        parent: LexicalScope;
        resolver?: (p1: string, p2: boolean) => Val;
        scopeKey: string;
        children: LexicalScope[];
        zero: Const;
        one: Const;
        _true: Const;
        _false: Const;
        values: {
            [key: string]: Val;
        };
        funcs: {
            [key: string]: Val;
        };
        builtIns: {
            [key: string]: (...p1: Result[]) => Result;
        };
        constructor(parent: LexicalScope, resolver?: (p1: string, p2: boolean) => Val);
        defineBuiltInName(name: string, fn: () => Result): void;
        defineName(qualifiedName: string, val: Val): void;
        defineFunc(qualifiedName: string, val: Val): void;
        defineBuiltIn(qualifiedName: string, fn: (...p1: Result[]) => Result): void;
    }
    function isAbsoluteLengthUnit(unit: string): boolean;
    function isViewportRelativeLengthUnit(unit: string): boolean;
    function isFontRelativeLengthUnit(unit: string): boolean;
    const defaultUnitSizes: {
        [key: string]: number;
    };
    function needUnitConversion(unit: string): boolean;
    type ScopeContext = {
        [key: string]: Result;
    };
    class Context {
        readonly rootScope: LexicalScope;
        readonly viewportWidth: number;
        readonly viewportHeight: number;
        protected actualPageWidth: number | null;
        pageWidth: () => number;
        protected actualPageHeight: number | null;
        pageHeight: () => number;
        initialFontSize: number;
        rootFontSize: number | null;
        fontSize: () => number;
        pref: Preferences;
        scopes: {
            [key: string]: ScopeContext;
        };
        pageAreaWidth: number | null;
        pageAreaHeight: number | null;
        pageVertical: boolean | null;
        pubTitle: string | null;
        docTitle: string | null;
        constructor(rootScope: LexicalScope, viewportWidth: number, viewportHeight: number, fontSize: number);
        private getScopeContext;
        clearScope(scope: LexicalScope): void;
        queryUnitSize(unit: string, isRoot: boolean): number;
        evalName(scope: LexicalScope, qualifiedName: string): Val;
        evalCall(scope: LexicalScope, qualifiedName: string, params: Val[], noBuiltInEval: boolean): Val;
        evalMediaName(name: string, not: boolean): boolean;
        evalMediaTest(feature: string, value: Val): boolean;
        queryVal(scope: LexicalScope, key: string): Result | undefined;
        storeVal(scope: LexicalScope, key: string, val: Result): void;
    }
    type DependencyCache = {
        [key: string]: boolean | Special;
    };
    class Val {
        scope: LexicalScope;
        key: string;
        constructor(scope: LexicalScope);
        toString(): string;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        expand(context: Context, params: Val[]): Val;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        dependOuter(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        depend(other: Val, context: Context): boolean;
        evaluate(context: Context): Result;
        isMediaName(): boolean;
    }
    class Prefix extends Val {
        val: Val;
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Infix extends Val {
        lhs: Val;
        rhs: Val;
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Logical extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Comparison extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Additive extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Multiplicative extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Not extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class Negate extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class And extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class AndMedia extends And {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Or extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class OrMedia extends Or {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Lt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Le extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Gt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ge extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Eq extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ne extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Add extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Subtract extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Multiply extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Divide extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Modulo extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Numeric extends Val {
        num: number;
        unit: string;
        constructor(scope: LexicalScope, num: number, unit: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class Named extends Val {
        qualifiedName: string;
        constructor(scope: LexicalScope, qualifiedName: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    }
    class MediaName extends Val {
        not: boolean;
        name: string;
        value: Val;
        constructor(scope: LexicalScope, not: boolean, name: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        isMediaName(): boolean;
    }
    class Native extends Val {
        fn: () => Result;
        str: string;
        constructor(scope: LexicalScope, fn: () => Result, str: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    function appendValArray(buf: Base.StringBuffer, arr: Val[]): void;
    function expandValArray(context: Context, arr: Val[], params: Val[]): Val[];
    function evalValArray(context: Context, arr: Val[]): Result[];
    class Call extends Val {
        qualifiedName: string;
        params: Val[];
        constructor(scope: LexicalScope, qualifiedName: string, params: Val[]);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Cond extends Val {
        cond: Val;
        ifTrue: Val;
        ifFalse: Val;
        constructor(scope: LexicalScope, cond: Val, ifTrue: Val, ifFalse: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Const extends Val {
        val: Result;
        constructor(scope: LexicalScope, val: Result);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class MediaTest extends Val {
        name: MediaName;
        value: Val;
        constructor(scope: LexicalScope, name: MediaName, value: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Param extends Val {
        index: number;
        constructor(scope: LexicalScope, index: number);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    function and(scope: LexicalScope, v1: Val, v2: Val): Val;
    function add(scope: LexicalScope, v1: Val, v2: Val): Val;
    function sub(scope: LexicalScope, v1: Val, v2: Val): Val;
    function mul(scope: LexicalScope, v1: Val, v2: Val): Val;
    function div(scope: LexicalScope, v1: Val, v2: Val): Val;
}
declare namespace GeometryUtil {
    class Rect {
        x1: number;
        y1: number;
        x2: number;
        y2: number;
        constructor(x1: number, y1: number, x2: number, y2: number);
    }
    class Point {
        x: number;
        y: number;
        constructor(x: number, y: number);
    }
    class Insets {
        left: number;
        top: number;
        right: number;
        bottom: number;
        constructor(left: number, top: number, right: number, bottom: number);
    }
    class Segment {
        low: Point;
        high: Point;
        winding: number;
        shapeId: number;
        constructor(low: Point, high: Point, winding: number, shapeId: number);
    }
    class Band {
        y1: number;
        y2: number;
        x1: number;
        x2: number;
        left: Element | null;
        right: Element | null;
        constructor(y1: number, y2: number, x1: number, x2: number);
    }
    function segmentCompare(s1: Segment, s2: Segment): number;
    class Shape {
        points: Point[];
        constructor(points: Point[]);
        addSegments(arr: Segment[], id: number): void;
        withOffset(offsetX: number, offsetY: number): Shape;
    }
    function shapeForEllipse(cx: number, cy: number, rx: number, ry: number): Shape;
    function shapeForRect(x1: number, y1: number, x2: number, y2: number): Shape;
    function shapeForRectObj(r: Rect): Shape;
    class BandIntersection {
        x: number;
        winding: number;
        shapeId: number;
        lowOrHigh: number;
        constructor(x: number, winding: number, shapeId: number, lowOrHigh: number);
    }
    function intersectY(s: Segment, y: number): number;
    function addBandIntersections(intersections: BandIntersection[], s: Segment, y1: number, y2: number): void;
    function mergeIntersections(intersections: BandIntersection[], includeCount: number, excludeCount: number): number[];
    function ceil(v: number, unit: number): number;
    function floor(v: number, unit: number): number;
    function rotatePoint(point: Point): Point;
    function rotateBox(box: Rect): Rect;
    function unrotateBox(box: Rect): Rect;
    function rotateShape(shape: Shape): Shape;
    function shapesToBands(box: Rect, include: Shape[], exclude: Shape[], granularity: number, snapHeight: number, vertical: boolean): Band[];
    function normalize(box: Rect, bands: Band[]): void;
    function findBand(bands: Band[], y: number): number;
    function findUppermostFullyOpenRect(bands: Band[], rect: Rect): Rect | null;
    function findBottommostFullyOpenRect(bands: Band[], rect: Rect): Rect | null;
    function positionFloat(box: Rect, bands: Band[], floatBox: Rect, side: string): boolean;
    function addFloatToBands(box: Rect, bands: Band[], floatBox: Rect, floatBands: Band[], side: string): void;
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
declare namespace TaskUtil {
    class Fetcher<T> {
        readonly fetch: () => Task.Result<T>;
        name: string;
        arrived: boolean;
        resource: T;
        task: Task.Task;
        piggybacks: ((p1: any) => void)[] | null;
        constructor(fetch: () => Task.Result<T>, opt_name?: string);
        start(): void;
        piggyback(fn: (p1: T) => void): void;
        get(): Task.Result<T>;
        hasArrived(): boolean;
    }
    const waitForFetchers: <T>(fetchers: Fetcher<T>[]) => Task.Result<boolean>;
    function loadElement(elem: Element, src: string): Fetcher<string>;
}
declare namespace Base {
    let emptyObj: {};
    type JSON = any;
    function jsonToString(json: JSON): string;
    function stringToJSON(str: string): JSON;
    function stripFragment(url: string): string;
    function stripFragmentAndQuery(url: string): string;
    let baseURL: string;
    function setBaseURL(value: string): void;
    let resourceBaseURL: string;
    function setResourceBaseURL(value: string): void;
    function resolveURL(relURL: string, baseURL: string): string;
    function convertSpecialURL(url: string): string;
    interface DocumentURLTransformer {
        transformFragment(fragment: string, baseURL: string): string;
        transformURL(url: string, baseURL: string): string;
        restoreURL(encoded: string): string[];
    }
    enum NS {
        FB2 = "http://www.gribuser.ru/xml/fictionbook/2.0",
        epub = "http://www.idpf.org/2007/ops",
        EV = "http://www.w3.org/2001/xml-events",
        MATHML = "http://www.w3.org/1998/Math/MathML",
        XML = "http://www.w3.org/XML/1998/namespace",
        XHTML = "http://www.w3.org/1999/xhtml",
        XLINK = "http://www.w3.org/1999/xlink",
        SHADOW = "http://www.pyroxy.com/ns/shadow",
        SVG = "http://www.w3.org/2000/svg",
        DC = "http://purl.org/dc/elements/1.1/",
        NCX = "http://www.daisy.org/z3986/2005/ncx/",
        SSE = "http://example.com/sse"
    }
    function getURLParam(name: string, opt_url?: string): string | null;
    function setURLParam(url: string, name: string, value: string): string;
    function asString(v: any): any;
    interface Comparable {
        compare(other: Comparable): number;
    }
    class PriorityQueue {
        queue: Comparable[];
        length(): number;
        add(item: Comparable): void;
        peek(): Comparable;
        remove(): Comparable;
    }
    function cssToJSProp(prefix: string, cssPropName: string): string;
    const knownPrefixes: string[];
    const propNameMap: {};
    function checkIfPropertySupported(prefix: string, prop: string): boolean;
    function getPrefixedPropertyNames(prop: string): string[] | null;
    function setCSSProperty(elem: Element, prop: string, value: string): void;
    function getCSSProperty(elem: Element, prop: string, opt_value?: string): string;
    function getLangAttribute(element: Element): string;
    class StringBuffer {
        list: string[];
        append(str: string): StringBuffer;
        clear(): void;
        toString(): string;
    }
    function escapeChar(str: string): string;
    function escapeCSSIdent(name: string): string;
    function escapeCSSStr(str: string): string;
    function lightURLEncode(str: string): string;
    function isLetter(ch: string): boolean;
    function escapeCharToHex(str: string, prefix?: string): string;
    function escapeNameStrToHex(str: string, prefix?: string): string;
    function escapeRegExp(str: string): string;
    function unescapeCharFromHex(str: string, prefix?: string): string;
    function unescapeStrFromHex(str: string, prefix?: string): string;
    function binarySearch(high: number, good: (p1: number) => boolean): number;
    function numberCompare(a: number, b: number): number;
    const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    function appendBase64(sb: StringBuffer, data: string): void;
    function indexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T;
    };
    function arrayToSet(arr: string[]): {
        [key: string]: boolean;
    };
    function multiIndexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T[];
    };
    function mapObj<P, R>(obj: {
        [key: string]: P;
    }, fn: (p1: P, p2: string) => R): {
        [key: string]: R;
    };
    function mapSize(obj: object): number;
    type Event = {
        type: string;
        target?: any;
        currentTarget?: any;
        preventDefault?: any;
        newPage?: any;
        anchorElement?: any;
        href?: any;
        content?: any;
    };
    type EventListener = (p1: Event) => void;
    class SimpleEventTarget {
        listeners: {
            [key: string]: EventListener[];
        };
        dispatchEvent(evt: Event): void;
        addEventListener(type: string, listener: EventListener, capture?: boolean): void;
        removeEventListener(type: string, listener: EventListener, capture?: boolean): void;
    }
    type EventTarget = SimpleEventTarget;
    let hasLShapeFloatBug: boolean | null;
    function checkLShapeFloatBug(body: HTMLElement): boolean;
    let hasVerticalBBoxBug: boolean | null;
    function checkVerticalBBoxBug(body: HTMLElement): boolean;
    let hasInlineBlockJustificationBug: boolean | null;
    function checkInlineBlockJustificationBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityAfterHyphenBug: boolean | null;
    function checkSoftWrapOpportunityAfterHyphenBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityByWbrBug: boolean | null;
    function checkSoftWrapOpportunityByWbrBug(body: HTMLElement): boolean;
}
declare namespace Constants {
    let isDebug: boolean;
    function setDebug(value: boolean): void;
    enum PageProgression {
        LTR = "ltr",
        RTL = "rtl"
    }
    function pageProgressionOf(str: string): PageProgression;
    enum PageSide {
        LEFT = "left",
        RIGHT = "right"
    }
    enum ReadyState {
        LOADING = "loading",
        INTERACTIVE = "interactive",
        COMPLETE = "complete"
    }
    const constants: {
        PageProgression: typeof PageProgression;
        PageSide: typeof PageSide;
        ReadyState: typeof ReadyState;
    };
}
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace Diff {
    type Change = (number | string)[];
    function diffChars(originalText: string, newText: string): Change[];
    function restoreOriginalText(changes: Change[]): any;
    function restoreNewText(changes: Change[]): any;
    function resolveNewIndex(changes: Change[], oldIndex: number): number;
    function resolveOriginalIndex(changes: Change[], newIndex: number): number;
    function resolveIndex(changes: Change[], index: number, coef: number): number;
}
declare namespace Exprs {
    type Preferences = {
        fontFamily: string;
        lineHeight: number;
        margin: number;
        hyphenate: boolean;
        columnWidth: number;
        horizontal: boolean;
        nightMode: boolean;
        spreadView: boolean;
        pageBorder: number;
        enabledMediaTypes: {
            [key: string]: boolean;
        };
        defaultPaperSize?: {
            [key: string]: number;
        };
    };
    function defaultPreferences(): Preferences;
    function clonePreferences(pref: Preferences): Preferences;
    const defaultPreferencesInstance: Preferences;
    const Special: {
        PENDING: Pending;
    };
    type Result = string | number | boolean | undefined;
    type PendingResult = Special | Result;
    function letterbox(viewW: number, viewH: number, objW: number, objH: number): string;
    function cssString(str: string): string;
    function cssIdent(name: string): string;
    function makeQualifiedName(objName: string | null, memberName: string): string;
    let nextKeyIndex: number;
    class LexicalScope {
        parent: LexicalScope;
        resolver?: (p1: string, p2: boolean) => Val;
        scopeKey: string;
        children: LexicalScope[];
        zero: Const;
        one: Const;
        _true: Const;
        _false: Const;
        values: {
            [key: string]: Val;
        };
        funcs: {
            [key: string]: Val;
        };
        builtIns: {
            [key: string]: (...p1: Result[]) => Result;
        };
        constructor(parent: LexicalScope, resolver?: (p1: string, p2: boolean) => Val);
        defineBuiltInName(name: string, fn: () => Result): void;
        defineName(qualifiedName: string, val: Val): void;
        defineFunc(qualifiedName: string, val: Val): void;
        defineBuiltIn(qualifiedName: string, fn: (...p1: Result[]) => Result): void;
    }
    function isAbsoluteLengthUnit(unit: string): boolean;
    function isViewportRelativeLengthUnit(unit: string): boolean;
    function isFontRelativeLengthUnit(unit: string): boolean;
    const defaultUnitSizes: {
        [key: string]: number;
    };
    function needUnitConversion(unit: string): boolean;
    type ScopeContext = {
        [key: string]: Result;
    };
    class Context {
        readonly rootScope: LexicalScope;
        readonly viewportWidth: number;
        readonly viewportHeight: number;
        protected actualPageWidth: number | null;
        pageWidth: () => number;
        protected actualPageHeight: number | null;
        pageHeight: () => number;
        initialFontSize: number;
        rootFontSize: number | null;
        fontSize: () => number;
        pref: Preferences;
        scopes: {
            [key: string]: ScopeContext;
        };
        pageAreaWidth: number | null;
        pageAreaHeight: number | null;
        pageVertical: boolean | null;
        pubTitle: string | null;
        docTitle: string | null;
        constructor(rootScope: LexicalScope, viewportWidth: number, viewportHeight: number, fontSize: number);
        private getScopeContext;
        clearScope(scope: LexicalScope): void;
        queryUnitSize(unit: string, isRoot: boolean): number;
        evalName(scope: LexicalScope, qualifiedName: string): Val;
        evalCall(scope: LexicalScope, qualifiedName: string, params: Val[], noBuiltInEval: boolean): Val;
        evalMediaName(name: string, not: boolean): boolean;
        evalMediaTest(feature: string, value: Val): boolean;
        queryVal(scope: LexicalScope, key: string): Result | undefined;
        storeVal(scope: LexicalScope, key: string, val: Result): void;
    }
    type DependencyCache = {
        [key: string]: boolean | Special;
    };
    class Val {
        scope: LexicalScope;
        key: string;
        constructor(scope: LexicalScope);
        toString(): string;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        expand(context: Context, params: Val[]): Val;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        dependOuter(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        depend(other: Val, context: Context): boolean;
        evaluate(context: Context): Result;
        isMediaName(): boolean;
    }
    class Prefix extends Val {
        val: Val;
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Infix extends Val {
        lhs: Val;
        rhs: Val;
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Logical extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Comparison extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Additive extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Multiplicative extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Not extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class Negate extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class And extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class AndMedia extends And {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Or extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class OrMedia extends Or {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Lt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Le extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Gt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ge extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Eq extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ne extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Add extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Subtract extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Multiply extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Divide extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Modulo extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Numeric extends Val {
        num: number;
        unit: string;
        constructor(scope: LexicalScope, num: number, unit: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class Named extends Val {
        qualifiedName: string;
        constructor(scope: LexicalScope, qualifiedName: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    }
    class MediaName extends Val {
        not: boolean;
        name: string;
        value: Val;
        constructor(scope: LexicalScope, not: boolean, name: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        isMediaName(): boolean;
    }
    class Native extends Val {
        fn: () => Result;
        str: string;
        constructor(scope: LexicalScope, fn: () => Result, str: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    function appendValArray(buf: Base.StringBuffer, arr: Val[]): void;
    function expandValArray(context: Context, arr: Val[], params: Val[]): Val[];
    function evalValArray(context: Context, arr: Val[]): Result[];
    class Call extends Val {
        qualifiedName: string;
        params: Val[];
        constructor(scope: LexicalScope, qualifiedName: string, params: Val[]);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Cond extends Val {
        cond: Val;
        ifTrue: Val;
        ifFalse: Val;
        constructor(scope: LexicalScope, cond: Val, ifTrue: Val, ifFalse: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Const extends Val {
        val: Result;
        constructor(scope: LexicalScope, val: Result);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class MediaTest extends Val {
        name: MediaName;
        value: Val;
        constructor(scope: LexicalScope, name: MediaName, value: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Param extends Val {
        index: number;
        constructor(scope: LexicalScope, index: number);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    function and(scope: LexicalScope, v1: Val, v2: Val): Val;
    function add(scope: LexicalScope, v1: Val, v2: Val): Val;
    function sub(scope: LexicalScope, v1: Val, v2: Val): Val;
    function mul(scope: LexicalScope, v1: Val, v2: Val): Val;
    function div(scope: LexicalScope, v1: Val, v2: Val): Val;
}
declare namespace GeometryUtil {
    class Rect {
        x1: number;
        y1: number;
        x2: number;
        y2: number;
        constructor(x1: number, y1: number, x2: number, y2: number);
    }
    class Point {
        x: number;
        y: number;
        constructor(x: number, y: number);
    }
    class Insets {
        left: number;
        top: number;
        right: number;
        bottom: number;
        constructor(left: number, top: number, right: number, bottom: number);
    }
    class Segment {
        low: Point;
        high: Point;
        winding: number;
        shapeId: number;
        constructor(low: Point, high: Point, winding: number, shapeId: number);
    }
    class Band {
        y1: number;
        y2: number;
        x1: number;
        x2: number;
        left: Element | null;
        right: Element | null;
        constructor(y1: number, y2: number, x1: number, x2: number);
    }
    function segmentCompare(s1: Segment, s2: Segment): number;
    class Shape {
        points: Point[];
        constructor(points: Point[]);
        addSegments(arr: Segment[], id: number): void;
        withOffset(offsetX: number, offsetY: number): Shape;
    }
    function shapeForEllipse(cx: number, cy: number, rx: number, ry: number): Shape;
    function shapeForRect(x1: number, y1: number, x2: number, y2: number): Shape;
    function shapeForRectObj(r: Rect): Shape;
    class BandIntersection {
        x: number;
        winding: number;
        shapeId: number;
        lowOrHigh: number;
        constructor(x: number, winding: number, shapeId: number, lowOrHigh: number);
    }
    function intersectY(s: Segment, y: number): number;
    function addBandIntersections(intersections: BandIntersection[], s: Segment, y1: number, y2: number): void;
    function mergeIntersections(intersections: BandIntersection[], includeCount: number, excludeCount: number): number[];
    function ceil(v: number, unit: number): number;
    function floor(v: number, unit: number): number;
    function rotatePoint(point: Point): Point;
    function rotateBox(box: Rect): Rect;
    function unrotateBox(box: Rect): Rect;
    function rotateShape(shape: Shape): Shape;
    function shapesToBands(box: Rect, include: Shape[], exclude: Shape[], granularity: number, snapHeight: number, vertical: boolean): Band[];
    function normalize(box: Rect, bands: Band[]): void;
    function findBand(bands: Band[], y: number): number;
    function findUppermostFullyOpenRect(bands: Band[], rect: Rect): Rect | null;
    function findBottommostFullyOpenRect(bands: Band[], rect: Rect): Rect | null;
    function positionFloat(box: Rect, bands: Band[], floatBox: Rect, side: string): boolean;
    function addFloatToBands(box: Rect, bands: Band[], floatBox: Rect, floatBands: Band[], side: string): void;
}
declare namespace TaskUtil {
    class Fetcher<T> {
        readonly fetch: () => Task.Result<T>;
        name: string;
        arrived: boolean;
        resource: T;
        task: Task.Task;
        piggybacks: ((p1: any) => void)[] | null;
        constructor(fetch: () => Task.Result<T>, opt_name?: string);
        start(): void;
        piggyback(fn: (p1: T) => void): void;
        get(): Task.Result<T>;
        hasArrived(): boolean;
    }
    const waitForFetchers: <T>(fetchers: Fetcher<T>[]) => Task.Result<boolean>;
    function loadElement(elem: Element, src: string): Fetcher<string>;
}
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace GeometryUtil {
    class Rect {
        x1: number;
        y1: number;
        x2: number;
        y2: number;
        constructor(x1: number, y1: number, x2: number, y2: number);
    }
    class Point {
        x: number;
        y: number;
        constructor(x: number, y: number);
    }
    class Insets {
        left: number;
        top: number;
        right: number;
        bottom: number;
        constructor(left: number, top: number, right: number, bottom: number);
    }
    class Segment {
        low: Point;
        high: Point;
        winding: number;
        shapeId: number;
        constructor(low: Point, high: Point, winding: number, shapeId: number);
    }
    class Band {
        y1: number;
        y2: number;
        x1: number;
        x2: number;
        left: Element | null;
        right: Element | null;
        constructor(y1: number, y2: number, x1: number, x2: number);
    }
    function segmentCompare(s1: Segment, s2: Segment): number;
    class Shape {
        points: Point[];
        constructor(points: Point[]);
        addSegments(arr: Segment[], id: number): void;
        withOffset(offsetX: number, offsetY: number): Shape;
    }
    function shapeForEllipse(cx: number, cy: number, rx: number, ry: number): Shape;
    function shapeForRect(x1: number, y1: number, x2: number, y2: number): Shape;
    function shapeForRectObj(r: Rect): Shape;
    class BandIntersection {
        x: number;
        winding: number;
        shapeId: number;
        lowOrHigh: number;
        constructor(x: number, winding: number, shapeId: number, lowOrHigh: number);
    }
    function intersectY(s: Segment, y: number): number;
    function addBandIntersections(intersections: BandIntersection[], s: Segment, y1: number, y2: number): void;
    function mergeIntersections(intersections: BandIntersection[], includeCount: number, excludeCount: number): number[];
    function ceil(v: number, unit: number): number;
    function floor(v: number, unit: number): number;
    function rotatePoint(point: Point): Point;
    function rotateBox(box: Rect): Rect;
    function unrotateBox(box: Rect): Rect;
    function rotateShape(shape: Shape): Shape;
    function shapesToBands(box: Rect, include: Shape[], exclude: Shape[], granularity: number, snapHeight: number, vertical: boolean): Band[];
    function normalize(box: Rect, bands: Band[]): void;
    function findBand(bands: Band[], y: number): number;
    function findUppermostFullyOpenRect(bands: Band[], rect: Rect): Rect | null;
    function findBottommostFullyOpenRect(bands: Band[], rect: Rect): Rect | null;
    function positionFloat(box: Rect, bands: Band[], floatBox: Rect, side: string): boolean;
    function addFloatToBands(box: Rect, bands: Band[], floatBox: Rect, floatBands: Band[], side: string): void;
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
type LayoutType = Layout;
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace PageFloats_$0 {
    const FloatReference_$0: typeof PageFloats.FloatReference_$0;
    type FloatReference_$0 = PageFloats.FloatReference_$0;
    function floatReferenceOf(str: string): FloatReference_$0;
    function isPageFloat(floatReference: FloatReference_$0): boolean;
    function resolveInlineFloatDirection(floatSide: string, vertical: boolean, direction: string): string;
    class PageFloat_$0 implements PageFloats.PageFloat_$0 {
        readonly nodePosition: Vtree.NodePosition;
        readonly floatReference: FloatReference_$0;
        readonly floatSide: string;
        readonly clearSide: string | null;
        readonly flowName: string;
        readonly floatMinWrapBlock: Css.Numeric | null;
        order: number | null;
        id: PageFloatID_$0 | null;
        constructor(nodePosition: Vtree.NodePosition, floatReference: FloatReference_$0, floatSide: string, clearSide: string | null, flowName: string, floatMinWrapBlock: Css.Numeric | null);
        getOrder(): number;
        getId(): PageFloatID_$0;
        isAllowedOnContext(pageFloatLayoutContext: PageFloatLayoutContext_$0): boolean;
        isAllowedToPrecede(other: PageFloat_$0): boolean;
    }
    class PageFloatStore {
        private floats;
        private nextPageFloatIndex;
        private nextOrder;
        private createPageFloatId;
        addPageFloat(float: PageFloat_$0): void;
        findPageFloatByNodePosition(nodePosition: Vtree.NodePosition): PageFloat_$0 | null;
        findPageFloatById(id: PageFloatID_$0): PageFloat_$0;
    }
    class PageFloatFragment_$0 implements PageFloats.PageFloatFragment_$0 {
        readonly floatReference: FloatReference_$0;
        readonly floatSide: string;
        readonly continuations: PageFloatContinuation_$0[];
        readonly area: Vtree.Container;
        readonly continues: boolean;
        constructor(floatReference: FloatReference_$0, floatSide: string, continuations: PageFloatContinuation_$0[], area: Vtree.Container, continues: boolean);
        hasFloat(float: PageFloat_$0): boolean;
        findNotAllowedFloat(context: PageFloatLayoutContext_$0): PageFloat_$0 | null;
        getOuterShape(): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
        getOrder(): number;
        shouldBeStashedBefore(float: PageFloat_$0): boolean;
        addContinuations(continuations: PageFloatContinuation_$0[]): void;
        getFlowName(): string;
    }
    class PageFloatContinuation_$0 implements PageFloats.PageFloatContinuation_$0 {
        readonly float: PageFloat_$0;
        readonly nodePosition: Vtree.NodePosition;
        constructor(float: PageFloat_$0, nodePosition: Vtree.NodePosition);
        equals(other: PageFloatContinuation_$0 | null): boolean;
    }
    type PageFloatPlacementCondition_$0 = PageFloats.PageFloatPlacementCondition_$0;
    class PageFloatLayoutContext_$0 implements PageFloats.PageFloatLayoutContext_$0 {
        readonly parent: PageFloatLayoutContext_$0;
        private readonly floatReference;
        private container;
        readonly flowName: string | null;
        readonly generatingNodePosition: Vtree.NodePosition | null;
        private children;
        writingMode: Css.Val;
        direction: Css.Val;
        private invalidated;
        private floatStore;
        private forbiddenFloats;
        floatFragments: PageFloatFragment_$0[];
        private stashedFloatFragments;
        private floatAnchors;
        private floatsDeferredToNext;
        private floatsDeferredFromPrevious;
        private layoutConstraints;
        private locked;
        constructor(parent: PageFloatLayoutContext_$0, floatReference: FloatReference_$0 | null, container: Vtree.Container, flowName: string | null, generatingNodePosition: Vtree.NodePosition | null, writingMode: Css.Val | null, direction: Css.Val | null);
        private getParent;
        private getPreviousSiblingOf;
        private getPreviousSibling;
        getContainer(floatReference?: FloatReference_$0): Vtree.Container;
        setContainer(container: Vtree.Container): void;
        addPageFloat(float: PageFloat_$0): void;
        getPageFloatLayoutContext(floatReference: FloatReference_$0): PageFloatLayoutContext_$0;
        findPageFloatByNodePosition(nodePosition: Vtree.NodePosition): PageFloat_$0 | null;
        private forbid;
        isForbidden(float: PageFloat_$0): boolean;
        addPageFloatFragment(floatFragment: PageFloatFragment_$0, dontInvalidate?: boolean): void;
        removePageFloatFragment(floatFragment: PageFloatFragment_$0, dontInvalidate?: boolean): void;
        findPageFloatFragment(float: PageFloat_$0): PageFloatFragment_$0 | null;
        hasFloatFragments(condition?: (p1: PageFloatFragment_$0) => boolean): boolean;
        hasContinuingFloatFragmentsInFlow(flowName: string): boolean;
        registerPageFloatAnchor(float: PageFloat_$0, anchorViewNode: Node): void;
        collectPageFloatAnchors(): any;
        isAnchorAlreadyAppeared(floatId: PageFloatID_$0): boolean;
        deferPageFloat(continuation: PageFloatContinuation_$0): void;
        hasPrecedingFloatsDeferredToNext(float: PageFloat_$0, ignoreReference?: boolean): boolean;
        getLastFollowingFloatInFragments(float: PageFloat_$0): PageFloat_$0 | null;
        getDeferredPageFloatContinuations(flowName?: string | null): PageFloatContinuation_$0[];
        getPageFloatContinuationsDeferredToNext(flowName?: string | null): PageFloatContinuation_$0[];
        getFloatsDeferredToNextInChildContexts(): PageFloat_$0[];
        checkAndForbidNotAllowedFloat(): boolean;
        checkAndForbidFloatFollowingDeferredFloat(): boolean;
        finish(): void;
        hasSameContainerAs(other: PageFloatLayoutContext_$0): boolean;
        invalidate(): void;
        detachChildren(): PageFloatLayoutContext_$0[];
        attachChildren(children: PageFloatLayoutContext_$0[]): void;
        isInvalidated(): any;
        validate(): void;
        private toLogical;
        private toPhysical;
        removeEndFloatFragments(floatSide: string): void;
        stashEndFloatFragments(float: PageFloat_$0): void;
        restoreStashedFragments(floatReference: FloatReference_$0): void;
        discardStashedFragments(floatReference: FloatReference_$0): void;
        getStashedFloatFragments(floatReference: FloatReference_$0): PageFloatFragment_$0[];
        private getLimitValue;
        private getLimitValueInner;
        private getLimitValuesInner;
        setFloatAreaDimensions(area: LayoutType.PageFloatArea, floatReference: FloatReference_$0, floatSide: string, anchorEdge: number | null, init: boolean, force: boolean, condition: PageFloatPlacementCondition_$0): string | null;
        getFloatFragmentExclusions(): GeometryUtil.Shape[];
        private reattachFloatFragments;
        getMaxReachedAfterEdge(): number;
        getBlockStartEdgeOfBlockEndFloats(): number;
        getPageFloatClearEdge(clear: string, column: LayoutType.Column): number;
        getPageFloatPlacementCondition(float: PageFloat_$0, floatSide: string, clearSide: string | null): PageFloatPlacementCondition_$0;
        getLayoutConstraints(): LayoutType.LayoutConstraint[];
        addLayoutConstraint(layoutConstraint: LayoutType.LayoutConstraint, floatReference: FloatReference_$0): void;
        isColumnFullWithPageFloats(column: LayoutType.Column): boolean;
        getMaxBlockSizeOfPageFloats(): number;
        lock(): void;
        unlock(): void;
        isLocked(): boolean;
    }
    interface PageFloatLayoutStrategy_$0 extends PageFloats.PageFloatLayoutStrategy_$0 {
    }
    class PageFloatLayoutStrategyResolver {
        register(strategy: PageFloatLayoutStrategy_$0): void;
        findByNodeContext(nodeContext: Vtree.NodeContext): PageFloatLayoutStrategy_$0;
        findByFloat(float: PageFloat_$0): PageFloatLayoutStrategy_$0;
    }
    class NormalPageFloatLayoutStrategy implements PageFloatLayoutStrategy_$0 {
        appliesToNodeContext(nodeContext: Vtree.NodeContext): boolean;
        appliesToFloat(float: PageFloat_$0): boolean;
        createPageFloat(nodeContext: Vtree.NodeContext, pageFloatLayoutContext: PageFloatLayoutContext_$0, column: LayoutType.Column): Task.Result<PageFloat_$0>;
        createPageFloatFragment(continuations: PageFloatContinuation_$0[], floatSide: string, floatArea: LayoutType.PageFloatArea, continues: boolean): PageFloatFragment_$0;
        findPageFloatFragment(float: PageFloat_$0, pageFloatLayoutContext: PageFloatLayoutContext_$0): PageFloatFragment_$0 | null;
        adjustPageFloatArea(floatArea: LayoutType.PageFloatArea, floatContainer: Vtree.Container, column: LayoutType.Column): void;
        forbid(float: PageFloat_$0, pageFloatLayoutContext: PageFloatLayoutContext_$0): void;
    }
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
declare namespace Vtree_$0 {
    const delayedProps: {
        transform: boolean;
        "transform-origin": boolean;
    };
    const delayedPropsIfRelativePositioned: {
        top: boolean;
        bottom: boolean;
        left: boolean;
        right: boolean;
    };
    class DelayedItem {
        target: Element;
        name: string;
        value: Css.Val;
        constructor(target: Element, name: string, value: Css.Val);
    }
    type PageHyperlinkEvent = {
        type: string;
        target: any;
        currentTarget: any;
        anchorElement: Element;
        href: string;
    };
    type Trigger = {
        observer: string;
        event: string;
        action: string;
        ref: string;
    };
    const actions: {
        show: (obj: any) => void;
        hide: (obj: any) => void;
        play: (obj: any) => void;
        pause: (obj: any) => void;
        resume: (obj: any) => void;
        mute: (obj: any) => void;
        unmute: (obj: any) => void;
    };
    function makeListener(refs: Element[], action: string): EventListener | null;
    class Page extends Base.SimpleEventTarget {
        readonly container: HTMLElement;
        readonly bleedBox: HTMLElement;
        private static AUTO_PAGE_WIDTH_ATTRIBUTE;
        private static AUTO_PAGE_HEIGHT_ATTRIBUTE;
        pageAreaElement: HTMLElement | null;
        delayedItems: DelayedItem[];
        hrefHandler: (e: Event) => void;
        elementsById: {
            [key: string]: Element[];
        };
        dimensions: {
            width: number;
            height: number;
        };
        isFirstPage: boolean;
        isLastPage: boolean;
        isAutoPageWidth: boolean;
        isAutoPageHeight: boolean;
        spineIndex: number;
        position: LayoutPosition;
        offset: number;
        side: Constants.PageSide | null;
        fetchers: TaskUtil.Fetcher<{}>[];
        marginBoxes: {
            top: {
                [key: string]: Container_$0;
            };
            bottom: {
                [key: string]: Container_$0;
            };
            left: {
                [key: string]: Container_$0;
            };
            right: {
                [key: string]: Container_$0;
            };
        };
        constructor(container: HTMLElement, bleedBox: HTMLElement);
        setAutoPageWidth(isAuto: boolean): void;
        setAutoPageHeight(isAuto: boolean): void;
        registerElementWithId(element: Element, id: string): void;
        finish(triggers: Trigger[], clientLayout: ClientLayout_$0): void;
        zoom(scale: number): void;
        getPageAreaElement(): HTMLElement;
    }
    type Spread = {
        left: Page;
        right: Page;
    };
    const SPECIAL_ATTR = "data-adapt-spec";
    const Whitespace_$0: typeof Vtree.Whitespace_$0;
    type Whitespace_$0 = Vtree.Whitespace_$0;
    function whitespaceFromPropertyValue(whitespace: string): Whitespace_$0 | null;
    function canIgnore(node: Node, whitespace: Whitespace_$0): boolean;
    class Flow {
        readonly flowName: string;
        readonly parentFlowName: string | null;
        forcedBreakOffsets: number[];
        formattingContext: FormattingContext_$0 | null;
        constructor(flowName: string, parentFlowName: string | null);
    }
    class FlowChunk {
        flowName: string;
        element: Element;
        startOffset: number;
        priority: number;
        linger: number;
        exclusive: boolean;
        repeated: boolean;
        last: boolean;
        breakBefore: string | null;
        startPage: number;
        constructor(flowName: string, element: Element, startOffset: number, priority: number, linger: number, exclusive: boolean, repeated: boolean, last: boolean, breakBefore: string | null);
        isBetter(other: FlowChunk): boolean;
    }
    type ClientRect_$0 = Vtree.ClientRect_$0;
    function clientrectIncreasingTop(r1: ClientRect_$0, r2: ClientRect_$0): number;
    function clientrectDecreasingRight(r1: ClientRect_$0, r2: ClientRect_$0): number;
    type ClientLayout_$0 = Vtree.ClientLayout_$0;
    type LayoutContext_$0 = Vtree.LayoutContext_$0;
    type FormattingContext_$0 = Vtree.FormattingContext_$0;
    function eachAncestorFormattingContext(nodeContext: NodeContext_$0, callback: (p1: FormattingContext_$0) => any): void;
    type NodePositionStep_$0 = Vtree.NodePositionStep_$0;
    function isSameNodePositionStep(nps1: NodePositionStep_$0, nps2: NodePositionStep_$0): boolean;
    type NodePosition_$0 = Vtree.NodePosition_$0;
    function isSameNodePosition(np1: NodePosition_$0 | null, np2: NodePosition_$0 | null): boolean;
    function newNodePositionFromNode(node: Node): NodePosition_$0;
    function newNodePositionFromNodeContext(nodeContext: Vtree.NodeContext_$0, initialFragmentIndex: number | null): NodePosition_$0;
    function makeNodeContextFromNodePositionStep(step: NodePositionStep_$0, parent: Vtree.NodeContext_$0): NodeContext_$0;
    const ShadowType_$0: typeof Vtree.ShadowType_$0;
    type ShadowType_$0 = Vtree.ShadowType_$0;
    class ShadowContext_$0 implements Vtree.ShadowContext_$0 {
        readonly owner: Element;
        readonly root: Element;
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly parentShadow: ShadowContext_$0;
        readonly type: ShadowType_$0;
        readonly styler: object;
        subShadow: ShadowContext_$0;
        constructor(owner: Element, root: Element, xmldoc: XmlDoc.XMLDocHolder, parentShadow: ShadowContext_$0, superShadow: ShadowContext_$0, type: ShadowType_$0, styler: object);
        equals(other: ShadowContext_$0): boolean;
    }
    function isSameShadowContext(sc1: ShadowContext_$0, sc2: ShadowContext_$0): boolean;
    class FirstPseudo_$0 implements Vtree.FirstPseudo_$0 {
        readonly outer: FirstPseudo_$0;
        readonly count: number;
        constructor(outer: FirstPseudo_$0, count: number);
    }
    class NodeContext_$0 implements Vtree.NodeContext_$0 {
        sourceNode: Node;
        parent: NodeContext_$0;
        boxOffset: number;
        offsetInNode: number;
        after: boolean;
        shadowType: ShadowType_$0;
        shadowContext: ShadowContext_$0;
        nodeShadow: ShadowContext_$0;
        shadowSibling: NodeContext_$0;
        shared: boolean;
        inline: boolean;
        overflow: boolean;
        breakPenalty: number;
        display: string | null;
        floatReference: PageFloats.FloatReference;
        floatSide: string | null;
        clearSide: string | null;
        floatMinWrapBlock: Css.Numeric | null;
        columnSpan: Css.Val | null;
        verticalAlign: string;
        captionSide: string;
        inlineBorderSpacing: number;
        blockBorderSpacing: number;
        flexContainer: boolean;
        whitespace: Whitespace_$0;
        hyphenateCharacter: string | null;
        breakWord: boolean;
        establishesBFC: boolean;
        containingBlockForAbsolute: boolean;
        breakBefore: string | null;
        breakAfter: string | null;
        viewNode: Node;
        clearSpacer: Node;
        inheritedProps: {
            [key: string]: number | string | Css.Val;
        };
        vertical: boolean;
        direction: string;
        firstPseudo: FirstPseudo_$0;
        lang: string | null;
        preprocessedTextContent: Diff.Change[] | null;
        formattingContext: FormattingContext_$0;
        repeatOnBreak: string | null;
        pluginProps: {
            [key: string]: string | number | undefined | null | (number | null)[];
        };
        fragmentIndex: number;
        afterIfContinues: Selectors.AfterIfContinues;
        footnotePolicy: Css.Ident | null;
        constructor(sourceNode: Node, parent: NodeContext_$0, boxOffset: number);
        resetView(): void;
        private cloneItem;
        modify(): NodeContext_$0;
        copy(): NodeContext_$0;
        clone(): NodeContext_$0;
        toNodePositionStep(): NodePositionStep_$0;
        toNodePosition(): NodePosition_$0;
        isInsideBFC(): boolean;
        getContainingBlockForAbsolute(): NodeContext_$0;
        walkUpBlocks(callback: (p1: NodeContext_$0) => any): void;
        belongsTo(formattingContext: FormattingContext_$0): boolean;
    }
    class ChunkPosition_$0 implements Vtree.ChunkPosition_$0 {
        primary: NodePosition_$0;
        floats: NodePosition_$0[];
        constructor(primary: NodePosition_$0);
        clone(): ChunkPosition_$0;
        isSamePosition(other: ChunkPosition_$0): boolean;
    }
    class FlowChunkPosition {
        chunkPosition: ChunkPosition_$0;
        readonly flowChunk: FlowChunk;
        constructor(chunkPosition: ChunkPosition_$0, flowChunk: FlowChunk);
        clone(): FlowChunkPosition;
        isSamePosition(other: FlowChunkPosition): boolean;
    }
    class FlowPosition {
        positions: FlowChunkPosition[];
        startSide: string;
        breakAfter: string | null;
        clone(): FlowPosition;
        isSamePosition(other: FlowPosition): boolean;
        hasContent(offset: number): boolean;
    }
    class LayoutPosition {
        page: number;
        flows: {
            [key: string]: Flow;
        };
        flowPositions: {
            [key: string]: FlowPosition;
        };
        highestSeenOffset: number;
        highestSeenNode: Node;
        lookupPositionOffset: number;
        clone(): LayoutPosition;
        isSamePosition(other: LayoutPosition): boolean;
        hasContent(name: string, offset: number): boolean;
        startSideOfFlow(name: string): string;
        firstFlowChunkOfFlow(name: string): FlowChunk | null;
    }
    class Container_$0 implements Vtree.Container_$0 {
        element: Element;
        left: number;
        top: number;
        marginLeft: number;
        marginRight: number;
        marginTop: number;
        marginBottom: number;
        borderLeft: number;
        borderRight: number;
        borderTop: number;
        borderBottom: number;
        paddingLeft: number;
        paddingRight: number;
        paddingTop: number;
        paddingBottom: number;
        width: number;
        height: number;
        originX: number;
        originY: number;
        exclusions: GeometryUtil.Shape[];
        innerShape: GeometryUtil.Shape;
        computedBlockSize: number;
        snapWidth: number;
        snapHeight: number;
        snapOffsetX: number;
        snapOffsetY: number;
        vertical: boolean;
        constructor(element: Element);
        getInsetTop(): number;
        getInsetBottom(): number;
        getInsetLeft(): number;
        getInsetRight(): number;
        getInsetBefore(): number;
        getInsetAfter(): number;
        getInsetStart(): number;
        getInsetEnd(): number;
        getBeforeEdge(box: ClientRect_$0): number;
        getAfterEdge(box: ClientRect_$0): number;
        getStartEdge(box: ClientRect_$0): number;
        getEndEdge(box: ClientRect_$0): number;
        getInlineSize(box: ClientRect_$0): number;
        getBoxSize(box: ClientRect_$0): number;
        getBoxDir(): number;
        getInlineDir(): number;
        copyFrom(other: Container_$0): void;
        setVerticalPosition(top: number, height: number): void;
        setHorizontalPosition(left: number, width: number): void;
        setBlockPosition(start: number, extent: number): void;
        setInlinePosition(start: number, extent: number): void;
        clear(): void;
        getInnerShape(): GeometryUtil.Shape;
        getInnerRect(): GeometryUtil.Rect;
        getPaddingRect(): GeometryUtil.Rect;
        getOuterShape(outerShapeProp: Css.Val, context: Exprs.Context): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
    }
    type ExprContentListener_$0 = Vtree.ExprContentListener_$0;
    class ContentPropertyHandler extends Css.Visitor {
        readonly elem: Element;
        readonly context: Exprs.Context;
        readonly rootContentValue: Css.Val;
        readonly exprContentListener: ExprContentListener_$0;
        constructor(elem: Element, context: Exprs.Context, rootContentValue: Css.Val, exprContentListener: ExprContentListener_$0);
        private visitStrInner;
        visitStr(str: Css.Str): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function nonTrivialContent(val: Css.Val): boolean;
}
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace CssCascade_$0 {
    interface ElementStyle_$0 extends CssCascade.ElementStyle_$0 {
    }
    const inheritedProps: {
        azimuth: boolean;
        "border-collapse": boolean;
        "border-spacing": boolean;
        "caption-side": boolean;
        "clip-rule": boolean;
        color: boolean;
        "color-interpolation": boolean;
        "color-rendering": boolean;
        cursor: boolean;
        direction: boolean;
        elevation: boolean;
        "empty-cells": boolean;
        fill: boolean;
        "fill-opacity": boolean;
        "fill-rule": boolean;
        "font-kerning": boolean;
        "font-size": boolean;
        "font-size-adjust": boolean;
        "font-family": boolean;
        "font-feature-settings": boolean;
        "font-style": boolean;
        "font-stretch": boolean;
        "font-variant": boolean;
        "font-weight": boolean;
        "glyph-orientation-vertical": boolean;
        hyphens: boolean;
        "hyphenate-character": boolean;
        "hyphenate-limit-chars": boolean;
        "hyphenate-limit-last": boolean;
        "image-rendering": boolean;
        "image-resolution": boolean;
        "letter-spacing": boolean;
        "line-break": boolean;
        "line-height": boolean;
        "list-style-image": boolean;
        "list-style-position": boolean;
        "list-style-type": boolean;
        marker: boolean;
        "marker-end": boolean;
        "marker-mid": boolean;
        "marker-start": boolean;
        orphans: boolean;
        "overflow-wrap": boolean;
        "paint-order": boolean;
        "pointer-events": boolean;
        "pitch-range": boolean;
        quotes: boolean;
        richness: boolean;
        "ruby-align": boolean;
        "ruby-position": boolean;
        "speak-header": boolean;
        "speak-numeral": boolean;
        "speak-punctuation": boolean;
        "speech-rate": boolean;
        "shape-rendering": boolean;
        stress: boolean;
        stroke: boolean;
        "stroke-dasharray": boolean;
        "stroke-dashoffset": boolean;
        "stroke-linecap": boolean;
        "stroke-linejoin": boolean;
        "stroke-miterlimit": boolean;
        "stroke-opacity": boolean;
        "stroke-width": boolean;
        "tab-size": boolean;
        "text-align": boolean;
        "text-align-last": boolean;
        "text-anchor": boolean;
        "text-decoration-skip": boolean;
        "text-emphasis-color": boolean;
        "text-emphasis-position": boolean;
        "text-emphasis-style": boolean;
        "text-combine-upright": boolean;
        "text-indent": boolean;
        "text-justify": boolean;
        "text-rendering": boolean;
        "text-size-adjust": boolean;
        "text-transform": boolean;
        "text-underline-position": boolean;
        visibility: boolean;
        "voice-family": boolean;
        volume: boolean;
        "white-space": boolean;
        widows: boolean;
        "word-break": boolean;
        "word-spacing": boolean;
        "word-wrap": boolean;
        "writing-mode": boolean;
    };
    const polyfilledInheritedProps: string[];
    function getPolyfilledInheritedProps(): string[];
    const supportedNamespaces: {
        "http://www.idpf.org/2007/ops": boolean;
        "http://www.w3.org/1999/xhtml": boolean;
        "http://www.w3.org/2000/svg": boolean;
    };
    const coupledPatterns: string[];
    const coupledExtentPatterns: string[];
    const geomNames: {
        [key: string]: boolean;
    };
    function buildCouplingMap(sideMap: {
        [key: string]: string;
    }, extentMap: {
        [key: string]: string;
    }): {
        [key: string]: string;
    };
    const couplingMapVert: {
        [key: string]: string;
    };
    const couplingMapHor: {
        [key: string]: string;
    };
    const couplingMapVertRtl: {
        [key: string]: string;
    };
    const couplingMapHorRtl: {
        [key: string]: string;
    };
    class CascadeValue {
        readonly value: Css.Val;
        readonly priority: number;
        constructor(value: Css.Val, priority: number);
        getBaseValue(): CascadeValue;
        filterValue(visitor: Css.Visitor): CascadeValue;
        increaseSpecificity(specificity: number): CascadeValue;
        evaluate(context: Exprs.Context, propName: string): Css.Val;
        isEnabled(context: Exprs.Context): boolean;
    }
    class ConditionalCascadeValue extends CascadeValue {
        readonly condition: Exprs.Val;
        constructor(value: Css.Val, priority: number, condition: Exprs.Val);
        getBaseValue(): CascadeValue;
        filterValue(visitor: Css.Visitor): CascadeValue;
        increaseSpecificity(specificity: number): CascadeValue;
        isEnabled(context: Exprs.Context): boolean;
    }
    function cascadeValues(context: Exprs.Context, tv: CascadeValue, av: CascadeValue): CascadeValue;
    type ElementStyleMap = {
        [key: string]: ElementStyle_$0;
    };
    const SPECIALS: {
        "region-id": boolean;
        "fragment-selector-id": boolean;
    };
    function isSpecialName(name: string): boolean;
    function isMapName(name: string): boolean;
    function isPropName(name: string): boolean;
    function isInherited(name: string): boolean;
    function getProp(style: ElementStyle_$0, name: string): CascadeValue;
    function setProp(style: ElementStyle_$0, name: string, value: CascadeValue): any;
    function getStyleMap(style: ElementStyle_$0, name: string): ElementStyleMap;
    function getMutableStyleMap(style: ElementStyle_$0, name: string): ElementStyleMap;
    const getViewConditionalStyleMap: (style: ElementStyle_$0) => {
        matcher: Matchers.Matcher;
        styles: ElementStyleMap;
    }[];
    function getSpecial(style: ElementStyle_$0, name: string): CascadeValue[];
    function getMutableSpecial(style: ElementStyle_$0, name: string): CascadeValue[];
    function mergeIn(context: Exprs.Context, target: ElementStyle_$0, style: ElementStyle_$0, specificity: number, pseudoelement: string | null, regionId: string | null, viewConditionMatcher: Matchers.Matcher | null): void;
    function mergeAll(context: Exprs.Context, styles: ElementStyle_$0[]): ElementStyle_$0;
    function chainActions(chain: ChainedAction[], action: CascadeAction): CascadeAction;
    class InheritanceVisitor extends Css.FilterVisitor {
        readonly props: ElementStyle_$0;
        readonly context: Exprs.Context;
        propName: string;
        constructor(props: ElementStyle_$0, context: Exprs.Context);
        setPropName(name: string): void;
        private getFontSize;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function convertFontRelativeLengthToPx(numeric: Css.Numeric, baseFontSize: number, context: Exprs.Context): Css.Numeric;
    function convertFontSizeToPx(numeric: Css.Numeric, parentFontSize: number, context: Exprs.Context): Css.Numeric;
    type ActionTable = {
        [key: string]: CascadeAction;
    };
    class CascadeAction {
        apply(cascadeInstance: CascadeInstance): void;
        mergeWith(other: CascadeAction): CascadeAction;
        clone(): CascadeAction;
    }
    class ConditionItemAction extends CascadeAction {
        readonly conditionItem: ConditionItem;
        constructor(conditionItem: ConditionItem);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CompoundAction extends CascadeAction {
        readonly list: CascadeAction[];
        constructor(list: CascadeAction[]);
        apply(cascadeInstance: CascadeInstance): void;
        mergeWith(other: CascadeAction): CascadeAction;
        clone(): CascadeAction;
    }
    class ApplyRuleAction extends CascadeAction {
        readonly style: ElementStyle_$0;
        readonly specificity: number;
        readonly pseudoelement: string | null;
        readonly regionId: string | null;
        readonly viewConditionId: string | null;
        constructor(style: ElementStyle_$0, specificity: number, pseudoelement: string | null, regionId: string | null, viewConditionId: string | null);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class ChainedAction extends CascadeAction {
        chained: CascadeAction;
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckClassAction extends ChainedAction {
        readonly className: string;
        constructor(className: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckIdAction extends ChainedAction {
        readonly id: string;
        constructor(id: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckLocalNameAction extends ChainedAction {
        readonly localName: string;
        constructor(localName: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckNSTagAction extends ChainedAction {
        readonly ns: string;
        readonly localName: string;
        constructor(ns: string, localName: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckTargetEpubTypeAction extends ChainedAction {
        readonly epubTypePatt: RegExp;
        constructor(epubTypePatt: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckNamespaceAction extends ChainedAction {
        readonly ns: string;
        constructor(ns: string);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckAttributePresentAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        constructor(ns: string, name: string);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckAttributeEqAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        readonly value: string;
        constructor(ns: string, name: string, value: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckNamespaceSupportedAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        constructor(ns: string, name: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckAttributeRegExpAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        readonly regexp: RegExp;
        constructor(ns: string, name: string, regexp: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckLangAction extends ChainedAction {
        readonly langRegExp: RegExp;
        constructor(langRegExp: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class IsFirstAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsRootAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthAction extends ChainedAction {
        readonly a: number;
        readonly b: number;
        constructor(a: number, b: number);
        matchANPlusB(order: number): boolean;
    }
    class IsNthSiblingAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthSiblingOfTypeAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthLastSiblingAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthLastSiblingOfTypeAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsEmptyAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsEnabledAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsDisabledAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsCheckedAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class CheckConditionAction extends ChainedAction {
        readonly condition: string;
        constructor(condition: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class CheckAppliedAction extends CascadeAction {
        applied: boolean;
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        clone(): CascadeAction;
    }
    class NegateActionsSet extends ChainedAction {
        checkAppliedAction: CheckAppliedAction;
        firstAction: CascadeAction;
        constructor(list: ChainedAction[]);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    interface ConditionItem {
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AbstractConditionItem {
        readonly condition: string;
        readonly viewConditionId: string | null;
        readonly viewCondition: Matchers.Matcher;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        increment(cascadeInstance: CascadeInstance): void;
        decrement(cascadeInstance: CascadeInstance): void;
        buildViewConditionMatcher(cascadeInstance: CascadeInstance): Matchers.Matcher;
    }
    class DescendantConditionItem extends AbstractConditionItem implements ConditionItem {
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class ChildConditionItem extends AbstractConditionItem implements ConditionItem {
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AdjacentSiblingConditionItem extends AbstractConditionItem implements ConditionItem {
        fired: boolean;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class FollowingSiblingConditionItem extends AbstractConditionItem implements ConditionItem {
        fired: boolean;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AfterPseudoelementItem implements ConditionItem {
        readonly afterprop: ElementStyle_$0;
        readonly element: Element;
        constructor(afterprop: ElementStyle_$0, element: Element);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class RestoreLangItem implements ConditionItem {
        readonly lang: string;
        constructor(lang: string);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class QuotesScopeItem implements ConditionItem {
        readonly oldQuotes: Css.Str[];
        constructor(oldQuotes: Css.Str[]);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    type CounterValues = {
        [key: string]: number[];
    };
    interface CounterListener {
        countersOfId(id: string, counters: CounterValues): any;
        getExprContentListener(): Vtree_$0.ExprContentListener;
    }
    interface CounterResolver {
        getPageCounterVal(name: string, format: (p1: number | null) => string): Exprs.Val;
        getPageCountersVal(name: string, format: (p1: number[]) => string): Exprs.Val;
        getTargetCounterVal(url: string, name: string, format: (p1: number | null) => string): Exprs.Val;
        getTargetCountersVal(url: string, name: string, format: (p1: number[]) => string): Exprs.Val;
        setStyler(styler: any): any;
    }
    class AttrValueFilterVisitor extends Css.FilterVisitor {
        element: Element;
        constructor(element: Element);
        private createValueFromString;
        visitFunc(func: Css.Func): Css.Val;
    }
    class ContentPropVisitor extends Css.FilterVisitor {
        cascade: CascadeInstance;
        element: Element;
        readonly counterResolver: CounterResolver;
        constructor(cascade: CascadeInstance, element: Element, counterResolver: CounterResolver);
        visitIdent(ident: Css.Ident): Css.Val;
        private format;
        visitFuncCounter(values: Css.Val[]): Css.Val;
        visitFuncCounters(values: Css.Val[]): Css.Val;
        visitFuncTargetCounter(values: Css.Val[]): Css.Val;
        visitFuncTargetCounters(values: Css.Val[]): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
    }
    function roman(num: number): string;
    const additiveNumbering: {
        roman: (string | number)[];
        armenian: (string | number)[];
        georgian: (string | number)[];
        hebrew: (string | number)[];
    };
    const alphabeticNumbering: {
        latin: string;
        alpha: string;
        greek: string;
        russian: string;
    };
    const fixed: {
        square: string;
        disc: string;
        circle: string;
        none: string;
    };
    function additiveFormat(entries: any[], num: number): string;
    function expandAlphabet(str: string): string[] | null;
    function alphabeticFormat(alphabetStr: string, num: number): string;
    type ChineseNumbering = {
        digits: string;
        markers: string;
        negative: string;
        formal: boolean;
    };
    const chineseTradInformal: ChineseNumbering;
    function chineseCounter(num: number, numbering: ChineseNumbering): string;
    const ORDER_INCREMENT: number;
    function copyTable(src: ActionTable, dst: ActionTable): void;
    class Cascade {
        nsCount: number;
        nsPrefix: {
            [key: string]: string;
        };
        tags: ActionTable;
        nstags: ActionTable;
        epubtypes: ActionTable;
        classes: ActionTable;
        ids: ActionTable;
        pagetypes: ActionTable;
        order: number;
        clone(): Cascade;
        insertInTable(table: ActionTable, key: string, action: CascadeAction): void;
        createInstance(context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: any): CascadeInstance;
        nextOrder(): number;
    }
    class CascadeInstance {
        readonly context: Exprs.Context;
        readonly counterListener: CounterListener;
        readonly counterResolver: CounterResolver;
        code: Cascade;
        stack: ConditionItem[][];
        conditions: {
            [key: string]: number;
        };
        currentElement: Element | null;
        currentElementOffset: number | null;
        currentStyle: ElementStyle_$0 | null;
        currentClassNames: string[] | null;
        currentLocalName: string;
        currentNamespace: string;
        currentId: string;
        currentXmlId: string;
        currentNSTag: string;
        currentEpubTypes: string[] | null;
        currentPageType: string | null;
        isFirst: boolean;
        isRoot: boolean;
        counters: {
            [key: string]: number[];
        };
        counterScoping: {
            [key: string]: boolean;
        }[];
        quotes: Css.Str[];
        quoteDepth: number;
        lang: string;
        siblingOrderStack: number[];
        currentSiblingOrder: number;
        siblingTypeCountsStack: {
            [key: string]: {
                [key: string]: number;
            };
        }[];
        currentSiblingTypeCounts: {
            [key: string]: {
                [key: string]: number;
            };
        };
        currentFollowingSiblingOrder: number | null;
        followingSiblingOrderStack: (number | null)[];
        followingSiblingTypeCountsStack: {
            [key: string]: {
                [key: string]: number;
            };
        }[];
        currentFollowingSiblingTypeCounts: {
            [key: string]: {
                [key: string]: number;
            };
        };
        viewConditions: {
            [key: string]: Matchers.Matcher[];
        };
        dependentConditions: string[];
        elementStack: Element[];
        currentDoc?: Document | null;
        constructor(cascade: Cascade, context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: string);
        pushConditionItem(item: ConditionItem): void;
        increment(condition: string, viewCondition: Matchers.Matcher): void;
        decrement(condition: string, viewCondition: Matchers.Matcher): void;
        buildViewConditionMatcher(viewConditionId: string | null): Matchers.Matcher;
        applyAction(table: ActionTable, key: string): void;
        pushRule(classes: string[], pageType: string | null, baseStyle: ElementStyle_$0): void;
        defineCounter(counterName: string, value: number): void;
        pushCounters(props: ElementStyle_$0): void;
        popCounters(): void;
        processPseudoelementProps(pseudoprops: ElementStyle_$0, element: Element): void;
        pushElement(element: Element, baseStyle: ElementStyle_$0, elementOffset: number): void;
        private applyAttrFilterInner;
        private applyAttrFilter;
        private applyActions;
        private pop;
        popRule(): void;
        popElement(element: Element): void;
    }
    const EMPTY: any[];
    const pseudoNames: string[];
    enum ParseState {
        TOP = 0,
        SELECTOR = 1,
        RULE = 2
    }
    let uaBaseCascade: Cascade;
    function setUABaseCascade(value: Cascade): void;
    class CascadeParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
        readonly condition: Exprs.Val;
        readonly regionId: string | null;
        readonly validatorSet: CssValidator.ValidatorSet;
        chain: ChainedAction[];
        specificity: number;
        elementStyle: ElementStyle_$0;
        conditionCount: number;
        pseudoelement: string | null;
        footnoteContent: boolean;
        cascade: Cascade;
        state: ParseState;
        viewConditionId: string | null;
        insideSelectorRule: ParseState;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, condition: Exprs.Val, parent: CascadeParserHandler, regionId: string | null, validatorSet: CssValidator.ValidatorSet, topLevel: boolean);
        insertNonPrimary(action: CascadeAction): void;
        processChain(action: CascadeAction): void;
        isInsideSelectorRule(mnemonics: string): boolean;
        tagSelector(ns: string | null, name: string | null): void;
        classSelector(name: string): void;
        pseudoclassSelector(name: string, params: (number | string)[]): void;
        pseudoelementSelector(name: string, params: (number | string)[]): void;
        idSelector(id: string): void;
        attributeSelector(ns: string, name: string, op: CssTokenizer.TokenType, value: string | null): void;
        descendantSelector(): void;
        childSelector(): void;
        adjacentSiblingSelector(): void;
        followingSiblingSelector(): void;
        nextSelector(): void;
        startSelectorRule(): void;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        startStylesheet(flavor: CssParser.StylesheetFlavor): void;
        startRuleBody(): void;
        endRule(): void;
        finishChain(): void;
        makeApplyRuleAction(specificity: number): ApplyRuleAction;
        special(name: string, value: Css.Val): void;
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
        finish(): Cascade;
        startFuncWithSelector(funcName: string): void;
    }
    const nthSelectorActionClasses: {
        [key: string]: typeof IsNthAction;
    };
    let conditionCount: number;
    class NotParameterParserHandler extends CascadeParserHandler {
        readonly parent: CascadeParserHandler;
        parentChain: ChainedAction[];
        constructor(parent: CascadeParserHandler);
        startFuncWithSelector(funcName: string): void;
        startRuleBody(): void;
        nextSelector(): void;
        endFuncWithSelector(): void;
        error(mnemonics: string, token: CssTokenizer.Token): void;
    }
    class DefineParserHandler extends CssParser.SlaveParserHandler {
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler);
        property(name: string, value: Css.Val, important: boolean): void;
    }
    class PropSetParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
        readonly condition: Exprs.Val;
        readonly elementStyle: ElementStyle_$0;
        readonly validatorSet: CssValidator.ValidatorSet;
        order: number;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, condition: Exprs.Val, elementStyle: ElementStyle_$0, validatorSet: CssValidator.ValidatorSet);
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    class PropertyParserHandler extends CssParser.ErrorHandler implements CssValidator.PropertyReceiver {
        readonly validatorSet: CssValidator.ValidatorSet;
        elementStyle: ElementStyle_$0;
        order: number;
        constructor(scope: Exprs.LexicalScope, validatorSet: CssValidator.ValidatorSet);
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    function forEachViewConditionalStyles(style: ElementStyle_$0, callback: (p1: ElementStyle_$0) => any): void;
    function mergeViewConditionalStyles(cascMap: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, style: ElementStyle_$0): void;
    function parseStyleAttribute_$0(scope: Exprs.LexicalScope, validatorSet: CssValidator.ValidatorSet, baseURL: string, styleAttrValue: string): ElementStyle_$0;
    function isVertical(cascaded: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, vertical: boolean): boolean;
    function isRtl(cascaded: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, rtl: boolean): boolean;
    function flattenCascadedStyle(style: ElementStyle_$0, context: Exprs.Context, regionIds: string[], isFootnote: boolean, nodeContext: Vtree_$0.NodeContext): {
        [key: string]: CascadeValue;
    };
    function forEachStylesInRegion(style: ElementStyle_$0, regionIds: string[], isFootnote: boolean, callback: (p1: string, p2: ElementStyle_$0) => any): void;
    function mergeStyle(to: {
        [key: string]: CascadeValue;
    }, from: ElementStyle_$0, context: Exprs.Context): void;
    const convertToPhysical: <T>(src: {
        [key: string]: CascadeValue;
    }, dest: {
        [key: string]: T;
    }, vertical: boolean, rtl: boolean, transform: (p1: string, p2: CascadeValue) => T) => void;
}
declare namespace CssStyler_$0 {
    class SlipRange {
        endStuckFixed: number;
        endFixed: number;
        endSlipped: number;
        constructor(endStuckFixed: any, endFixed: any, endSlipped: any);
    }
    class SlipMap {
        map: SlipRange[];
        getMaxFixed(): number;
        getMaxSlipped(): number;
        addStuckRange(endFixed: number): void;
        addSlippedRange(endFixed: number): void;
        slippedByFixed(fixed: number): number;
        fixedBySlipped(slipped: number): number;
    }
    interface FlowListener {
        encounteredFlowChunk(flowChunk: Vtree_$0.FlowChunk, flow: Vtree_$0.Flow): any;
    }
    interface AbstractStyler_$0 extends CssStyler.AbstractStyler_$0 {
    }
    class Box {
        readonly context: Exprs.Context;
        readonly style: CssCascade_$0.ElementStyle;
        readonly offset: number;
        readonly isRoot: boolean;
        readonly flowChunk: Vtree_$0.FlowChunk;
        readonly atBlockStart: boolean;
        readonly atFlowStart: boolean;
        readonly isParentBoxDisplayed: boolean;
        flowName: string;
        isBlockValue: boolean | null;
        hasBoxValue: boolean | null;
        styleValues: {
            [key: string]: Css.Val;
        };
        beforeBox: Box;
        afterBox: Box;
        breakBefore: string | null;
        constructor(context: Exprs.Context, style: CssCascade_$0.ElementStyle, offset: number, isRoot: boolean, flowChunk: Vtree_$0.FlowChunk, atBlockStart: boolean, atFlowStart: boolean, isParentBoxDisplayed: boolean);
        buildAfterPseudoElementBox(offset: number, atBlockStart: boolean, atFlowStart: boolean): void;
        styleValue(name: string, defaultValue?: Css.Val): Css.Val | null;
        displayValue(): Css.Val;
        isBlock(): boolean;
        hasBox(): boolean;
        getBreakValue(edge: string): string | null;
    }
    class BoxStack {
        readonly context: Exprs.Context;
        stack: Box[];
        atBlockStart: boolean;
        atFlowStart: boolean;
        atStartStack: {
            atBlockStart: boolean;
            atFlowStart: boolean;
        }[];
        constructor(context: Exprs.Context);
        empty(): boolean;
        lastBox(): Box | undefined;
        lastFlowName(): string | null;
        isCurrentBoxDisplayed(): boolean;
        push(style: CssCascade_$0.ElementStyle, offset: number, isRoot: boolean, newFlowChunk?: Vtree_$0.FlowChunk): Box;
        encounteredTextNode(node: Node): void;
        pop(offset: number): Box;
        nearestBlockStartOffset(box: Box): number;
    }
    class Styler implements AbstractStyler_$0 {
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly scope: Exprs.LexicalScope;
        readonly context: Exprs.Context;
        readonly primaryFlows: {
            [key: string]: boolean;
        };
        readonly validatorSet: CssValidator.ValidatorSet;
        readonly counterListener: CssCascade_$0.CounterListener;
        root: Element;
        cascadeHolder: CssCascade_$0.Cascade;
        last: Node;
        rootStyle: CssCascade_$0.ElementStyle;
        styleMap: {
            [key: string]: CssCascade_$0.ElementStyle;
        };
        flows: {
            [key: string]: Vtree_$0.Flow;
        };
        flowChunks: Vtree_$0.FlowChunk[];
        flowListener: FlowListener;
        flowToReach: string | null;
        idToReach: string | null;
        cascade: CssCascade_$0.CascadeInstance;
        offsetMap: SlipMap;
        primary: boolean;
        primaryStack: boolean[];
        rootBackgroundAssigned: boolean;
        rootLayoutAssigned: boolean;
        lastOffset: number;
        breakBeforeValues: {
            [key: number]: string;
        };
        boxStack: BoxStack;
        bodyReached: boolean;
        constructor(xmldoc: XmlDoc.XMLDocHolder, cascade: CssCascade_$0.Cascade, scope: Exprs.LexicalScope, context: Exprs.Context, primaryFlows: {
            [key: string]: boolean;
        }, validatorSet: CssValidator.ValidatorSet, counterListener: CssCascade_$0.CounterListener, counterResolver: CssCascade_$0.CounterResolver);
        hasProp(style: CssCascade_$0.ElementStyle, map: CssValidator.ValueMap, name: string): boolean;
        transferPropsToRoot(srcStyle: CssCascade_$0.ElementStyle, map: CssValidator.ValueMap): void;
        postprocessTopStyle(elemStyle: CssCascade_$0.ElementStyle, isBody: boolean): void;
        getTopContainerStyle(): CssCascade_$0.ElementStyle;
        getAttrStyle(elem: Element): CssCascade_$0.ElementStyle;
        getReachedOffset(): number;
        replayFlowElementsFromOffset(offset: number): void;
        resetFlowChunkStream(flowListener: FlowListener): void;
        styleUntilFlowIsReached(flowName: string): void;
        styleUntilIdIsReached(id: string): void;
        private encounteredFlowElement;
        registerForcedBreakOffset(breakValue: string | null, offset: number, flowName: string): void;
        styleUntil(startOffset: number, lookup: number): number;
        getStyle(element: Element, deep: boolean): CssCascade_$0.ElementStyle;
        processContent(element: Element, styles: {
            [key: string]: Css.Val;
        }): void;
    }
    const columnProps: string[];
}
declare namespace Exprs {
    type Preferences = {
        fontFamily: string;
        lineHeight: number;
        margin: number;
        hyphenate: boolean;
        columnWidth: number;
        horizontal: boolean;
        nightMode: boolean;
        spreadView: boolean;
        pageBorder: number;
        enabledMediaTypes: {
            [key: string]: boolean;
        };
        defaultPaperSize?: {
            [key: string]: number;
        };
    };
    function defaultPreferences(): Preferences;
    function clonePreferences(pref: Preferences): Preferences;
    const defaultPreferencesInstance: Preferences;
    const Special: {
        PENDING: Pending;
    };
    type Result = string | number | boolean | undefined;
    type PendingResult = Special | Result;
    function letterbox(viewW: number, viewH: number, objW: number, objH: number): string;
    function cssString(str: string): string;
    function cssIdent(name: string): string;
    function makeQualifiedName(objName: string | null, memberName: string): string;
    let nextKeyIndex: number;
    class LexicalScope {
        parent: LexicalScope;
        resolver?: (p1: string, p2: boolean) => Val;
        scopeKey: string;
        children: LexicalScope[];
        zero: Const;
        one: Const;
        _true: Const;
        _false: Const;
        values: {
            [key: string]: Val;
        };
        funcs: {
            [key: string]: Val;
        };
        builtIns: {
            [key: string]: (...p1: Result[]) => Result;
        };
        constructor(parent: LexicalScope, resolver?: (p1: string, p2: boolean) => Val);
        defineBuiltInName(name: string, fn: () => Result): void;
        defineName(qualifiedName: string, val: Val): void;
        defineFunc(qualifiedName: string, val: Val): void;
        defineBuiltIn(qualifiedName: string, fn: (...p1: Result[]) => Result): void;
    }
    function isAbsoluteLengthUnit(unit: string): boolean;
    function isViewportRelativeLengthUnit(unit: string): boolean;
    function isFontRelativeLengthUnit(unit: string): boolean;
    const defaultUnitSizes: {
        [key: string]: number;
    };
    function needUnitConversion(unit: string): boolean;
    type ScopeContext = {
        [key: string]: Result;
    };
    class Context {
        readonly rootScope: LexicalScope;
        readonly viewportWidth: number;
        readonly viewportHeight: number;
        protected actualPageWidth: number | null;
        pageWidth: () => number;
        protected actualPageHeight: number | null;
        pageHeight: () => number;
        initialFontSize: number;
        rootFontSize: number | null;
        fontSize: () => number;
        pref: Preferences;
        scopes: {
            [key: string]: ScopeContext;
        };
        pageAreaWidth: number | null;
        pageAreaHeight: number | null;
        pageVertical: boolean | null;
        pubTitle: string | null;
        docTitle: string | null;
        constructor(rootScope: LexicalScope, viewportWidth: number, viewportHeight: number, fontSize: number);
        private getScopeContext;
        clearScope(scope: LexicalScope): void;
        queryUnitSize(unit: string, isRoot: boolean): number;
        evalName(scope: LexicalScope, qualifiedName: string): Val;
        evalCall(scope: LexicalScope, qualifiedName: string, params: Val[], noBuiltInEval: boolean): Val;
        evalMediaName(name: string, not: boolean): boolean;
        evalMediaTest(feature: string, value: Val): boolean;
        queryVal(scope: LexicalScope, key: string): Result | undefined;
        storeVal(scope: LexicalScope, key: string, val: Result): void;
    }
    type DependencyCache = {
        [key: string]: boolean | Special;
    };
    class Val {
        scope: LexicalScope;
        key: string;
        constructor(scope: LexicalScope);
        toString(): string;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        expand(context: Context, params: Val[]): Val;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        dependOuter(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        depend(other: Val, context: Context): boolean;
        evaluate(context: Context): Result;
        isMediaName(): boolean;
    }
    class Prefix extends Val {
        val: Val;
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Infix extends Val {
        lhs: Val;
        rhs: Val;
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Logical extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Comparison extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Additive extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Multiplicative extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Not extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class Negate extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class And extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class AndMedia extends And {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Or extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class OrMedia extends Or {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Lt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Le extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Gt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ge extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Eq extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ne extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Add extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Subtract extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Multiply extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Divide extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Modulo extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Numeric extends Val {
        num: number;
        unit: string;
        constructor(scope: LexicalScope, num: number, unit: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class Named extends Val {
        qualifiedName: string;
        constructor(scope: LexicalScope, qualifiedName: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    }
    class MediaName extends Val {
        not: boolean;
        name: string;
        value: Val;
        constructor(scope: LexicalScope, not: boolean, name: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        isMediaName(): boolean;
    }
    class Native extends Val {
        fn: () => Result;
        str: string;
        constructor(scope: LexicalScope, fn: () => Result, str: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    function appendValArray(buf: Base.StringBuffer, arr: Val[]): void;
    function expandValArray(context: Context, arr: Val[], params: Val[]): Val[];
    function evalValArray(context: Context, arr: Val[]): Result[];
    class Call extends Val {
        qualifiedName: string;
        params: Val[];
        constructor(scope: LexicalScope, qualifiedName: string, params: Val[]);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Cond extends Val {
        cond: Val;
        ifTrue: Val;
        ifFalse: Val;
        constructor(scope: LexicalScope, cond: Val, ifTrue: Val, ifFalse: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Const extends Val {
        val: Result;
        constructor(scope: LexicalScope, val: Result);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class MediaTest extends Val {
        name: MediaName;
        value: Val;
        constructor(scope: LexicalScope, name: MediaName, value: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Param extends Val {
        index: number;
        constructor(scope: LexicalScope, index: number);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    function and(scope: LexicalScope, v1: Val, v2: Val): Val;
    function add(scope: LexicalScope, v1: Val, v2: Val): Val;
    function sub(scope: LexicalScope, v1: Val, v2: Val): Val;
    function mul(scope: LexicalScope, v1: Val, v2: Val): Val;
    function div(scope: LexicalScope, v1: Val, v2: Val): Val;
}
declare namespace Vtree_$0 {
    const delayedProps: {
        transform: boolean;
        "transform-origin": boolean;
    };
    const delayedPropsIfRelativePositioned: {
        top: boolean;
        bottom: boolean;
        left: boolean;
        right: boolean;
    };
    class DelayedItem {
        target: Element;
        name: string;
        value: Css.Val;
        constructor(target: Element, name: string, value: Css.Val);
    }
    type PageHyperlinkEvent = {
        type: string;
        target: any;
        currentTarget: any;
        anchorElement: Element;
        href: string;
    };
    type Trigger = {
        observer: string;
        event: string;
        action: string;
        ref: string;
    };
    const actions: {
        show: (obj: any) => void;
        hide: (obj: any) => void;
        play: (obj: any) => void;
        pause: (obj: any) => void;
        resume: (obj: any) => void;
        mute: (obj: any) => void;
        unmute: (obj: any) => void;
    };
    function makeListener(refs: Element[], action: string): EventListener | null;
    class Page extends Base.SimpleEventTarget {
        readonly container: HTMLElement;
        readonly bleedBox: HTMLElement;
        private static AUTO_PAGE_WIDTH_ATTRIBUTE;
        private static AUTO_PAGE_HEIGHT_ATTRIBUTE;
        pageAreaElement: HTMLElement | null;
        delayedItems: DelayedItem[];
        hrefHandler: (e: Event) => void;
        elementsById: {
            [key: string]: Element[];
        };
        dimensions: {
            width: number;
            height: number;
        };
        isFirstPage: boolean;
        isLastPage: boolean;
        isAutoPageWidth: boolean;
        isAutoPageHeight: boolean;
        spineIndex: number;
        position: LayoutPosition;
        offset: number;
        side: Constants.PageSide | null;
        fetchers: TaskUtil.Fetcher<{}>[];
        marginBoxes: {
            top: {
                [key: string]: Container_$0;
            };
            bottom: {
                [key: string]: Container_$0;
            };
            left: {
                [key: string]: Container_$0;
            };
            right: {
                [key: string]: Container_$0;
            };
        };
        constructor(container: HTMLElement, bleedBox: HTMLElement);
        setAutoPageWidth(isAuto: boolean): void;
        setAutoPageHeight(isAuto: boolean): void;
        registerElementWithId(element: Element, id: string): void;
        finish(triggers: Trigger[], clientLayout: ClientLayout_$0): void;
        zoom(scale: number): void;
        getPageAreaElement(): HTMLElement;
    }
    type Spread = {
        left: Page;
        right: Page;
    };
    const SPECIAL_ATTR = "data-adapt-spec";
    const Whitespace_$0: typeof Vtree.Whitespace_$0;
    type Whitespace_$0 = Vtree.Whitespace_$0;
    function whitespaceFromPropertyValue(whitespace: string): Whitespace_$0 | null;
    function canIgnore(node: Node, whitespace: Whitespace_$0): boolean;
    class Flow {
        readonly flowName: string;
        readonly parentFlowName: string | null;
        forcedBreakOffsets: number[];
        formattingContext: FormattingContext_$0 | null;
        constructor(flowName: string, parentFlowName: string | null);
    }
    class FlowChunk {
        flowName: string;
        element: Element;
        startOffset: number;
        priority: number;
        linger: number;
        exclusive: boolean;
        repeated: boolean;
        last: boolean;
        breakBefore: string | null;
        startPage: number;
        constructor(flowName: string, element: Element, startOffset: number, priority: number, linger: number, exclusive: boolean, repeated: boolean, last: boolean, breakBefore: string | null);
        isBetter(other: FlowChunk): boolean;
    }
    type ClientRect_$0 = Vtree.ClientRect_$0;
    function clientrectIncreasingTop(r1: ClientRect_$0, r2: ClientRect_$0): number;
    function clientrectDecreasingRight(r1: ClientRect_$0, r2: ClientRect_$0): number;
    type ClientLayout_$0 = Vtree.ClientLayout_$0;
    type LayoutContext_$0 = Vtree.LayoutContext_$0;
    type FormattingContext_$0 = Vtree.FormattingContext_$0;
    function eachAncestorFormattingContext(nodeContext: NodeContext_$0, callback: (p1: FormattingContext_$0) => any): void;
    type NodePositionStep_$0 = Vtree.NodePositionStep_$0;
    function isSameNodePositionStep(nps1: NodePositionStep_$0, nps2: NodePositionStep_$0): boolean;
    type NodePosition_$0 = Vtree.NodePosition_$0;
    function isSameNodePosition(np1: NodePosition_$0 | null, np2: NodePosition_$0 | null): boolean;
    function newNodePositionFromNode(node: Node): NodePosition_$0;
    function newNodePositionFromNodeContext(nodeContext: Vtree.NodeContext_$0, initialFragmentIndex: number | null): NodePosition_$0;
    function makeNodeContextFromNodePositionStep(step: NodePositionStep_$0, parent: Vtree.NodeContext_$0): NodeContext_$0;
    const ShadowType_$0: typeof Vtree.ShadowType_$0;
    type ShadowType_$0 = Vtree.ShadowType_$0;
    class ShadowContext_$0 implements Vtree.ShadowContext_$0 {
        readonly owner: Element;
        readonly root: Element;
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly parentShadow: ShadowContext_$0;
        readonly type: ShadowType_$0;
        readonly styler: object;
        subShadow: ShadowContext_$0;
        constructor(owner: Element, root: Element, xmldoc: XmlDoc.XMLDocHolder, parentShadow: ShadowContext_$0, superShadow: ShadowContext_$0, type: ShadowType_$0, styler: object);
        equals(other: ShadowContext_$0): boolean;
    }
    function isSameShadowContext(sc1: ShadowContext_$0, sc2: ShadowContext_$0): boolean;
    class FirstPseudo_$0 implements Vtree.FirstPseudo_$0 {
        readonly outer: FirstPseudo_$0;
        readonly count: number;
        constructor(outer: FirstPseudo_$0, count: number);
    }
    class NodeContext_$0 implements Vtree.NodeContext_$0 {
        sourceNode: Node;
        parent: NodeContext_$0;
        boxOffset: number;
        offsetInNode: number;
        after: boolean;
        shadowType: ShadowType_$0;
        shadowContext: ShadowContext_$0;
        nodeShadow: ShadowContext_$0;
        shadowSibling: NodeContext_$0;
        shared: boolean;
        inline: boolean;
        overflow: boolean;
        breakPenalty: number;
        display: string | null;
        floatReference: PageFloats.FloatReference;
        floatSide: string | null;
        clearSide: string | null;
        floatMinWrapBlock: Css.Numeric | null;
        columnSpan: Css.Val | null;
        verticalAlign: string;
        captionSide: string;
        inlineBorderSpacing: number;
        blockBorderSpacing: number;
        flexContainer: boolean;
        whitespace: Whitespace_$0;
        hyphenateCharacter: string | null;
        breakWord: boolean;
        establishesBFC: boolean;
        containingBlockForAbsolute: boolean;
        breakBefore: string | null;
        breakAfter: string | null;
        viewNode: Node;
        clearSpacer: Node;
        inheritedProps: {
            [key: string]: number | string | Css.Val;
        };
        vertical: boolean;
        direction: string;
        firstPseudo: FirstPseudo_$0;
        lang: string | null;
        preprocessedTextContent: Diff.Change[] | null;
        formattingContext: FormattingContext_$0;
        repeatOnBreak: string | null;
        pluginProps: {
            [key: string]: string | number | undefined | null | (number | null)[];
        };
        fragmentIndex: number;
        afterIfContinues: Selectors.AfterIfContinues;
        footnotePolicy: Css.Ident | null;
        constructor(sourceNode: Node, parent: NodeContext_$0, boxOffset: number);
        resetView(): void;
        private cloneItem;
        modify(): NodeContext_$0;
        copy(): NodeContext_$0;
        clone(): NodeContext_$0;
        toNodePositionStep(): NodePositionStep_$0;
        toNodePosition(): NodePosition_$0;
        isInsideBFC(): boolean;
        getContainingBlockForAbsolute(): NodeContext_$0;
        walkUpBlocks(callback: (p1: NodeContext_$0) => any): void;
        belongsTo(formattingContext: FormattingContext_$0): boolean;
    }
    class ChunkPosition_$0 implements Vtree.ChunkPosition_$0 {
        primary: NodePosition_$0;
        floats: NodePosition_$0[];
        constructor(primary: NodePosition_$0);
        clone(): ChunkPosition_$0;
        isSamePosition(other: ChunkPosition_$0): boolean;
    }
    class FlowChunkPosition {
        chunkPosition: ChunkPosition_$0;
        readonly flowChunk: FlowChunk;
        constructor(chunkPosition: ChunkPosition_$0, flowChunk: FlowChunk);
        clone(): FlowChunkPosition;
        isSamePosition(other: FlowChunkPosition): boolean;
    }
    class FlowPosition {
        positions: FlowChunkPosition[];
        startSide: string;
        breakAfter: string | null;
        clone(): FlowPosition;
        isSamePosition(other: FlowPosition): boolean;
        hasContent(offset: number): boolean;
    }
    class LayoutPosition {
        page: number;
        flows: {
            [key: string]: Flow;
        };
        flowPositions: {
            [key: string]: FlowPosition;
        };
        highestSeenOffset: number;
        highestSeenNode: Node;
        lookupPositionOffset: number;
        clone(): LayoutPosition;
        isSamePosition(other: LayoutPosition): boolean;
        hasContent(name: string, offset: number): boolean;
        startSideOfFlow(name: string): string;
        firstFlowChunkOfFlow(name: string): FlowChunk | null;
    }
    class Container_$0 implements Vtree.Container_$0 {
        element: Element;
        left: number;
        top: number;
        marginLeft: number;
        marginRight: number;
        marginTop: number;
        marginBottom: number;
        borderLeft: number;
        borderRight: number;
        borderTop: number;
        borderBottom: number;
        paddingLeft: number;
        paddingRight: number;
        paddingTop: number;
        paddingBottom: number;
        width: number;
        height: number;
        originX: number;
        originY: number;
        exclusions: GeometryUtil.Shape[];
        innerShape: GeometryUtil.Shape;
        computedBlockSize: number;
        snapWidth: number;
        snapHeight: number;
        snapOffsetX: number;
        snapOffsetY: number;
        vertical: boolean;
        constructor(element: Element);
        getInsetTop(): number;
        getInsetBottom(): number;
        getInsetLeft(): number;
        getInsetRight(): number;
        getInsetBefore(): number;
        getInsetAfter(): number;
        getInsetStart(): number;
        getInsetEnd(): number;
        getBeforeEdge(box: ClientRect_$0): number;
        getAfterEdge(box: ClientRect_$0): number;
        getStartEdge(box: ClientRect_$0): number;
        getEndEdge(box: ClientRect_$0): number;
        getInlineSize(box: ClientRect_$0): number;
        getBoxSize(box: ClientRect_$0): number;
        getBoxDir(): number;
        getInlineDir(): number;
        copyFrom(other: Container_$0): void;
        setVerticalPosition(top: number, height: number): void;
        setHorizontalPosition(left: number, width: number): void;
        setBlockPosition(start: number, extent: number): void;
        setInlinePosition(start: number, extent: number): void;
        clear(): void;
        getInnerShape(): GeometryUtil.Shape;
        getInnerRect(): GeometryUtil.Rect;
        getPaddingRect(): GeometryUtil.Rect;
        getOuterShape(outerShapeProp: Css.Val, context: Exprs.Context): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
    }
    type ExprContentListener_$0 = Vtree.ExprContentListener_$0;
    class ContentPropertyHandler extends Css.Visitor {
        readonly elem: Element;
        readonly context: Exprs.Context;
        readonly rootContentValue: Css.Val;
        readonly exprContentListener: ExprContentListener_$0;
        constructor(elem: Element, context: Exprs.Context, rootContentValue: Css.Val, exprContentListener: ExprContentListener_$0);
        private visitStrInner;
        visitStr(str: Css.Str): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function nonTrivialContent(val: Css.Val): boolean;
}
declare namespace LayoutRetryers {
    abstract class AbstractLayoutRetryer {
        initialBreakPositions: Layout.BreakPosition[];
        initialStateOfFormattingContext: Vtree.NodeContext;
        initialPosition: Vtree.NodeContext;
        initialFragmentLayoutConstraints: Layout.FragmentLayoutConstraint[];
        layout(nodeContext: Vtree.NodeContext, column: Layout.Column): Task.Result<Vtree.NodeContext>;
        private tryLayout;
        resolveLayoutMode(nodeContext: Vtree.NodeContext): Layout.LayoutMode;
        prepareLayout(nodeContext: Vtree.NodeContext, column: Layout.Column): void;
        clearNodes(initialPosition: Vtree.NodeContext): void;
        saveState(nodeContext: Vtree.NodeContext, column: Layout.Column): void;
        restoreState(nodeContext: Vtree.NodeContext, column: Layout.Column): void;
    }
}
declare namespace BreakPosition_$0 {
    type BreakPosition_$0 = Layout.BreakPosition_$0;
    abstract class AbstractBreakPosition_$0 implements Layout.AbstractBreakPosition_$0 {
        findAcceptableBreak(column: Layout.Column, penalty: number): Vtree.NodeContext;
        getMinBreakPenalty(): number;
        calculateOffset(column: any): {
            current: number;
            minimum: number;
        };
        breakPositionChosen(column: Layout.Column): void;
        getNodeContext(): Vtree.NodeContext;
    }
    function calculateOffset(nodeContext: Vtree.NodeContext, elementsOffsets: RepetitiveElement.ElementsOffset[]): {
        current: number;
        minimum: number;
    };
    class EdgeBreakPosition_$0 extends AbstractBreakPosition_$0 implements Layout.EdgeBreakPosition_$0 {
        readonly position: Vtree.NodeContext;
        readonly breakOnEdge: string | null;
        overflows: boolean;
        readonly computedBlockSize: number;
        overflowIfRepetitiveElementsDropped: boolean;
        protected isEdgeUpdated: boolean;
        private edge;
        constructor(position: Vtree.NodeContext, breakOnEdge: string | null, overflows: boolean, computedBlockSize: number);
        findAcceptableBreak(column: Layout.Column, penalty: number): Vtree.NodeContext;
        getMinBreakPenalty(): number;
        private updateEdge;
        private updateOverflows;
        getNodeContext(): Vtree.NodeContext;
        private isFirstContentOfRepetitiveElementsOwner;
    }
}
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace GeometryUtil {
    class Rect {
        x1: number;
        y1: number;
        x2: number;
        y2: number;
        constructor(x1: number, y1: number, x2: number, y2: number);
    }
    class Point {
        x: number;
        y: number;
        constructor(x: number, y: number);
    }
    class Insets {
        left: number;
        top: number;
        right: number;
        bottom: number;
        constructor(left: number, top: number, right: number, bottom: number);
    }
    class Segment {
        low: Point;
        high: Point;
        winding: number;
        shapeId: number;
        constructor(low: Point, high: Point, winding: number, shapeId: number);
    }
    class Band {
        y1: number;
        y2: number;
        x1: number;
        x2: number;
        left: Element | null;
        right: Element | null;
        constructor(y1: number, y2: number, x1: number, x2: number);
    }
    function segmentCompare(s1: Segment, s2: Segment): number;
    class Shape {
        points: Point[];
        constructor(points: Point[]);
        addSegments(arr: Segment[], id: number): void;
        withOffset(offsetX: number, offsetY: number): Shape;
    }
    function shapeForEllipse(cx: number, cy: number, rx: number, ry: number): Shape;
    function shapeForRect(x1: number, y1: number, x2: number, y2: number): Shape;
    function shapeForRectObj(r: Rect): Shape;
    class BandIntersection {
        x: number;
        winding: number;
        shapeId: number;
        lowOrHigh: number;
        constructor(x: number, winding: number, shapeId: number, lowOrHigh: number);
    }
    function intersectY(s: Segment, y: number): number;
    function addBandIntersections(intersections: BandIntersection[], s: Segment, y1: number, y2: number): void;
    function mergeIntersections(intersections: BandIntersection[], includeCount: number, excludeCount: number): number[];
    function ceil(v: number, unit: number): number;
    function floor(v: number, unit: number): number;
    function rotatePoint(point: Point): Point;
    function rotateBox(box: Rect): Rect;
    function unrotateBox(box: Rect): Rect;
    function rotateShape(shape: Shape): Shape;
    function shapesToBands(box: Rect, include: Shape[], exclude: Shape[], granularity: number, snapHeight: number, vertical: boolean): Band[];
    function normalize(box: Rect, bands: Band[]): void;
    function findBand(bands: Band[], y: number): number;
    function findUppermostFullyOpenRect(bands: Band[], rect: Rect): Rect | null;
    function findBottommostFullyOpenRect(bands: Band[], rect: Rect): Rect | null;
    function positionFloat(box: Rect, bands: Band[], floatBox: Rect, side: string): boolean;
    function addFloatToBands(box: Rect, bands: Band[], floatBox: Rect, floatBands: Band[], side: string): void;
}
declare namespace PageFloats_$0 {
    const FloatReference_$0: typeof PageFloats.FloatReference_$0;
    type FloatReference_$0 = PageFloats.FloatReference_$0;
    function floatReferenceOf(str: string): FloatReference_$0;
    function isPageFloat(floatReference: FloatReference_$0): boolean;
    function resolveInlineFloatDirection(floatSide: string, vertical: boolean, direction: string): string;
    class PageFloat_$0 implements PageFloats.PageFloat_$0 {
        readonly nodePosition: Vtree.NodePosition;
        readonly floatReference: FloatReference_$0;
        readonly floatSide: string;
        readonly clearSide: string | null;
        readonly flowName: string;
        readonly floatMinWrapBlock: Css.Numeric | null;
        order: number | null;
        id: PageFloatID_$0 | null;
        constructor(nodePosition: Vtree.NodePosition, floatReference: FloatReference_$0, floatSide: string, clearSide: string | null, flowName: string, floatMinWrapBlock: Css.Numeric | null);
        getOrder(): number;
        getId(): PageFloatID_$0;
        isAllowedOnContext(pageFloatLayoutContext: PageFloatLayoutContext_$0): boolean;
        isAllowedToPrecede(other: PageFloat_$0): boolean;
    }
    class PageFloatStore {
        private floats;
        private nextPageFloatIndex;
        private nextOrder;
        private createPageFloatId;
        addPageFloat(float: PageFloat_$0): void;
        findPageFloatByNodePosition(nodePosition: Vtree.NodePosition): PageFloat_$0 | null;
        findPageFloatById(id: PageFloatID_$0): PageFloat_$0;
    }
    class PageFloatFragment_$0 implements PageFloats.PageFloatFragment_$0 {
        readonly floatReference: FloatReference_$0;
        readonly floatSide: string;
        readonly continuations: PageFloatContinuation_$0[];
        readonly area: Vtree.Container;
        readonly continues: boolean;
        constructor(floatReference: FloatReference_$0, floatSide: string, continuations: PageFloatContinuation_$0[], area: Vtree.Container, continues: boolean);
        hasFloat(float: PageFloat_$0): boolean;
        findNotAllowedFloat(context: PageFloatLayoutContext_$0): PageFloat_$0 | null;
        getOuterShape(): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
        getOrder(): number;
        shouldBeStashedBefore(float: PageFloat_$0): boolean;
        addContinuations(continuations: PageFloatContinuation_$0[]): void;
        getFlowName(): string;
    }
    class PageFloatContinuation_$0 implements PageFloats.PageFloatContinuation_$0 {
        readonly float: PageFloat_$0;
        readonly nodePosition: Vtree.NodePosition;
        constructor(float: PageFloat_$0, nodePosition: Vtree.NodePosition);
        equals(other: PageFloatContinuation_$0 | null): boolean;
    }
    type PageFloatPlacementCondition_$0 = PageFloats.PageFloatPlacementCondition_$0;
    class PageFloatLayoutContext_$0 implements PageFloats.PageFloatLayoutContext_$0 {
        readonly parent: PageFloatLayoutContext_$0;
        private readonly floatReference;
        private container;
        readonly flowName: string | null;
        readonly generatingNodePosition: Vtree.NodePosition | null;
        private children;
        writingMode: Css.Val;
        direction: Css.Val;
        private invalidated;
        private floatStore;
        private forbiddenFloats;
        floatFragments: PageFloatFragment_$0[];
        private stashedFloatFragments;
        private floatAnchors;
        private floatsDeferredToNext;
        private floatsDeferredFromPrevious;
        private layoutConstraints;
        private locked;
        constructor(parent: PageFloatLayoutContext_$0, floatReference: FloatReference_$0 | null, container: Vtree.Container, flowName: string | null, generatingNodePosition: Vtree.NodePosition | null, writingMode: Css.Val | null, direction: Css.Val | null);
        private getParent;
        private getPreviousSiblingOf;
        private getPreviousSibling;
        getContainer(floatReference?: FloatReference_$0): Vtree.Container;
        setContainer(container: Vtree.Container): void;
        addPageFloat(float: PageFloat_$0): void;
        getPageFloatLayoutContext(floatReference: FloatReference_$0): PageFloatLayoutContext_$0;
        findPageFloatByNodePosition(nodePosition: Vtree.NodePosition): PageFloat_$0 | null;
        private forbid;
        isForbidden(float: PageFloat_$0): boolean;
        addPageFloatFragment(floatFragment: PageFloatFragment_$0, dontInvalidate?: boolean): void;
        removePageFloatFragment(floatFragment: PageFloatFragment_$0, dontInvalidate?: boolean): void;
        findPageFloatFragment(float: PageFloat_$0): PageFloatFragment_$0 | null;
        hasFloatFragments(condition?: (p1: PageFloatFragment_$0) => boolean): boolean;
        hasContinuingFloatFragmentsInFlow(flowName: string): boolean;
        registerPageFloatAnchor(float: PageFloat_$0, anchorViewNode: Node): void;
        collectPageFloatAnchors(): any;
        isAnchorAlreadyAppeared(floatId: PageFloatID_$0): boolean;
        deferPageFloat(continuation: PageFloatContinuation_$0): void;
        hasPrecedingFloatsDeferredToNext(float: PageFloat_$0, ignoreReference?: boolean): boolean;
        getLastFollowingFloatInFragments(float: PageFloat_$0): PageFloat_$0 | null;
        getDeferredPageFloatContinuations(flowName?: string | null): PageFloatContinuation_$0[];
        getPageFloatContinuationsDeferredToNext(flowName?: string | null): PageFloatContinuation_$0[];
        getFloatsDeferredToNextInChildContexts(): PageFloat_$0[];
        checkAndForbidNotAllowedFloat(): boolean;
        checkAndForbidFloatFollowingDeferredFloat(): boolean;
        finish(): void;
        hasSameContainerAs(other: PageFloatLayoutContext_$0): boolean;
        invalidate(): void;
        detachChildren(): PageFloatLayoutContext_$0[];
        attachChildren(children: PageFloatLayoutContext_$0[]): void;
        isInvalidated(): any;
        validate(): void;
        private toLogical;
        private toPhysical;
        removeEndFloatFragments(floatSide: string): void;
        stashEndFloatFragments(float: PageFloat_$0): void;
        restoreStashedFragments(floatReference: FloatReference_$0): void;
        discardStashedFragments(floatReference: FloatReference_$0): void;
        getStashedFloatFragments(floatReference: FloatReference_$0): PageFloatFragment_$0[];
        private getLimitValue;
        private getLimitValueInner;
        private getLimitValuesInner;
        setFloatAreaDimensions(area: LayoutType.PageFloatArea, floatReference: FloatReference_$0, floatSide: string, anchorEdge: number | null, init: boolean, force: boolean, condition: PageFloatPlacementCondition_$0): string | null;
        getFloatFragmentExclusions(): GeometryUtil.Shape[];
        private reattachFloatFragments;
        getMaxReachedAfterEdge(): number;
        getBlockStartEdgeOfBlockEndFloats(): number;
        getPageFloatClearEdge(clear: string, column: LayoutType.Column): number;
        getPageFloatPlacementCondition(float: PageFloat_$0, floatSide: string, clearSide: string | null): PageFloatPlacementCondition_$0;
        getLayoutConstraints(): LayoutType.LayoutConstraint[];
        addLayoutConstraint(layoutConstraint: LayoutType.LayoutConstraint, floatReference: FloatReference_$0): void;
        isColumnFullWithPageFloats(column: LayoutType.Column): boolean;
        getMaxBlockSizeOfPageFloats(): number;
        lock(): void;
        unlock(): void;
        isLocked(): boolean;
    }
    interface PageFloatLayoutStrategy_$0 extends PageFloats.PageFloatLayoutStrategy_$0 {
    }
    class PageFloatLayoutStrategyResolver {
        register(strategy: PageFloatLayoutStrategy_$0): void;
        findByNodeContext(nodeContext: Vtree.NodeContext): PageFloatLayoutStrategy_$0;
        findByFloat(float: PageFloat_$0): PageFloatLayoutStrategy_$0;
    }
    class NormalPageFloatLayoutStrategy implements PageFloatLayoutStrategy_$0 {
        appliesToNodeContext(nodeContext: Vtree.NodeContext): boolean;
        appliesToFloat(float: PageFloat_$0): boolean;
        createPageFloat(nodeContext: Vtree.NodeContext, pageFloatLayoutContext: PageFloatLayoutContext_$0, column: LayoutType.Column): Task.Result<PageFloat_$0>;
        createPageFloatFragment(continuations: PageFloatContinuation_$0[], floatSide: string, floatArea: LayoutType.PageFloatArea, continues: boolean): PageFloatFragment_$0;
        findPageFloatFragment(float: PageFloat_$0, pageFloatLayoutContext: PageFloatLayoutContext_$0): PageFloatFragment_$0 | null;
        adjustPageFloatArea(floatArea: LayoutType.PageFloatArea, floatContainer: Vtree.Container, column: LayoutType.Column): void;
        forbid(float: PageFloat_$0, pageFloatLayoutContext: PageFloatLayoutContext_$0): void;
    }
}
declare namespace Matchers {
    function matchANPlusB(order: number, a: number, b: number): boolean;
    interface Matcher {
        matches(): boolean;
    }
    class AnyMatcher implements Matcher {
        readonly matchers: Matcher[];
        constructor(matchers: Matcher[]);
        matches(): boolean;
    }
    class AllMatcher implements Matcher {
        readonly matchers: Matcher[];
        constructor(matchers: Matcher[]);
        matches(): boolean;
    }
    class NthFragmentMatcher implements Matcher {
        readonly elementOffset: number;
        readonly a: number;
        readonly b: number;
        static fragmentIndices: {};
        registerFragmentIndex(elementOffset: number, fragmentIndex: number, priority: number): void;
        clearFragmentIndices(): void;
        constructor(elementOffset: number, a: number, b: number);
        matches(): boolean;
    }
    class MatcherBuilder {
        buildViewConditionMatcher(elementOffset: number, viewCondition: string): Matcher;
        buildAllMatcher(matchers: Matcher[]): Matcher;
        buildAnyMatcher(matchers: Matcher[]): Matcher;
    }
}
declare namespace PseudoElement_$0 {
    const document: Document;
    const pseudoNames_$0: string[];
    const PSEUDO_ATTR = "data-adapt-pseudo";
    function getPseudoName(element: Element): string;
    function setPseudoName(element: Element, name: string): void;
    class PseudoelementStyler_$0 implements PseudoElement.PseudoelementStyler_$0 {
        readonly element: Element;
        style: CssCascade_$0.ElementStyle;
        styler: CssStyler_$0.AbstractStyler;
        readonly context: Exprs.Context;
        readonly exprContentListener: Vtree_$0.ExprContentListener;
        contentProcessed: {
            [key: string]: boolean;
        };
        constructor(element: Element, style: CssCascade_$0.ElementStyle, styler: CssStyler_$0.AbstractStyler, context: Exprs.Context, exprContentListener: Vtree_$0.ExprContentListener);
        getStyle(element: Element, deep: boolean): CssCascade_$0.ElementStyle;
        processContent(element: Element, styles: {
            [key: string]: Css.Val;
        }): void;
    }
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
declare namespace VtreeImpl {
    const delayedProps: {
        transform: boolean;
        "transform-origin": boolean;
    };
    const delayedPropsIfRelativePositioned: {
        top: boolean;
        bottom: boolean;
        left: boolean;
        right: boolean;
    };
    class DelayedItem {
        target: Element;
        name: string;
        value: Css.Val;
        constructor(target: Element, name: string, value: Css.Val);
    }
    type PageHyperlinkEvent = {
        type: string;
        target: any;
        currentTarget: any;
        anchorElement: Element;
        href: string;
    };
    type Trigger = {
        observer: string;
        event: string;
        action: string;
        ref: string;
    };
    const actions: {
        show: (obj: any) => void;
        hide: (obj: any) => void;
        play: (obj: any) => void;
        pause: (obj: any) => void;
        resume: (obj: any) => void;
        mute: (obj: any) => void;
        unmute: (obj: any) => void;
    };
    function makeListener(refs: Element[], action: string): EventListener | null;
    class Page extends Base.SimpleEventTarget {
        readonly container: HTMLElement;
        readonly bleedBox: HTMLElement;
        private static AUTO_PAGE_WIDTH_ATTRIBUTE;
        private static AUTO_PAGE_HEIGHT_ATTRIBUTE;
        pageAreaElement: HTMLElement | null;
        delayedItems: DelayedItem[];
        hrefHandler: (e: Event) => void;
        elementsById: {
            [key: string]: Element[];
        };
        dimensions: {
            width: number;
            height: number;
        };
        isFirstPage: boolean;
        isLastPage: boolean;
        isAutoPageWidth: boolean;
        isAutoPageHeight: boolean;
        spineIndex: number;
        position: LayoutPosition;
        offset: number;
        side: Constants.PageSide | null;
        fetchers: TaskUtil.Fetcher<{}>[];
        marginBoxes: {
            top: {
                [key: string]: Container_$0;
            };
            bottom: {
                [key: string]: Container_$0;
            };
            left: {
                [key: string]: Container_$0;
            };
            right: {
                [key: string]: Container_$0;
            };
        };
        constructor(container: HTMLElement, bleedBox: HTMLElement);
        setAutoPageWidth(isAuto: boolean): void;
        setAutoPageHeight(isAuto: boolean): void;
        registerElementWithId(element: Element, id: string): void;
        finish(triggers: Trigger[], clientLayout: ClientLayout_$0): void;
        zoom(scale: number): void;
        getPageAreaElement(): HTMLElement;
    }
    type Spread = {
        left: Page;
        right: Page;
    };
    const SPECIAL_ATTR = "data-adapt-spec";
    const Whitespace_$0: typeof Vtree.Whitespace_$0;
    type Whitespace_$0 = Vtree.Whitespace_$0;
    function whitespaceFromPropertyValue(whitespace: string): Whitespace_$0 | null;
    function canIgnore(node: Node, whitespace: Whitespace_$0): boolean;
    class Flow {
        readonly flowName: string;
        readonly parentFlowName: string | null;
        forcedBreakOffsets: number[];
        formattingContext: FormattingContext_$0 | null;
        constructor(flowName: string, parentFlowName: string | null);
    }
    class FlowChunk {
        flowName: string;
        element: Element;
        startOffset: number;
        priority: number;
        linger: number;
        exclusive: boolean;
        repeated: boolean;
        last: boolean;
        breakBefore: string | null;
        startPage: number;
        constructor(flowName: string, element: Element, startOffset: number, priority: number, linger: number, exclusive: boolean, repeated: boolean, last: boolean, breakBefore: string | null);
        isBetter(other: FlowChunk): boolean;
    }
    type ClientRect_$0 = Vtree.ClientRect_$0;
    function clientrectIncreasingTop(r1: ClientRect_$0, r2: ClientRect_$0): number;
    function clientrectDecreasingRight(r1: ClientRect_$0, r2: ClientRect_$0): number;
    type ClientLayout_$0 = Vtree.ClientLayout_$0;
    type LayoutContext_$0 = Vtree.LayoutContext_$0;
    type FormattingContext_$0 = Vtree.FormattingContext_$0;
    function eachAncestorFormattingContext(nodeContext: NodeContext_$0, callback: (p1: FormattingContext_$0) => any): void;
    type NodePositionStep_$0 = Vtree.NodePositionStep_$0;
    function isSameNodePositionStep(nps1: NodePositionStep_$0, nps2: NodePositionStep_$0): boolean;
    type NodePosition_$0 = Vtree.NodePosition_$0;
    function isSameNodePosition(np1: NodePosition_$0 | null, np2: NodePosition_$0 | null): boolean;
    function newNodePositionFromNode(node: Node): NodePosition_$0;
    function newNodePositionFromNodeContext(nodeContext: Vtree.NodeContext_$0, initialFragmentIndex: number | null): NodePosition_$0;
    function makeNodeContextFromNodePositionStep(step: NodePositionStep_$0, parent: Vtree.NodeContext_$0): NodeContext_$0;
    const ShadowType_$0: typeof Vtree.ShadowType_$0;
    type ShadowType_$0 = Vtree.ShadowType_$0;
    class ShadowContext_$0 implements Vtree.ShadowContext_$0 {
        readonly owner: Element;
        readonly root: Element;
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly parentShadow: ShadowContext_$0;
        readonly type: ShadowType_$0;
        readonly styler: object;
        subShadow: ShadowContext_$0;
        constructor(owner: Element, root: Element, xmldoc: XmlDoc.XMLDocHolder, parentShadow: ShadowContext_$0, superShadow: ShadowContext_$0, type: ShadowType_$0, styler: object);
        equals(other: ShadowContext_$0): boolean;
    }
    function isSameShadowContext(sc1: ShadowContext_$0, sc2: ShadowContext_$0): boolean;
    class FirstPseudo_$0 implements Vtree.FirstPseudo_$0 {
        readonly outer: FirstPseudo_$0;
        readonly count: number;
        constructor(outer: FirstPseudo_$0, count: number);
    }
    class NodeContext_$0 implements Vtree.NodeContext_$0 {
        sourceNode: Node;
        parent: NodeContext_$0;
        boxOffset: number;
        offsetInNode: number;
        after: boolean;
        shadowType: ShadowType_$0;
        shadowContext: ShadowContext_$0;
        nodeShadow: ShadowContext_$0;
        shadowSibling: NodeContext_$0;
        shared: boolean;
        inline: boolean;
        overflow: boolean;
        breakPenalty: number;
        display: string | null;
        floatReference: PageFloats.FloatReference;
        floatSide: string | null;
        clearSide: string | null;
        floatMinWrapBlock: Css.Numeric | null;
        columnSpan: Css.Val | null;
        verticalAlign: string;
        captionSide: string;
        inlineBorderSpacing: number;
        blockBorderSpacing: number;
        flexContainer: boolean;
        whitespace: Whitespace_$0;
        hyphenateCharacter: string | null;
        breakWord: boolean;
        establishesBFC: boolean;
        containingBlockForAbsolute: boolean;
        breakBefore: string | null;
        breakAfter: string | null;
        viewNode: Node;
        clearSpacer: Node;
        inheritedProps: {
            [key: string]: number | string | Css.Val;
        };
        vertical: boolean;
        direction: string;
        firstPseudo: FirstPseudo_$0;
        lang: string | null;
        preprocessedTextContent: Diff.Change[] | null;
        formattingContext: FormattingContext_$0;
        repeatOnBreak: string | null;
        pluginProps: {
            [key: string]: string | number | undefined | null | (number | null)[];
        };
        fragmentIndex: number;
        afterIfContinues: Selectors.AfterIfContinues;
        footnotePolicy: Css.Ident | null;
        constructor(sourceNode: Node, parent: NodeContext_$0, boxOffset: number);
        resetView(): void;
        private cloneItem;
        modify(): NodeContext_$0;
        copy(): NodeContext_$0;
        clone(): NodeContext_$0;
        toNodePositionStep(): NodePositionStep_$0;
        toNodePosition(): NodePosition_$0;
        isInsideBFC(): boolean;
        getContainingBlockForAbsolute(): NodeContext_$0;
        walkUpBlocks(callback: (p1: NodeContext_$0) => any): void;
        belongsTo(formattingContext: FormattingContext_$0): boolean;
    }
    class ChunkPosition_$0 implements Vtree.ChunkPosition_$0 {
        primary: NodePosition_$0;
        floats: NodePosition_$0[];
        constructor(primary: NodePosition_$0);
        clone(): ChunkPosition_$0;
        isSamePosition(other: ChunkPosition_$0): boolean;
    }
    class FlowChunkPosition {
        chunkPosition: ChunkPosition_$0;
        readonly flowChunk: FlowChunk;
        constructor(chunkPosition: ChunkPosition_$0, flowChunk: FlowChunk);
        clone(): FlowChunkPosition;
        isSamePosition(other: FlowChunkPosition): boolean;
    }
    class FlowPosition {
        positions: FlowChunkPosition[];
        startSide: string;
        breakAfter: string | null;
        clone(): FlowPosition;
        isSamePosition(other: FlowPosition): boolean;
        hasContent(offset: number): boolean;
    }
    class LayoutPosition {
        page: number;
        flows: {
            [key: string]: Flow;
        };
        flowPositions: {
            [key: string]: FlowPosition;
        };
        highestSeenOffset: number;
        highestSeenNode: Node;
        lookupPositionOffset: number;
        clone(): LayoutPosition;
        isSamePosition(other: LayoutPosition): boolean;
        hasContent(name: string, offset: number): boolean;
        startSideOfFlow(name: string): string;
        firstFlowChunkOfFlow(name: string): FlowChunk | null;
    }
    class Container_$0 implements Vtree.Container_$0 {
        element: Element;
        left: number;
        top: number;
        marginLeft: number;
        marginRight: number;
        marginTop: number;
        marginBottom: number;
        borderLeft: number;
        borderRight: number;
        borderTop: number;
        borderBottom: number;
        paddingLeft: number;
        paddingRight: number;
        paddingTop: number;
        paddingBottom: number;
        width: number;
        height: number;
        originX: number;
        originY: number;
        exclusions: GeometryUtil.Shape[];
        innerShape: GeometryUtil.Shape;
        computedBlockSize: number;
        snapWidth: number;
        snapHeight: number;
        snapOffsetX: number;
        snapOffsetY: number;
        vertical: boolean;
        constructor(element: Element);
        getInsetTop(): number;
        getInsetBottom(): number;
        getInsetLeft(): number;
        getInsetRight(): number;
        getInsetBefore(): number;
        getInsetAfter(): number;
        getInsetStart(): number;
        getInsetEnd(): number;
        getBeforeEdge(box: ClientRect_$0): number;
        getAfterEdge(box: ClientRect_$0): number;
        getStartEdge(box: ClientRect_$0): number;
        getEndEdge(box: ClientRect_$0): number;
        getInlineSize(box: ClientRect_$0): number;
        getBoxSize(box: ClientRect_$0): number;
        getBoxDir(): number;
        getInlineDir(): number;
        copyFrom(other: Container_$0): void;
        setVerticalPosition(top: number, height: number): void;
        setHorizontalPosition(left: number, width: number): void;
        setBlockPosition(start: number, extent: number): void;
        setInlinePosition(start: number, extent: number): void;
        clear(): void;
        getInnerShape(): GeometryUtil.Shape;
        getInnerRect(): GeometryUtil.Rect;
        getPaddingRect(): GeometryUtil.Rect;
        getOuterShape(outerShapeProp: Css.Val, context: Exprs.Context): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
    }
    type ExprContentListener_$0 = Vtree.ExprContentListener_$0;
    class ContentPropertyHandler extends Css.Visitor {
        readonly elem: Element;
        readonly context: Exprs.Context;
        readonly rootContentValue: Css.Val;
        readonly exprContentListener: ExprContentListener_$0;
        constructor(elem: Element, context: Exprs.Context, rootContentValue: Css.Val, exprContentListener: ExprContentListener_$0);
        private visitStrInner;
        visitStr(str: Css.Str): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function nonTrivialContent(val: Css.Val): boolean;
}
declare namespace LayoutProcessor {
    interface LayoutProcessor_$0 {
        layout(nodeContext: Vtree.NodeContext, column: Layout.Column, leadingEdge: boolean): Task.Result<Vtree.NodeContext>;
        createEdgeBreakPosition(position: Vtree.NodeContext, breakOnEdge: string | null, overflows: boolean, columnBlockSize: number): Layout.BreakPosition;
        startNonInlineElementNode(nodeContext: Vtree.NodeContext): boolean;
        afterNonInlineElementNode(nodeContext: Vtree.NodeContext, stopAtOverflow: boolean): boolean;
        finishBreak(column: Layout.Column, nodeContext: Vtree.NodeContext, forceRemoveSelf: boolean, endOfColumn: boolean): Task.Result<boolean>;
        clearOverflownViewNodes(column: Layout.Column, parentNodeContext: Vtree.NodeContext, nodeContext: Vtree.NodeContext, removeSelf: boolean): any;
    }
    class LayoutProcessorResolver {
        find(formattingContext: Vtree.FormattingContext): LayoutProcessor_$0;
    }
    class BlockLayoutProcessor implements LayoutProcessor_$0 {
        layout(nodeContext: Vtree.NodeContext, column: Layout.Column, leadingEdge: boolean): Task.Result<Vtree.NodeContext>;
        createEdgeBreakPosition(position: Vtree.NodeContext, breakOnEdge: string | null, overflows: boolean, columnBlockSize: number): Layout.BreakPosition;
        startNonInlineElementNode(nodeContext: Vtree.NodeContext): boolean;
        afterNonInlineElementNode(nodeContext: Vtree.NodeContext, stopAtOverflow: boolean): boolean;
        clearOverflownViewNodes(column: Layout.Column, parentNodeContext: Vtree.NodeContext, nodeContext: Vtree.NodeContext, removeSelf: boolean): void;
        finishBreak(column: Layout.Column, nodeContext: Vtree.NodeContext, forceRemoveSelf: boolean, endOfColumn: boolean): Task.Result<boolean>;
    }
    class BlockFormattingContext_$0 implements LayoutProcessor_$0.BlockFormattingContext_$0 {
        private readonly parent;
        formattingContextType: FormattingContextType;
        constructor(parent: Vtree.FormattingContext);
        getName(): string;
        isFirstTime(nodeContext: Vtree.NodeContext, firstTime: boolean): boolean;
        getParent(): Vtree.FormattingContext;
        saveState(): any;
        restoreState(state: any): void;
    }
    const blockLayoutProcessor: BlockLayoutProcessor;
    const isInstanceOfBlockFormattingContext_$0: typeof LayoutProcessor_$0.isInstanceOfBlockFormattingContext_$0;
}
declare namespace LayoutRetryers {
    abstract class AbstractLayoutRetryer {
        initialBreakPositions: Layout.BreakPosition[];
        initialStateOfFormattingContext: Vtree.NodeContext;
        initialPosition: Vtree.NodeContext;
        initialFragmentLayoutConstraints: Layout.FragmentLayoutConstraint[];
        layout(nodeContext: Vtree.NodeContext, column: Layout.Column): Task.Result<Vtree.NodeContext>;
        private tryLayout;
        resolveLayoutMode(nodeContext: Vtree.NodeContext): Layout.LayoutMode;
        prepareLayout(nodeContext: Vtree.NodeContext, column: Layout.Column): void;
        clearNodes(initialPosition: Vtree.NodeContext): void;
        saveState(nodeContext: Vtree.NodeContext, column: Layout.Column): void;
        restoreState(nodeContext: Vtree.NodeContext, column: Layout.Column): void;
    }
}
declare namespace LayoutUtil {
    type LayoutIteratorState = {
        nodeContext: Vtree.NodeContext;
        atUnforcedBreak: boolean;
        break: boolean;
        leadingEdge?: boolean;
        breakAtTheEdge?: string | null;
        onStartEdges?: boolean;
        leadingEdgeContexts?: Vtree.NodeContext[];
        lastAfterNodeContext?: Vtree.NodeContext | null;
    };
    class LayoutIteratorStrategy {
        initialState(initialNodeContext: Vtree.NodeContext): LayoutIteratorState;
        startNonDisplayableNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        afterNonDisplayableNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        startIgnoredTextNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        afterIgnoredTextNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        startNonElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        afterNonElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        startInlineElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        afterInlineElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        startNonInlineElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        afterNonInlineElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        finish(state: LayoutIteratorState): void | Task.Result<boolean>;
    }
    class LayoutIterator {
        private readonly strategy;
        private readonly layoutContext;
        constructor(strategy: LayoutIteratorStrategy, layoutContext: Vtree.LayoutContext);
        iterate(initialNodeContext: Vtree.NodeContext): Task.Result<Vtree.NodeContext>;
    }
    class EdgeSkipper extends LayoutIteratorStrategy {
        protected readonly leadingEdge?: boolean;
        constructor(leadingEdge?: boolean);
        startNonInlineBox(state: LayoutIteratorState): void | Task.Result<boolean>;
        endEmptyNonInlineBox(state: LayoutIteratorState): void | Task.Result<boolean>;
        endNonInlineBox(state: LayoutIteratorState): void | Task.Result<boolean>;
        initialState(initialNodeContext: Vtree.NodeContext): LayoutIteratorState;
        processForcedBreak(state: LayoutIteratorState, column: Layout.Column): boolean;
        saveEdgeAndProcessOverflow(state: LayoutIteratorState, column: Layout.Column): boolean;
        processLayoutConstraint(state: LayoutIteratorState, layoutConstraint: Layout.LayoutConstraint, column: Layout.Column): boolean;
        startNonElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        startNonInlineElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        afterNonInlineElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
    }
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
type LayoutType = Layout;
declare namespace BreakPosition_$0 {
    type BreakPosition_$0 = Layout.BreakPosition_$0;
    abstract class AbstractBreakPosition_$0 implements Layout.AbstractBreakPosition_$0 {
        findAcceptableBreak(column: Layout.Column, penalty: number): Vtree.NodeContext;
        getMinBreakPenalty(): number;
        calculateOffset(column: any): {
            current: number;
            minimum: number;
        };
        breakPositionChosen(column: Layout.Column): void;
        getNodeContext(): Vtree.NodeContext;
    }
    function calculateOffset(nodeContext: Vtree.NodeContext, elementsOffsets: RepetitiveElement.ElementsOffset[]): {
        current: number;
        minimum: number;
    };
    class EdgeBreakPosition_$0 extends AbstractBreakPosition_$0 implements Layout.EdgeBreakPosition_$0 {
        readonly position: Vtree.NodeContext;
        readonly breakOnEdge: string | null;
        overflows: boolean;
        readonly computedBlockSize: number;
        overflowIfRepetitiveElementsDropped: boolean;
        protected isEdgeUpdated: boolean;
        private edge;
        constructor(position: Vtree.NodeContext, breakOnEdge: string | null, overflows: boolean, computedBlockSize: number);
        findAcceptableBreak(column: Layout.Column, penalty: number): Vtree.NodeContext;
        getMinBreakPenalty(): number;
        private updateEdge;
        private updateOverflows;
        getNodeContext(): Vtree.NodeContext;
        private isFirstContentOfRepetitiveElementsOwner;
    }
}
declare namespace LayoutProcessor {
    interface LayoutProcessor_$0 {
        layout(nodeContext: Vtree.NodeContext, column: Layout.Column, leadingEdge: boolean): Task.Result<Vtree.NodeContext>;
        createEdgeBreakPosition(position: Vtree.NodeContext, breakOnEdge: string | null, overflows: boolean, columnBlockSize: number): Layout.BreakPosition;
        startNonInlineElementNode(nodeContext: Vtree.NodeContext): boolean;
        afterNonInlineElementNode(nodeContext: Vtree.NodeContext, stopAtOverflow: boolean): boolean;
        finishBreak(column: Layout.Column, nodeContext: Vtree.NodeContext, forceRemoveSelf: boolean, endOfColumn: boolean): Task.Result<boolean>;
        clearOverflownViewNodes(column: Layout.Column, parentNodeContext: Vtree.NodeContext, nodeContext: Vtree.NodeContext, removeSelf: boolean): any;
    }
    class LayoutProcessorResolver {
        find(formattingContext: Vtree.FormattingContext): LayoutProcessor_$0;
    }
    class BlockLayoutProcessor implements LayoutProcessor_$0 {
        layout(nodeContext: Vtree.NodeContext, column: Layout.Column, leadingEdge: boolean): Task.Result<Vtree.NodeContext>;
        createEdgeBreakPosition(position: Vtree.NodeContext, breakOnEdge: string | null, overflows: boolean, columnBlockSize: number): Layout.BreakPosition;
        startNonInlineElementNode(nodeContext: Vtree.NodeContext): boolean;
        afterNonInlineElementNode(nodeContext: Vtree.NodeContext, stopAtOverflow: boolean): boolean;
        clearOverflownViewNodes(column: Layout.Column, parentNodeContext: Vtree.NodeContext, nodeContext: Vtree.NodeContext, removeSelf: boolean): void;
        finishBreak(column: Layout.Column, nodeContext: Vtree.NodeContext, forceRemoveSelf: boolean, endOfColumn: boolean): Task.Result<boolean>;
    }
    class BlockFormattingContext_$0 implements LayoutProcessor_$0.BlockFormattingContext_$0 {
        private readonly parent;
        formattingContextType: FormattingContextType;
        constructor(parent: Vtree.FormattingContext);
        getName(): string;
        isFirstTime(nodeContext: Vtree.NodeContext, firstTime: boolean): boolean;
        getParent(): Vtree.FormattingContext;
        saveState(): any;
        restoreState(state: any): void;
    }
    const blockLayoutProcessor: BlockLayoutProcessor;
    const isInstanceOfBlockFormattingContext_$0: typeof LayoutProcessor_$0.isInstanceOfBlockFormattingContext_$0;
}
declare namespace LayoutRetryers {
    abstract class AbstractLayoutRetryer {
        initialBreakPositions: Layout.BreakPosition[];
        initialStateOfFormattingContext: Vtree.NodeContext;
        initialPosition: Vtree.NodeContext;
        initialFragmentLayoutConstraints: Layout.FragmentLayoutConstraint[];
        layout(nodeContext: Vtree.NodeContext, column: Layout.Column): Task.Result<Vtree.NodeContext>;
        private tryLayout;
        resolveLayoutMode(nodeContext: Vtree.NodeContext): Layout.LayoutMode;
        prepareLayout(nodeContext: Vtree.NodeContext, column: Layout.Column): void;
        clearNodes(initialPosition: Vtree.NodeContext): void;
        saveState(nodeContext: Vtree.NodeContext, column: Layout.Column): void;
        restoreState(nodeContext: Vtree.NodeContext, column: Layout.Column): void;
    }
}
declare namespace LayoutUtil {
    type LayoutIteratorState = {
        nodeContext: Vtree.NodeContext;
        atUnforcedBreak: boolean;
        break: boolean;
        leadingEdge?: boolean;
        breakAtTheEdge?: string | null;
        onStartEdges?: boolean;
        leadingEdgeContexts?: Vtree.NodeContext[];
        lastAfterNodeContext?: Vtree.NodeContext | null;
    };
    class LayoutIteratorStrategy {
        initialState(initialNodeContext: Vtree.NodeContext): LayoutIteratorState;
        startNonDisplayableNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        afterNonDisplayableNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        startIgnoredTextNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        afterIgnoredTextNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        startNonElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        afterNonElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        startInlineElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        afterInlineElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        startNonInlineElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        afterNonInlineElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        finish(state: LayoutIteratorState): void | Task.Result<boolean>;
    }
    class LayoutIterator {
        private readonly strategy;
        private readonly layoutContext;
        constructor(strategy: LayoutIteratorStrategy, layoutContext: Vtree.LayoutContext);
        iterate(initialNodeContext: Vtree.NodeContext): Task.Result<Vtree.NodeContext>;
    }
    class EdgeSkipper extends LayoutIteratorStrategy {
        protected readonly leadingEdge?: boolean;
        constructor(leadingEdge?: boolean);
        startNonInlineBox(state: LayoutIteratorState): void | Task.Result<boolean>;
        endEmptyNonInlineBox(state: LayoutIteratorState): void | Task.Result<boolean>;
        endNonInlineBox(state: LayoutIteratorState): void | Task.Result<boolean>;
        initialState(initialNodeContext: Vtree.NodeContext): LayoutIteratorState;
        processForcedBreak(state: LayoutIteratorState, column: Layout.Column): boolean;
        saveEdgeAndProcessOverflow(state: LayoutIteratorState, column: Layout.Column): boolean;
        processLayoutConstraint(state: LayoutIteratorState, layoutConstraint: Layout.LayoutConstraint, column: Layout.Column): boolean;
        startNonElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        startNonInlineElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
        afterNonInlineElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
    }
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
type LayoutType = Layout;
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace PageFloats_$0 {
    const FloatReference_$0: typeof PageFloats.FloatReference_$0;
    type FloatReference_$0 = PageFloats.FloatReference_$0;
    function floatReferenceOf(str: string): FloatReference_$0;
    function isPageFloat(floatReference: FloatReference_$0): boolean;
    function resolveInlineFloatDirection(floatSide: string, vertical: boolean, direction: string): string;
    class PageFloat_$0 implements PageFloats.PageFloat_$0 {
        readonly nodePosition: Vtree.NodePosition;
        readonly floatReference: FloatReference_$0;
        readonly floatSide: string;
        readonly clearSide: string | null;
        readonly flowName: string;
        readonly floatMinWrapBlock: Css.Numeric | null;
        order: number | null;
        id: PageFloatID_$0 | null;
        constructor(nodePosition: Vtree.NodePosition, floatReference: FloatReference_$0, floatSide: string, clearSide: string | null, flowName: string, floatMinWrapBlock: Css.Numeric | null);
        getOrder(): number;
        getId(): PageFloatID_$0;
        isAllowedOnContext(pageFloatLayoutContext: PageFloatLayoutContext_$0): boolean;
        isAllowedToPrecede(other: PageFloat_$0): boolean;
    }
    class PageFloatStore {
        private floats;
        private nextPageFloatIndex;
        private nextOrder;
        private createPageFloatId;
        addPageFloat(float: PageFloat_$0): void;
        findPageFloatByNodePosition(nodePosition: Vtree.NodePosition): PageFloat_$0 | null;
        findPageFloatById(id: PageFloatID_$0): PageFloat_$0;
    }
    class PageFloatFragment_$0 implements PageFloats.PageFloatFragment_$0 {
        readonly floatReference: FloatReference_$0;
        readonly floatSide: string;
        readonly continuations: PageFloatContinuation_$0[];
        readonly area: Vtree.Container;
        readonly continues: boolean;
        constructor(floatReference: FloatReference_$0, floatSide: string, continuations: PageFloatContinuation_$0[], area: Vtree.Container, continues: boolean);
        hasFloat(float: PageFloat_$0): boolean;
        findNotAllowedFloat(context: PageFloatLayoutContext_$0): PageFloat_$0 | null;
        getOuterShape(): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
        getOrder(): number;
        shouldBeStashedBefore(float: PageFloat_$0): boolean;
        addContinuations(continuations: PageFloatContinuation_$0[]): void;
        getFlowName(): string;
    }
    class PageFloatContinuation_$0 implements PageFloats.PageFloatContinuation_$0 {
        readonly float: PageFloat_$0;
        readonly nodePosition: Vtree.NodePosition;
        constructor(float: PageFloat_$0, nodePosition: Vtree.NodePosition);
        equals(other: PageFloatContinuation_$0 | null): boolean;
    }
    type PageFloatPlacementCondition_$0 = PageFloats.PageFloatPlacementCondition_$0;
    class PageFloatLayoutContext_$0 implements PageFloats.PageFloatLayoutContext_$0 {
        readonly parent: PageFloatLayoutContext_$0;
        private readonly floatReference;
        private container;
        readonly flowName: string | null;
        readonly generatingNodePosition: Vtree.NodePosition | null;
        private children;
        writingMode: Css.Val;
        direction: Css.Val;
        private invalidated;
        private floatStore;
        private forbiddenFloats;
        floatFragments: PageFloatFragment_$0[];
        private stashedFloatFragments;
        private floatAnchors;
        private floatsDeferredToNext;
        private floatsDeferredFromPrevious;
        private layoutConstraints;
        private locked;
        constructor(parent: PageFloatLayoutContext_$0, floatReference: FloatReference_$0 | null, container: Vtree.Container, flowName: string | null, generatingNodePosition: Vtree.NodePosition | null, writingMode: Css.Val | null, direction: Css.Val | null);
        private getParent;
        private getPreviousSiblingOf;
        private getPreviousSibling;
        getContainer(floatReference?: FloatReference_$0): Vtree.Container;
        setContainer(container: Vtree.Container): void;
        addPageFloat(float: PageFloat_$0): void;
        getPageFloatLayoutContext(floatReference: FloatReference_$0): PageFloatLayoutContext_$0;
        findPageFloatByNodePosition(nodePosition: Vtree.NodePosition): PageFloat_$0 | null;
        private forbid;
        isForbidden(float: PageFloat_$0): boolean;
        addPageFloatFragment(floatFragment: PageFloatFragment_$0, dontInvalidate?: boolean): void;
        removePageFloatFragment(floatFragment: PageFloatFragment_$0, dontInvalidate?: boolean): void;
        findPageFloatFragment(float: PageFloat_$0): PageFloatFragment_$0 | null;
        hasFloatFragments(condition?: (p1: PageFloatFragment_$0) => boolean): boolean;
        hasContinuingFloatFragmentsInFlow(flowName: string): boolean;
        registerPageFloatAnchor(float: PageFloat_$0, anchorViewNode: Node): void;
        collectPageFloatAnchors(): any;
        isAnchorAlreadyAppeared(floatId: PageFloatID_$0): boolean;
        deferPageFloat(continuation: PageFloatContinuation_$0): void;
        hasPrecedingFloatsDeferredToNext(float: PageFloat_$0, ignoreReference?: boolean): boolean;
        getLastFollowingFloatInFragments(float: PageFloat_$0): PageFloat_$0 | null;
        getDeferredPageFloatContinuations(flowName?: string | null): PageFloatContinuation_$0[];
        getPageFloatContinuationsDeferredToNext(flowName?: string | null): PageFloatContinuation_$0[];
        getFloatsDeferredToNextInChildContexts(): PageFloat_$0[];
        checkAndForbidNotAllowedFloat(): boolean;
        checkAndForbidFloatFollowingDeferredFloat(): boolean;
        finish(): void;
        hasSameContainerAs(other: PageFloatLayoutContext_$0): boolean;
        invalidate(): void;
        detachChildren(): PageFloatLayoutContext_$0[];
        attachChildren(children: PageFloatLayoutContext_$0[]): void;
        isInvalidated(): any;
        validate(): void;
        private toLogical;
        private toPhysical;
        removeEndFloatFragments(floatSide: string): void;
        stashEndFloatFragments(float: PageFloat_$0): void;
        restoreStashedFragments(floatReference: FloatReference_$0): void;
        discardStashedFragments(floatReference: FloatReference_$0): void;
        getStashedFloatFragments(floatReference: FloatReference_$0): PageFloatFragment_$0[];
        private getLimitValue;
        private getLimitValueInner;
        private getLimitValuesInner;
        setFloatAreaDimensions(area: LayoutType.PageFloatArea, floatReference: FloatReference_$0, floatSide: string, anchorEdge: number | null, init: boolean, force: boolean, condition: PageFloatPlacementCondition_$0): string | null;
        getFloatFragmentExclusions(): GeometryUtil.Shape[];
        private reattachFloatFragments;
        getMaxReachedAfterEdge(): number;
        getBlockStartEdgeOfBlockEndFloats(): number;
        getPageFloatClearEdge(clear: string, column: LayoutType.Column): number;
        getPageFloatPlacementCondition(float: PageFloat_$0, floatSide: string, clearSide: string | null): PageFloatPlacementCondition_$0;
        getLayoutConstraints(): LayoutType.LayoutConstraint[];
        addLayoutConstraint(layoutConstraint: LayoutType.LayoutConstraint, floatReference: FloatReference_$0): void;
        isColumnFullWithPageFloats(column: LayoutType.Column): boolean;
        getMaxBlockSizeOfPageFloats(): number;
        lock(): void;
        unlock(): void;
        isLocked(): boolean;
    }
    interface PageFloatLayoutStrategy_$0 extends PageFloats.PageFloatLayoutStrategy_$0 {
    }
    class PageFloatLayoutStrategyResolver {
        register(strategy: PageFloatLayoutStrategy_$0): void;
        findByNodeContext(nodeContext: Vtree.NodeContext): PageFloatLayoutStrategy_$0;
        findByFloat(float: PageFloat_$0): PageFloatLayoutStrategy_$0;
    }
    class NormalPageFloatLayoutStrategy implements PageFloatLayoutStrategy_$0 {
        appliesToNodeContext(nodeContext: Vtree.NodeContext): boolean;
        appliesToFloat(float: PageFloat_$0): boolean;
        createPageFloat(nodeContext: Vtree.NodeContext, pageFloatLayoutContext: PageFloatLayoutContext_$0, column: LayoutType.Column): Task.Result<PageFloat_$0>;
        createPageFloatFragment(continuations: PageFloatContinuation_$0[], floatSide: string, floatArea: LayoutType.PageFloatArea, continues: boolean): PageFloatFragment_$0;
        findPageFloatFragment(float: PageFloat_$0, pageFloatLayoutContext: PageFloatLayoutContext_$0): PageFloatFragment_$0 | null;
        adjustPageFloatArea(floatArea: LayoutType.PageFloatArea, floatContainer: Vtree.Container, column: LayoutType.Column): void;
        forbid(float: PageFloat_$0, pageFloatLayoutContext: PageFloatLayoutContext_$0): void;
    }
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
declare namespace Vtree_$0 {
    const delayedProps: {
        transform: boolean;
        "transform-origin": boolean;
    };
    const delayedPropsIfRelativePositioned: {
        top: boolean;
        bottom: boolean;
        left: boolean;
        right: boolean;
    };
    class DelayedItem {
        target: Element;
        name: string;
        value: Css.Val;
        constructor(target: Element, name: string, value: Css.Val);
    }
    type PageHyperlinkEvent = {
        type: string;
        target: any;
        currentTarget: any;
        anchorElement: Element;
        href: string;
    };
    type Trigger = {
        observer: string;
        event: string;
        action: string;
        ref: string;
    };
    const actions: {
        show: (obj: any) => void;
        hide: (obj: any) => void;
        play: (obj: any) => void;
        pause: (obj: any) => void;
        resume: (obj: any) => void;
        mute: (obj: any) => void;
        unmute: (obj: any) => void;
    };
    function makeListener(refs: Element[], action: string): EventListener | null;
    class Page extends Base.SimpleEventTarget {
        readonly container: HTMLElement;
        readonly bleedBox: HTMLElement;
        private static AUTO_PAGE_WIDTH_ATTRIBUTE;
        private static AUTO_PAGE_HEIGHT_ATTRIBUTE;
        pageAreaElement: HTMLElement | null;
        delayedItems: DelayedItem[];
        hrefHandler: (e: Event) => void;
        elementsById: {
            [key: string]: Element[];
        };
        dimensions: {
            width: number;
            height: number;
        };
        isFirstPage: boolean;
        isLastPage: boolean;
        isAutoPageWidth: boolean;
        isAutoPageHeight: boolean;
        spineIndex: number;
        position: LayoutPosition;
        offset: number;
        side: Constants.PageSide | null;
        fetchers: TaskUtil.Fetcher<{}>[];
        marginBoxes: {
            top: {
                [key: string]: Container_$0;
            };
            bottom: {
                [key: string]: Container_$0;
            };
            left: {
                [key: string]: Container_$0;
            };
            right: {
                [key: string]: Container_$0;
            };
        };
        constructor(container: HTMLElement, bleedBox: HTMLElement);
        setAutoPageWidth(isAuto: boolean): void;
        setAutoPageHeight(isAuto: boolean): void;
        registerElementWithId(element: Element, id: string): void;
        finish(triggers: Trigger[], clientLayout: ClientLayout_$0): void;
        zoom(scale: number): void;
        getPageAreaElement(): HTMLElement;
    }
    type Spread = {
        left: Page;
        right: Page;
    };
    const SPECIAL_ATTR = "data-adapt-spec";
    const Whitespace_$0: typeof Vtree.Whitespace_$0;
    type Whitespace_$0 = Vtree.Whitespace_$0;
    function whitespaceFromPropertyValue(whitespace: string): Whitespace_$0 | null;
    function canIgnore(node: Node, whitespace: Whitespace_$0): boolean;
    class Flow {
        readonly flowName: string;
        readonly parentFlowName: string | null;
        forcedBreakOffsets: number[];
        formattingContext: FormattingContext_$0 | null;
        constructor(flowName: string, parentFlowName: string | null);
    }
    class FlowChunk {
        flowName: string;
        element: Element;
        startOffset: number;
        priority: number;
        linger: number;
        exclusive: boolean;
        repeated: boolean;
        last: boolean;
        breakBefore: string | null;
        startPage: number;
        constructor(flowName: string, element: Element, startOffset: number, priority: number, linger: number, exclusive: boolean, repeated: boolean, last: boolean, breakBefore: string | null);
        isBetter(other: FlowChunk): boolean;
    }
    type ClientRect_$0 = Vtree.ClientRect_$0;
    function clientrectIncreasingTop(r1: ClientRect_$0, r2: ClientRect_$0): number;
    function clientrectDecreasingRight(r1: ClientRect_$0, r2: ClientRect_$0): number;
    type ClientLayout_$0 = Vtree.ClientLayout_$0;
    type LayoutContext_$0 = Vtree.LayoutContext_$0;
    type FormattingContext_$0 = Vtree.FormattingContext_$0;
    function eachAncestorFormattingContext(nodeContext: NodeContext_$0, callback: (p1: FormattingContext_$0) => any): void;
    type NodePositionStep_$0 = Vtree.NodePositionStep_$0;
    function isSameNodePositionStep(nps1: NodePositionStep_$0, nps2: NodePositionStep_$0): boolean;
    type NodePosition_$0 = Vtree.NodePosition_$0;
    function isSameNodePosition(np1: NodePosition_$0 | null, np2: NodePosition_$0 | null): boolean;
    function newNodePositionFromNode(node: Node): NodePosition_$0;
    function newNodePositionFromNodeContext(nodeContext: Vtree.NodeContext_$0, initialFragmentIndex: number | null): NodePosition_$0;
    function makeNodeContextFromNodePositionStep(step: NodePositionStep_$0, parent: Vtree.NodeContext_$0): NodeContext_$0;
    const ShadowType_$0: typeof Vtree.ShadowType_$0;
    type ShadowType_$0 = Vtree.ShadowType_$0;
    class ShadowContext_$0 implements Vtree.ShadowContext_$0 {
        readonly owner: Element;
        readonly root: Element;
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly parentShadow: ShadowContext_$0;
        readonly type: ShadowType_$0;
        readonly styler: object;
        subShadow: ShadowContext_$0;
        constructor(owner: Element, root: Element, xmldoc: XmlDoc.XMLDocHolder, parentShadow: ShadowContext_$0, superShadow: ShadowContext_$0, type: ShadowType_$0, styler: object);
        equals(other: ShadowContext_$0): boolean;
    }
    function isSameShadowContext(sc1: ShadowContext_$0, sc2: ShadowContext_$0): boolean;
    class FirstPseudo_$0 implements Vtree.FirstPseudo_$0 {
        readonly outer: FirstPseudo_$0;
        readonly count: number;
        constructor(outer: FirstPseudo_$0, count: number);
    }
    class NodeContext_$0 implements Vtree.NodeContext_$0 {
        sourceNode: Node;
        parent: NodeContext_$0;
        boxOffset: number;
        offsetInNode: number;
        after: boolean;
        shadowType: ShadowType_$0;
        shadowContext: ShadowContext_$0;
        nodeShadow: ShadowContext_$0;
        shadowSibling: NodeContext_$0;
        shared: boolean;
        inline: boolean;
        overflow: boolean;
        breakPenalty: number;
        display: string | null;
        floatReference: PageFloats.FloatReference;
        floatSide: string | null;
        clearSide: string | null;
        floatMinWrapBlock: Css.Numeric | null;
        columnSpan: Css.Val | null;
        verticalAlign: string;
        captionSide: string;
        inlineBorderSpacing: number;
        blockBorderSpacing: number;
        flexContainer: boolean;
        whitespace: Whitespace_$0;
        hyphenateCharacter: string | null;
        breakWord: boolean;
        establishesBFC: boolean;
        containingBlockForAbsolute: boolean;
        breakBefore: string | null;
        breakAfter: string | null;
        viewNode: Node;
        clearSpacer: Node;
        inheritedProps: {
            [key: string]: number | string | Css.Val;
        };
        vertical: boolean;
        direction: string;
        firstPseudo: FirstPseudo_$0;
        lang: string | null;
        preprocessedTextContent: Diff.Change[] | null;
        formattingContext: FormattingContext_$0;
        repeatOnBreak: string | null;
        pluginProps: {
            [key: string]: string | number | undefined | null | (number | null)[];
        };
        fragmentIndex: number;
        afterIfContinues: Selectors.AfterIfContinues;
        footnotePolicy: Css.Ident | null;
        constructor(sourceNode: Node, parent: NodeContext_$0, boxOffset: number);
        resetView(): void;
        private cloneItem;
        modify(): NodeContext_$0;
        copy(): NodeContext_$0;
        clone(): NodeContext_$0;
        toNodePositionStep(): NodePositionStep_$0;
        toNodePosition(): NodePosition_$0;
        isInsideBFC(): boolean;
        getContainingBlockForAbsolute(): NodeContext_$0;
        walkUpBlocks(callback: (p1: NodeContext_$0) => any): void;
        belongsTo(formattingContext: FormattingContext_$0): boolean;
    }
    class ChunkPosition_$0 implements Vtree.ChunkPosition_$0 {
        primary: NodePosition_$0;
        floats: NodePosition_$0[];
        constructor(primary: NodePosition_$0);
        clone(): ChunkPosition_$0;
        isSamePosition(other: ChunkPosition_$0): boolean;
    }
    class FlowChunkPosition {
        chunkPosition: ChunkPosition_$0;
        readonly flowChunk: FlowChunk;
        constructor(chunkPosition: ChunkPosition_$0, flowChunk: FlowChunk);
        clone(): FlowChunkPosition;
        isSamePosition(other: FlowChunkPosition): boolean;
    }
    class FlowPosition {
        positions: FlowChunkPosition[];
        startSide: string;
        breakAfter: string | null;
        clone(): FlowPosition;
        isSamePosition(other: FlowPosition): boolean;
        hasContent(offset: number): boolean;
    }
    class LayoutPosition {
        page: number;
        flows: {
            [key: string]: Flow;
        };
        flowPositions: {
            [key: string]: FlowPosition;
        };
        highestSeenOffset: number;
        highestSeenNode: Node;
        lookupPositionOffset: number;
        clone(): LayoutPosition;
        isSamePosition(other: LayoutPosition): boolean;
        hasContent(name: string, offset: number): boolean;
        startSideOfFlow(name: string): string;
        firstFlowChunkOfFlow(name: string): FlowChunk | null;
    }
    class Container_$0 implements Vtree.Container_$0 {
        element: Element;
        left: number;
        top: number;
        marginLeft: number;
        marginRight: number;
        marginTop: number;
        marginBottom: number;
        borderLeft: number;
        borderRight: number;
        borderTop: number;
        borderBottom: number;
        paddingLeft: number;
        paddingRight: number;
        paddingTop: number;
        paddingBottom: number;
        width: number;
        height: number;
        originX: number;
        originY: number;
        exclusions: GeometryUtil.Shape[];
        innerShape: GeometryUtil.Shape;
        computedBlockSize: number;
        snapWidth: number;
        snapHeight: number;
        snapOffsetX: number;
        snapOffsetY: number;
        vertical: boolean;
        constructor(element: Element);
        getInsetTop(): number;
        getInsetBottom(): number;
        getInsetLeft(): number;
        getInsetRight(): number;
        getInsetBefore(): number;
        getInsetAfter(): number;
        getInsetStart(): number;
        getInsetEnd(): number;
        getBeforeEdge(box: ClientRect_$0): number;
        getAfterEdge(box: ClientRect_$0): number;
        getStartEdge(box: ClientRect_$0): number;
        getEndEdge(box: ClientRect_$0): number;
        getInlineSize(box: ClientRect_$0): number;
        getBoxSize(box: ClientRect_$0): number;
        getBoxDir(): number;
        getInlineDir(): number;
        copyFrom(other: Container_$0): void;
        setVerticalPosition(top: number, height: number): void;
        setHorizontalPosition(left: number, width: number): void;
        setBlockPosition(start: number, extent: number): void;
        setInlinePosition(start: number, extent: number): void;
        clear(): void;
        getInnerShape(): GeometryUtil.Shape;
        getInnerRect(): GeometryUtil.Rect;
        getPaddingRect(): GeometryUtil.Rect;
        getOuterShape(outerShapeProp: Css.Val, context: Exprs.Context): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
    }
    type ExprContentListener_$0 = Vtree.ExprContentListener_$0;
    class ContentPropertyHandler extends Css.Visitor {
        readonly elem: Element;
        readonly context: Exprs.Context;
        readonly rootContentValue: Css.Val;
        readonly exprContentListener: ExprContentListener_$0;
        constructor(elem: Element, context: Exprs.Context, rootContentValue: Css.Val, exprContentListener: ExprContentListener_$0);
        private visitStrInner;
        visitStr(str: Css.Str): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function nonTrivialContent(val: Css.Val): boolean;
}
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace CssCascade_$0 {
    interface ElementStyle_$0 extends CssCascade.ElementStyle_$0 {
    }
    const inheritedProps: {
        azimuth: boolean;
        "border-collapse": boolean;
        "border-spacing": boolean;
        "caption-side": boolean;
        "clip-rule": boolean;
        color: boolean;
        "color-interpolation": boolean;
        "color-rendering": boolean;
        cursor: boolean;
        direction: boolean;
        elevation: boolean;
        "empty-cells": boolean;
        fill: boolean;
        "fill-opacity": boolean;
        "fill-rule": boolean;
        "font-kerning": boolean;
        "font-size": boolean;
        "font-size-adjust": boolean;
        "font-family": boolean;
        "font-feature-settings": boolean;
        "font-style": boolean;
        "font-stretch": boolean;
        "font-variant": boolean;
        "font-weight": boolean;
        "glyph-orientation-vertical": boolean;
        hyphens: boolean;
        "hyphenate-character": boolean;
        "hyphenate-limit-chars": boolean;
        "hyphenate-limit-last": boolean;
        "image-rendering": boolean;
        "image-resolution": boolean;
        "letter-spacing": boolean;
        "line-break": boolean;
        "line-height": boolean;
        "list-style-image": boolean;
        "list-style-position": boolean;
        "list-style-type": boolean;
        marker: boolean;
        "marker-end": boolean;
        "marker-mid": boolean;
        "marker-start": boolean;
        orphans: boolean;
        "overflow-wrap": boolean;
        "paint-order": boolean;
        "pointer-events": boolean;
        "pitch-range": boolean;
        quotes: boolean;
        richness: boolean;
        "ruby-align": boolean;
        "ruby-position": boolean;
        "speak-header": boolean;
        "speak-numeral": boolean;
        "speak-punctuation": boolean;
        "speech-rate": boolean;
        "shape-rendering": boolean;
        stress: boolean;
        stroke: boolean;
        "stroke-dasharray": boolean;
        "stroke-dashoffset": boolean;
        "stroke-linecap": boolean;
        "stroke-linejoin": boolean;
        "stroke-miterlimit": boolean;
        "stroke-opacity": boolean;
        "stroke-width": boolean;
        "tab-size": boolean;
        "text-align": boolean;
        "text-align-last": boolean;
        "text-anchor": boolean;
        "text-decoration-skip": boolean;
        "text-emphasis-color": boolean;
        "text-emphasis-position": boolean;
        "text-emphasis-style": boolean;
        "text-combine-upright": boolean;
        "text-indent": boolean;
        "text-justify": boolean;
        "text-rendering": boolean;
        "text-size-adjust": boolean;
        "text-transform": boolean;
        "text-underline-position": boolean;
        visibility: boolean;
        "voice-family": boolean;
        volume: boolean;
        "white-space": boolean;
        widows: boolean;
        "word-break": boolean;
        "word-spacing": boolean;
        "word-wrap": boolean;
        "writing-mode": boolean;
    };
    const polyfilledInheritedProps: string[];
    function getPolyfilledInheritedProps(): string[];
    const supportedNamespaces: {
        "http://www.idpf.org/2007/ops": boolean;
        "http://www.w3.org/1999/xhtml": boolean;
        "http://www.w3.org/2000/svg": boolean;
    };
    const coupledPatterns: string[];
    const coupledExtentPatterns: string[];
    const geomNames: {
        [key: string]: boolean;
    };
    function buildCouplingMap(sideMap: {
        [key: string]: string;
    }, extentMap: {
        [key: string]: string;
    }): {
        [key: string]: string;
    };
    const couplingMapVert: {
        [key: string]: string;
    };
    const couplingMapHor: {
        [key: string]: string;
    };
    const couplingMapVertRtl: {
        [key: string]: string;
    };
    const couplingMapHorRtl: {
        [key: string]: string;
    };
    class CascadeValue {
        readonly value: Css.Val;
        readonly priority: number;
        constructor(value: Css.Val, priority: number);
        getBaseValue(): CascadeValue;
        filterValue(visitor: Css.Visitor): CascadeValue;
        increaseSpecificity(specificity: number): CascadeValue;
        evaluate(context: Exprs.Context, propName: string): Css.Val;
        isEnabled(context: Exprs.Context): boolean;
    }
    class ConditionalCascadeValue extends CascadeValue {
        readonly condition: Exprs.Val;
        constructor(value: Css.Val, priority: number, condition: Exprs.Val);
        getBaseValue(): CascadeValue;
        filterValue(visitor: Css.Visitor): CascadeValue;
        increaseSpecificity(specificity: number): CascadeValue;
        isEnabled(context: Exprs.Context): boolean;
    }
    function cascadeValues(context: Exprs.Context, tv: CascadeValue, av: CascadeValue): CascadeValue;
    type ElementStyleMap = {
        [key: string]: ElementStyle_$0;
    };
    const SPECIALS: {
        "region-id": boolean;
        "fragment-selector-id": boolean;
    };
    function isSpecialName(name: string): boolean;
    function isMapName(name: string): boolean;
    function isPropName(name: string): boolean;
    function isInherited(name: string): boolean;
    function getProp(style: ElementStyle_$0, name: string): CascadeValue;
    function setProp(style: ElementStyle_$0, name: string, value: CascadeValue): any;
    function getStyleMap(style: ElementStyle_$0, name: string): ElementStyleMap;
    function getMutableStyleMap(style: ElementStyle_$0, name: string): ElementStyleMap;
    const getViewConditionalStyleMap: (style: ElementStyle_$0) => {
        matcher: Matchers.Matcher;
        styles: ElementStyleMap;
    }[];
    function getSpecial(style: ElementStyle_$0, name: string): CascadeValue[];
    function getMutableSpecial(style: ElementStyle_$0, name: string): CascadeValue[];
    function mergeIn(context: Exprs.Context, target: ElementStyle_$0, style: ElementStyle_$0, specificity: number, pseudoelement: string | null, regionId: string | null, viewConditionMatcher: Matchers.Matcher | null): void;
    function mergeAll(context: Exprs.Context, styles: ElementStyle_$0[]): ElementStyle_$0;
    function chainActions(chain: ChainedAction[], action: CascadeAction): CascadeAction;
    class InheritanceVisitor extends Css.FilterVisitor {
        readonly props: ElementStyle_$0;
        readonly context: Exprs.Context;
        propName: string;
        constructor(props: ElementStyle_$0, context: Exprs.Context);
        setPropName(name: string): void;
        private getFontSize;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function convertFontRelativeLengthToPx(numeric: Css.Numeric, baseFontSize: number, context: Exprs.Context): Css.Numeric;
    function convertFontSizeToPx(numeric: Css.Numeric, parentFontSize: number, context: Exprs.Context): Css.Numeric;
    type ActionTable = {
        [key: string]: CascadeAction;
    };
    class CascadeAction {
        apply(cascadeInstance: CascadeInstance): void;
        mergeWith(other: CascadeAction): CascadeAction;
        clone(): CascadeAction;
    }
    class ConditionItemAction extends CascadeAction {
        readonly conditionItem: ConditionItem;
        constructor(conditionItem: ConditionItem);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CompoundAction extends CascadeAction {
        readonly list: CascadeAction[];
        constructor(list: CascadeAction[]);
        apply(cascadeInstance: CascadeInstance): void;
        mergeWith(other: CascadeAction): CascadeAction;
        clone(): CascadeAction;
    }
    class ApplyRuleAction extends CascadeAction {
        readonly style: ElementStyle_$0;
        readonly specificity: number;
        readonly pseudoelement: string | null;
        readonly regionId: string | null;
        readonly viewConditionId: string | null;
        constructor(style: ElementStyle_$0, specificity: number, pseudoelement: string | null, regionId: string | null, viewConditionId: string | null);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class ChainedAction extends CascadeAction {
        chained: CascadeAction;
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckClassAction extends ChainedAction {
        readonly className: string;
        constructor(className: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckIdAction extends ChainedAction {
        readonly id: string;
        constructor(id: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckLocalNameAction extends ChainedAction {
        readonly localName: string;
        constructor(localName: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckNSTagAction extends ChainedAction {
        readonly ns: string;
        readonly localName: string;
        constructor(ns: string, localName: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckTargetEpubTypeAction extends ChainedAction {
        readonly epubTypePatt: RegExp;
        constructor(epubTypePatt: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckNamespaceAction extends ChainedAction {
        readonly ns: string;
        constructor(ns: string);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckAttributePresentAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        constructor(ns: string, name: string);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckAttributeEqAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        readonly value: string;
        constructor(ns: string, name: string, value: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckNamespaceSupportedAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        constructor(ns: string, name: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckAttributeRegExpAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        readonly regexp: RegExp;
        constructor(ns: string, name: string, regexp: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckLangAction extends ChainedAction {
        readonly langRegExp: RegExp;
        constructor(langRegExp: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class IsFirstAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsRootAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthAction extends ChainedAction {
        readonly a: number;
        readonly b: number;
        constructor(a: number, b: number);
        matchANPlusB(order: number): boolean;
    }
    class IsNthSiblingAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthSiblingOfTypeAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthLastSiblingAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthLastSiblingOfTypeAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsEmptyAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsEnabledAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsDisabledAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsCheckedAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class CheckConditionAction extends ChainedAction {
        readonly condition: string;
        constructor(condition: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class CheckAppliedAction extends CascadeAction {
        applied: boolean;
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        clone(): CascadeAction;
    }
    class NegateActionsSet extends ChainedAction {
        checkAppliedAction: CheckAppliedAction;
        firstAction: CascadeAction;
        constructor(list: ChainedAction[]);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    interface ConditionItem {
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AbstractConditionItem {
        readonly condition: string;
        readonly viewConditionId: string | null;
        readonly viewCondition: Matchers.Matcher;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        increment(cascadeInstance: CascadeInstance): void;
        decrement(cascadeInstance: CascadeInstance): void;
        buildViewConditionMatcher(cascadeInstance: CascadeInstance): Matchers.Matcher;
    }
    class DescendantConditionItem extends AbstractConditionItem implements ConditionItem {
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class ChildConditionItem extends AbstractConditionItem implements ConditionItem {
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AdjacentSiblingConditionItem extends AbstractConditionItem implements ConditionItem {
        fired: boolean;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class FollowingSiblingConditionItem extends AbstractConditionItem implements ConditionItem {
        fired: boolean;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AfterPseudoelementItem implements ConditionItem {
        readonly afterprop: ElementStyle_$0;
        readonly element: Element;
        constructor(afterprop: ElementStyle_$0, element: Element);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class RestoreLangItem implements ConditionItem {
        readonly lang: string;
        constructor(lang: string);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class QuotesScopeItem implements ConditionItem {
        readonly oldQuotes: Css.Str[];
        constructor(oldQuotes: Css.Str[]);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    type CounterValues = {
        [key: string]: number[];
    };
    interface CounterListener {
        countersOfId(id: string, counters: CounterValues): any;
        getExprContentListener(): Vtree_$0.ExprContentListener;
    }
    interface CounterResolver {
        getPageCounterVal(name: string, format: (p1: number | null) => string): Exprs.Val;
        getPageCountersVal(name: string, format: (p1: number[]) => string): Exprs.Val;
        getTargetCounterVal(url: string, name: string, format: (p1: number | null) => string): Exprs.Val;
        getTargetCountersVal(url: string, name: string, format: (p1: number[]) => string): Exprs.Val;
        setStyler(styler: any): any;
    }
    class AttrValueFilterVisitor extends Css.FilterVisitor {
        element: Element;
        constructor(element: Element);
        private createValueFromString;
        visitFunc(func: Css.Func): Css.Val;
    }
    class ContentPropVisitor extends Css.FilterVisitor {
        cascade: CascadeInstance;
        element: Element;
        readonly counterResolver: CounterResolver;
        constructor(cascade: CascadeInstance, element: Element, counterResolver: CounterResolver);
        visitIdent(ident: Css.Ident): Css.Val;
        private format;
        visitFuncCounter(values: Css.Val[]): Css.Val;
        visitFuncCounters(values: Css.Val[]): Css.Val;
        visitFuncTargetCounter(values: Css.Val[]): Css.Val;
        visitFuncTargetCounters(values: Css.Val[]): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
    }
    function roman(num: number): string;
    const additiveNumbering: {
        roman: (string | number)[];
        armenian: (string | number)[];
        georgian: (string | number)[];
        hebrew: (string | number)[];
    };
    const alphabeticNumbering: {
        latin: string;
        alpha: string;
        greek: string;
        russian: string;
    };
    const fixed: {
        square: string;
        disc: string;
        circle: string;
        none: string;
    };
    function additiveFormat(entries: any[], num: number): string;
    function expandAlphabet(str: string): string[] | null;
    function alphabeticFormat(alphabetStr: string, num: number): string;
    type ChineseNumbering = {
        digits: string;
        markers: string;
        negative: string;
        formal: boolean;
    };
    const chineseTradInformal: ChineseNumbering;
    function chineseCounter(num: number, numbering: ChineseNumbering): string;
    const ORDER_INCREMENT: number;
    function copyTable(src: ActionTable, dst: ActionTable): void;
    class Cascade {
        nsCount: number;
        nsPrefix: {
            [key: string]: string;
        };
        tags: ActionTable;
        nstags: ActionTable;
        epubtypes: ActionTable;
        classes: ActionTable;
        ids: ActionTable;
        pagetypes: ActionTable;
        order: number;
        clone(): Cascade;
        insertInTable(table: ActionTable, key: string, action: CascadeAction): void;
        createInstance(context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: any): CascadeInstance;
        nextOrder(): number;
    }
    class CascadeInstance {
        readonly context: Exprs.Context;
        readonly counterListener: CounterListener;
        readonly counterResolver: CounterResolver;
        code: Cascade;
        stack: ConditionItem[][];
        conditions: {
            [key: string]: number;
        };
        currentElement: Element | null;
        currentElementOffset: number | null;
        currentStyle: ElementStyle_$0 | null;
        currentClassNames: string[] | null;
        currentLocalName: string;
        currentNamespace: string;
        currentId: string;
        currentXmlId: string;
        currentNSTag: string;
        currentEpubTypes: string[] | null;
        currentPageType: string | null;
        isFirst: boolean;
        isRoot: boolean;
        counters: {
            [key: string]: number[];
        };
        counterScoping: {
            [key: string]: boolean;
        }[];
        quotes: Css.Str[];
        quoteDepth: number;
        lang: string;
        siblingOrderStack: number[];
        currentSiblingOrder: number;
        siblingTypeCountsStack: {
            [key: string]: {
                [key: string]: number;
            };
        }[];
        currentSiblingTypeCounts: {
            [key: string]: {
                [key: string]: number;
            };
        };
        currentFollowingSiblingOrder: number | null;
        followingSiblingOrderStack: (number | null)[];
        followingSiblingTypeCountsStack: {
            [key: string]: {
                [key: string]: number;
            };
        }[];
        currentFollowingSiblingTypeCounts: {
            [key: string]: {
                [key: string]: number;
            };
        };
        viewConditions: {
            [key: string]: Matchers.Matcher[];
        };
        dependentConditions: string[];
        elementStack: Element[];
        currentDoc?: Document | null;
        constructor(cascade: Cascade, context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: string);
        pushConditionItem(item: ConditionItem): void;
        increment(condition: string, viewCondition: Matchers.Matcher): void;
        decrement(condition: string, viewCondition: Matchers.Matcher): void;
        buildViewConditionMatcher(viewConditionId: string | null): Matchers.Matcher;
        applyAction(table: ActionTable, key: string): void;
        pushRule(classes: string[], pageType: string | null, baseStyle: ElementStyle_$0): void;
        defineCounter(counterName: string, value: number): void;
        pushCounters(props: ElementStyle_$0): void;
        popCounters(): void;
        processPseudoelementProps(pseudoprops: ElementStyle_$0, element: Element): void;
        pushElement(element: Element, baseStyle: ElementStyle_$0, elementOffset: number): void;
        private applyAttrFilterInner;
        private applyAttrFilter;
        private applyActions;
        private pop;
        popRule(): void;
        popElement(element: Element): void;
    }
    const EMPTY: any[];
    const pseudoNames: string[];
    enum ParseState {
        TOP = 0,
        SELECTOR = 1,
        RULE = 2
    }
    let uaBaseCascade: Cascade;
    function setUABaseCascade(value: Cascade): void;
    class CascadeParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
        readonly condition: Exprs.Val;
        readonly regionId: string | null;
        readonly validatorSet: CssValidator.ValidatorSet;
        chain: ChainedAction[];
        specificity: number;
        elementStyle: ElementStyle_$0;
        conditionCount: number;
        pseudoelement: string | null;
        footnoteContent: boolean;
        cascade: Cascade;
        state: ParseState;
        viewConditionId: string | null;
        insideSelectorRule: ParseState;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, condition: Exprs.Val, parent: CascadeParserHandler, regionId: string | null, validatorSet: CssValidator.ValidatorSet, topLevel: boolean);
        insertNonPrimary(action: CascadeAction): void;
        processChain(action: CascadeAction): void;
        isInsideSelectorRule(mnemonics: string): boolean;
        tagSelector(ns: string | null, name: string | null): void;
        classSelector(name: string): void;
        pseudoclassSelector(name: string, params: (number | string)[]): void;
        pseudoelementSelector(name: string, params: (number | string)[]): void;
        idSelector(id: string): void;
        attributeSelector(ns: string, name: string, op: CssTokenizer.TokenType, value: string | null): void;
        descendantSelector(): void;
        childSelector(): void;
        adjacentSiblingSelector(): void;
        followingSiblingSelector(): void;
        nextSelector(): void;
        startSelectorRule(): void;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        startStylesheet(flavor: CssParser.StylesheetFlavor): void;
        startRuleBody(): void;
        endRule(): void;
        finishChain(): void;
        makeApplyRuleAction(specificity: number): ApplyRuleAction;
        special(name: string, value: Css.Val): void;
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
        finish(): Cascade;
        startFuncWithSelector(funcName: string): void;
    }
    const nthSelectorActionClasses: {
        [key: string]: typeof IsNthAction;
    };
    let conditionCount: number;
    class NotParameterParserHandler extends CascadeParserHandler {
        readonly parent: CascadeParserHandler;
        parentChain: ChainedAction[];
        constructor(parent: CascadeParserHandler);
        startFuncWithSelector(funcName: string): void;
        startRuleBody(): void;
        nextSelector(): void;
        endFuncWithSelector(): void;
        error(mnemonics: string, token: CssTokenizer.Token): void;
    }
    class DefineParserHandler extends CssParser.SlaveParserHandler {
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler);
        property(name: string, value: Css.Val, important: boolean): void;
    }
    class PropSetParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
        readonly condition: Exprs.Val;
        readonly elementStyle: ElementStyle_$0;
        readonly validatorSet: CssValidator.ValidatorSet;
        order: number;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, condition: Exprs.Val, elementStyle: ElementStyle_$0, validatorSet: CssValidator.ValidatorSet);
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    class PropertyParserHandler extends CssParser.ErrorHandler implements CssValidator.PropertyReceiver {
        readonly validatorSet: CssValidator.ValidatorSet;
        elementStyle: ElementStyle_$0;
        order: number;
        constructor(scope: Exprs.LexicalScope, validatorSet: CssValidator.ValidatorSet);
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    function forEachViewConditionalStyles(style: ElementStyle_$0, callback: (p1: ElementStyle_$0) => any): void;
    function mergeViewConditionalStyles(cascMap: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, style: ElementStyle_$0): void;
    function parseStyleAttribute_$0(scope: Exprs.LexicalScope, validatorSet: CssValidator.ValidatorSet, baseURL: string, styleAttrValue: string): ElementStyle_$0;
    function isVertical(cascaded: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, vertical: boolean): boolean;
    function isRtl(cascaded: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, rtl: boolean): boolean;
    function flattenCascadedStyle(style: ElementStyle_$0, context: Exprs.Context, regionIds: string[], isFootnote: boolean, nodeContext: Vtree_$0.NodeContext): {
        [key: string]: CascadeValue;
    };
    function forEachStylesInRegion(style: ElementStyle_$0, regionIds: string[], isFootnote: boolean, callback: (p1: string, p2: ElementStyle_$0) => any): void;
    function mergeStyle(to: {
        [key: string]: CascadeValue;
    }, from: ElementStyle_$0, context: Exprs.Context): void;
    const convertToPhysical: <T>(src: {
        [key: string]: CascadeValue;
    }, dest: {
        [key: string]: T;
    }, vertical: boolean, rtl: boolean, transform: (p1: string, p2: CascadeValue) => T) => void;
}
declare namespace CssValidator {
    interface PropertyReceiver {
        unknownProperty(name: string, value: Css.Val): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    class Node {
        validator: PropertyValidator;
        success: Node;
        failure: Node;
        code: number;
        constructor(validator: PropertyValidator);
        isSpecial(): boolean;
        markAsStartGroup(): void;
        isStartGroup(): boolean;
        markAsEndGroup(): void;
        isEndGroup(): boolean;
        markAsStartAlternate(index: number): void;
        isStartAlternate(): boolean;
        markAsEndAlternate(index: number): void;
        isEndAlternate(): boolean;
        getAlternate(): number;
    }
    class Connection {
        where: number;
        success: boolean;
        what: number;
        constructor(where: number, success: boolean);
    }
    enum Add_$0 {
        FOLLOW = 1,
        OPTIONAL = 2,
        REPEATED = 3,
        ALTERNATE = 4
    }
    class ValidatingGroup {
        nodes: Node[];
        connections: Connection[];
        match: number[];
        nomatch: number[];
        error: number[];
        emptyHead: boolean;
        connect(arr: number[], nodeIndex: number): void;
        clone(): ValidatingGroup;
        private addSpecialToArr;
        endSpecialGroup(): void;
        startSpecialGroup(): void;
        endClause(clause: number): void;
        startClause(clause: number): void;
        addPrimitive(validator: PropertyValidator): void;
        isSimple(): boolean;
        isPrimitive(): boolean;
        addGroup(group: ValidatingGroup, how: Add_$0): void;
        finish(successTerminal: Node, failTerminal: Node): Node;
    }
    const ALLOW_EMPTY = 1;
    const ALLOW_STR = 2;
    const ALLOW_IDENT = 4;
    const ALLOW_POS_NUMERIC = 8;
    const ALLOW_POS_NUM = 16;
    const ALLOW_POS_INT = 32;
    const ALLOW_COLOR = 64;
    const ALLOW_URL = 128;
    const ALLOW_NEGATIVE = 256;
    const ALLOW_ZERO = 512;
    const ALLOW_ZERO_PERCENT = 1024;
    const ALLOW_SLASH = 2048;
    type ValueMap = {
        [key: string]: Css.Val;
    };
    class PropertyValidator extends Css.Visitor {
        constructor();
        validateForShorthand(values: Css.Val[], index: number): Css.Val[];
    }
    class PrimitiveValidator extends PropertyValidator {
        readonly allowed: number;
        readonly idents: ValueMap;
        readonly units: ValueMap;
        constructor(allowed: number, idents: ValueMap, units: ValueMap);
        visitEmpty(empty: Css.Val): Css.Val;
        visitSlash(slash: Css.Val): Css.Val;
        visitStr(str: Css.Str): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitNum(num: Css.Num): Css.Val;
        visitInt(num: Css.Int): Css.Val;
        visitColor(color: Css.Color): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
        combine(other: PrimitiveValidator): PrimitiveValidator;
    }
    const ALWAYS_FAIL: PrimitiveValidator;
    class ListValidator extends PropertyValidator {
        successTerminal: Node;
        failureTerminal: Node;
        first: Node;
        constructor(group: ValidatingGroup);
        validateList(arr: Css.Val[], slice: boolean, startIndex: number): Css.Val[];
        validateSingle(inval: Css.Val): Css.Val;
        visitEmpty(empty: Css.Val): Css.Val;
        visitSlash(slash: Css.Val): Css.Val;
        visitStr(str: Css.Str): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitNum(num: Css.Num): Css.Val;
        visitInt(num: Css.Int): Css.Val;
        visitColor(color: Css.Color): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    class SpaceListValidator extends ListValidator {
        constructor(group: ValidatingGroup);
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        validateForShorthand(values: Css.Val[], index: number): Css.Val[];
    }
    class CommaListValidator extends ListValidator {
        constructor(group: ValidatingGroup);
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        validateForShorthand(values: Css.Val[], index: number): Css.Val[];
    }
    class FuncValidator extends ListValidator {
        readonly name: string;
        constructor(name: string, group: ValidatingGroup);
        validateSingle(inval: Css.Val): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
    }
    class ShorthandSyntaxNode {
        tryParse(values: Css.Val[], index: number, shorthandValidator: ShorthandValidator): number;
        success(rval: Css.Val, shorthandValidator: ShorthandValidator): void;
    }
    class ShorthandSyntaxProperty extends ShorthandSyntaxNode {
        readonly name: string;
        validator: PropertyValidator;
        constructor(validatorSet: ValidatorSet, name: string);
        tryParse(values: Css.Val[], index: number, shorthandValidator: ShorthandValidator): number;
        success(rval: Css.Val, shorthandValidator: ShorthandValidator): void;
    }
    class ShorthandSyntaxPropertyN extends ShorthandSyntaxProperty {
        readonly names: string[];
        constructor(validatorSet: ValidatorSet, names: string[]);
        success(rval: Css.Val, shorthandValidator: ShorthandValidator): void;
    }
    class ShorthandSyntaxCompound extends ShorthandSyntaxNode {
        readonly nodes: ShorthandSyntaxNode[];
        readonly slash: boolean;
        constructor(nodes: ShorthandSyntaxNode[], slash: boolean);
        tryParse(values: Css.Val[], index: number, shorthandValidator: ShorthandValidator): number;
    }
    class ShorthandValidator extends Css.Visitor {
        syntax: ShorthandSyntaxNode[];
        propList: string[];
        error: boolean;
        values: ValueMap;
        validatorSet: ValidatorSet;
        setOwner(validatorSet: ValidatorSet): void;
        syntaxNodeForProperty(name: string): ShorthandSyntaxNode;
        clone(): this;
        init(syntax: ShorthandSyntaxNode[], propList: string[]): void;
        finish(important: boolean, receiver: PropertyReceiver): boolean;
        propagateInherit(important: boolean, receiver: PropertyReceiver): void;
        validateList(list: Css.Val[]): number;
        validateSingle(val: Css.Val): Css.Val;
        visitEmpty(empty: Css.Val): Css.Val;
        visitStr(str: Css.Str): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitNum(num: Css.Num): Css.Val;
        visitInt(num: Css.Int): Css.Val;
        visitColor(color: Css.Color): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    class SimpleShorthandValidator extends ShorthandValidator {
        constructor();
        validateList(list: Css.Val[]): number;
    }
    class InsetsShorthandValidator extends ShorthandValidator {
        constructor();
        validateList(list: Css.Val[]): number;
        createSyntaxNode(): ShorthandSyntaxPropertyN;
    }
    class InsetsSlashShorthandValidator extends ShorthandValidator {
        constructor();
        validateList(list: Css.Val[]): number;
    }
    class CommaShorthandValidator extends SimpleShorthandValidator {
        constructor();
        mergeIn(acc: {
            [key: string]: Css.Val[];
        }, values: ValueMap): void;
        visitCommaList(list: Css.CommaList): Css.Val;
    }
    class FontShorthandValidator extends SimpleShorthandValidator {
        constructor();
        init(syntax: ShorthandSyntaxNode[], propList: string[]): void;
        validateList(list: Css.Val[]): number;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
    }
    const shorthandValidators: {
        [key: string]: typeof ShorthandValidator;
    };
    class ValidatorSet {
        validators: {
            [key: string]: PropertyValidator;
        };
        prefixes: {
            [key: string]: {
                [key: string]: boolean;
            };
        };
        defaultValues: ValueMap;
        namedValidators: {
            [key: string]: ValidatingGroup;
        };
        systemFonts: {
            [key: string]: ValueMap;
        };
        shorthands: {
            [key: string]: ShorthandValidator;
        };
        layoutProps: ValueMap;
        backgroundProps: ValueMap;
        private addReplacement;
        private newGroup;
        private addCounts;
        private primitive;
        private newFunc;
        initBuiltInValidators(): void;
        private isBuiltIn;
        private readNameAndPrefixes;
        private parseValidators;
        private parseDefaults;
        private parseShorthands;
        parse(text: string): void;
        makePropSet(propList: string[]): ValueMap;
        validatePropertyAndHandleShorthand(name: string, value: Css.Val, important: boolean, receiver: PropertyReceiver): void;
    }
    function baseValidatorSet(): ValidatorSet;
}
declare namespace Exprs {
    type Preferences = {
        fontFamily: string;
        lineHeight: number;
        margin: number;
        hyphenate: boolean;
        columnWidth: number;
        horizontal: boolean;
        nightMode: boolean;
        spreadView: boolean;
        pageBorder: number;
        enabledMediaTypes: {
            [key: string]: boolean;
        };
        defaultPaperSize?: {
            [key: string]: number;
        };
    };
    function defaultPreferences(): Preferences;
    function clonePreferences(pref: Preferences): Preferences;
    const defaultPreferencesInstance: Preferences;
    const Special: {
        PENDING: Pending;
    };
    type Result = string | number | boolean | undefined;
    type PendingResult = Special | Result;
    function letterbox(viewW: number, viewH: number, objW: number, objH: number): string;
    function cssString(str: string): string;
    function cssIdent(name: string): string;
    function makeQualifiedName(objName: string | null, memberName: string): string;
    let nextKeyIndex: number;
    class LexicalScope {
        parent: LexicalScope;
        resolver?: (p1: string, p2: boolean) => Val;
        scopeKey: string;
        children: LexicalScope[];
        zero: Const;
        one: Const;
        _true: Const;
        _false: Const;
        values: {
            [key: string]: Val;
        };
        funcs: {
            [key: string]: Val;
        };
        builtIns: {
            [key: string]: (...p1: Result[]) => Result;
        };
        constructor(parent: LexicalScope, resolver?: (p1: string, p2: boolean) => Val);
        defineBuiltInName(name: string, fn: () => Result): void;
        defineName(qualifiedName: string, val: Val): void;
        defineFunc(qualifiedName: string, val: Val): void;
        defineBuiltIn(qualifiedName: string, fn: (...p1: Result[]) => Result): void;
    }
    function isAbsoluteLengthUnit(unit: string): boolean;
    function isViewportRelativeLengthUnit(unit: string): boolean;
    function isFontRelativeLengthUnit(unit: string): boolean;
    const defaultUnitSizes: {
        [key: string]: number;
    };
    function needUnitConversion(unit: string): boolean;
    type ScopeContext = {
        [key: string]: Result;
    };
    class Context {
        readonly rootScope: LexicalScope;
        readonly viewportWidth: number;
        readonly viewportHeight: number;
        protected actualPageWidth: number | null;
        pageWidth: () => number;
        protected actualPageHeight: number | null;
        pageHeight: () => number;
        initialFontSize: number;
        rootFontSize: number | null;
        fontSize: () => number;
        pref: Preferences;
        scopes: {
            [key: string]: ScopeContext;
        };
        pageAreaWidth: number | null;
        pageAreaHeight: number | null;
        pageVertical: boolean | null;
        pubTitle: string | null;
        docTitle: string | null;
        constructor(rootScope: LexicalScope, viewportWidth: number, viewportHeight: number, fontSize: number);
        private getScopeContext;
        clearScope(scope: LexicalScope): void;
        queryUnitSize(unit: string, isRoot: boolean): number;
        evalName(scope: LexicalScope, qualifiedName: string): Val;
        evalCall(scope: LexicalScope, qualifiedName: string, params: Val[], noBuiltInEval: boolean): Val;
        evalMediaName(name: string, not: boolean): boolean;
        evalMediaTest(feature: string, value: Val): boolean;
        queryVal(scope: LexicalScope, key: string): Result | undefined;
        storeVal(scope: LexicalScope, key: string, val: Result): void;
    }
    type DependencyCache = {
        [key: string]: boolean | Special;
    };
    class Val {
        scope: LexicalScope;
        key: string;
        constructor(scope: LexicalScope);
        toString(): string;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        expand(context: Context, params: Val[]): Val;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        dependOuter(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        depend(other: Val, context: Context): boolean;
        evaluate(context: Context): Result;
        isMediaName(): boolean;
    }
    class Prefix extends Val {
        val: Val;
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Infix extends Val {
        lhs: Val;
        rhs: Val;
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Logical extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Comparison extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Additive extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Multiplicative extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Not extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class Negate extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class And extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class AndMedia extends And {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Or extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class OrMedia extends Or {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Lt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Le extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Gt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ge extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Eq extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ne extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Add extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Subtract extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Multiply extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Divide extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Modulo extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Numeric extends Val {
        num: number;
        unit: string;
        constructor(scope: LexicalScope, num: number, unit: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class Named extends Val {
        qualifiedName: string;
        constructor(scope: LexicalScope, qualifiedName: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    }
    class MediaName extends Val {
        not: boolean;
        name: string;
        value: Val;
        constructor(scope: LexicalScope, not: boolean, name: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        isMediaName(): boolean;
    }
    class Native extends Val {
        fn: () => Result;
        str: string;
        constructor(scope: LexicalScope, fn: () => Result, str: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    function appendValArray(buf: Base.StringBuffer, arr: Val[]): void;
    function expandValArray(context: Context, arr: Val[], params: Val[]): Val[];
    function evalValArray(context: Context, arr: Val[]): Result[];
    class Call extends Val {
        qualifiedName: string;
        params: Val[];
        constructor(scope: LexicalScope, qualifiedName: string, params: Val[]);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Cond extends Val {
        cond: Val;
        ifTrue: Val;
        ifFalse: Val;
        constructor(scope: LexicalScope, cond: Val, ifTrue: Val, ifFalse: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Const extends Val {
        val: Result;
        constructor(scope: LexicalScope, val: Result);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class MediaTest extends Val {
        name: MediaName;
        value: Val;
        constructor(scope: LexicalScope, name: MediaName, value: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Param extends Val {
        index: number;
        constructor(scope: LexicalScope, index: number);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    function and(scope: LexicalScope, v1: Val, v2: Val): Val;
    function add(scope: LexicalScope, v1: Val, v2: Val): Val;
    function sub(scope: LexicalScope, v1: Val, v2: Val): Val;
    function mul(scope: LexicalScope, v1: Val, v2: Val): Val;
    function div(scope: LexicalScope, v1: Val, v2: Val): Val;
}
declare namespace Vtree_$0 {
    const delayedProps: {
        transform: boolean;
        "transform-origin": boolean;
    };
    const delayedPropsIfRelativePositioned: {
        top: boolean;
        bottom: boolean;
        left: boolean;
        right: boolean;
    };
    class DelayedItem {
        target: Element;
        name: string;
        value: Css.Val;
        constructor(target: Element, name: string, value: Css.Val);
    }
    type PageHyperlinkEvent = {
        type: string;
        target: any;
        currentTarget: any;
        anchorElement: Element;
        href: string;
    };
    type Trigger = {
        observer: string;
        event: string;
        action: string;
        ref: string;
    };
    const actions: {
        show: (obj: any) => void;
        hide: (obj: any) => void;
        play: (obj: any) => void;
        pause: (obj: any) => void;
        resume: (obj: any) => void;
        mute: (obj: any) => void;
        unmute: (obj: any) => void;
    };
    function makeListener(refs: Element[], action: string): EventListener | null;
    class Page extends Base.SimpleEventTarget {
        readonly container: HTMLElement;
        readonly bleedBox: HTMLElement;
        private static AUTO_PAGE_WIDTH_ATTRIBUTE;
        private static AUTO_PAGE_HEIGHT_ATTRIBUTE;
        pageAreaElement: HTMLElement | null;
        delayedItems: DelayedItem[];
        hrefHandler: (e: Event) => void;
        elementsById: {
            [key: string]: Element[];
        };
        dimensions: {
            width: number;
            height: number;
        };
        isFirstPage: boolean;
        isLastPage: boolean;
        isAutoPageWidth: boolean;
        isAutoPageHeight: boolean;
        spineIndex: number;
        position: LayoutPosition;
        offset: number;
        side: Constants.PageSide | null;
        fetchers: TaskUtil.Fetcher<{}>[];
        marginBoxes: {
            top: {
                [key: string]: Container_$0;
            };
            bottom: {
                [key: string]: Container_$0;
            };
            left: {
                [key: string]: Container_$0;
            };
            right: {
                [key: string]: Container_$0;
            };
        };
        constructor(container: HTMLElement, bleedBox: HTMLElement);
        setAutoPageWidth(isAuto: boolean): void;
        setAutoPageHeight(isAuto: boolean): void;
        registerElementWithId(element: Element, id: string): void;
        finish(triggers: Trigger[], clientLayout: ClientLayout_$0): void;
        zoom(scale: number): void;
        getPageAreaElement(): HTMLElement;
    }
    type Spread = {
        left: Page;
        right: Page;
    };
    const SPECIAL_ATTR = "data-adapt-spec";
    const Whitespace_$0: typeof Vtree.Whitespace_$0;
    type Whitespace_$0 = Vtree.Whitespace_$0;
    function whitespaceFromPropertyValue(whitespace: string): Whitespace_$0 | null;
    function canIgnore(node: Node, whitespace: Whitespace_$0): boolean;
    class Flow {
        readonly flowName: string;
        readonly parentFlowName: string | null;
        forcedBreakOffsets: number[];
        formattingContext: FormattingContext_$0 | null;
        constructor(flowName: string, parentFlowName: string | null);
    }
    class FlowChunk {
        flowName: string;
        element: Element;
        startOffset: number;
        priority: number;
        linger: number;
        exclusive: boolean;
        repeated: boolean;
        last: boolean;
        breakBefore: string | null;
        startPage: number;
        constructor(flowName: string, element: Element, startOffset: number, priority: number, linger: number, exclusive: boolean, repeated: boolean, last: boolean, breakBefore: string | null);
        isBetter(other: FlowChunk): boolean;
    }
    type ClientRect_$0 = Vtree.ClientRect_$0;
    function clientrectIncreasingTop(r1: ClientRect_$0, r2: ClientRect_$0): number;
    function clientrectDecreasingRight(r1: ClientRect_$0, r2: ClientRect_$0): number;
    type ClientLayout_$0 = Vtree.ClientLayout_$0;
    type LayoutContext_$0 = Vtree.LayoutContext_$0;
    type FormattingContext_$0 = Vtree.FormattingContext_$0;
    function eachAncestorFormattingContext(nodeContext: NodeContext_$0, callback: (p1: FormattingContext_$0) => any): void;
    type NodePositionStep_$0 = Vtree.NodePositionStep_$0;
    function isSameNodePositionStep(nps1: NodePositionStep_$0, nps2: NodePositionStep_$0): boolean;
    type NodePosition_$0 = Vtree.NodePosition_$0;
    function isSameNodePosition(np1: NodePosition_$0 | null, np2: NodePosition_$0 | null): boolean;
    function newNodePositionFromNode(node: Node): NodePosition_$0;
    function newNodePositionFromNodeContext(nodeContext: Vtree.NodeContext_$0, initialFragmentIndex: number | null): NodePosition_$0;
    function makeNodeContextFromNodePositionStep(step: NodePositionStep_$0, parent: Vtree.NodeContext_$0): NodeContext_$0;
    const ShadowType_$0: typeof Vtree.ShadowType_$0;
    type ShadowType_$0 = Vtree.ShadowType_$0;
    class ShadowContext_$0 implements Vtree.ShadowContext_$0 {
        readonly owner: Element;
        readonly root: Element;
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly parentShadow: ShadowContext_$0;
        readonly type: ShadowType_$0;
        readonly styler: object;
        subShadow: ShadowContext_$0;
        constructor(owner: Element, root: Element, xmldoc: XmlDoc.XMLDocHolder, parentShadow: ShadowContext_$0, superShadow: ShadowContext_$0, type: ShadowType_$0, styler: object);
        equals(other: ShadowContext_$0): boolean;
    }
    function isSameShadowContext(sc1: ShadowContext_$0, sc2: ShadowContext_$0): boolean;
    class FirstPseudo_$0 implements Vtree.FirstPseudo_$0 {
        readonly outer: FirstPseudo_$0;
        readonly count: number;
        constructor(outer: FirstPseudo_$0, count: number);
    }
    class NodeContext_$0 implements Vtree.NodeContext_$0 {
        sourceNode: Node;
        parent: NodeContext_$0;
        boxOffset: number;
        offsetInNode: number;
        after: boolean;
        shadowType: ShadowType_$0;
        shadowContext: ShadowContext_$0;
        nodeShadow: ShadowContext_$0;
        shadowSibling: NodeContext_$0;
        shared: boolean;
        inline: boolean;
        overflow: boolean;
        breakPenalty: number;
        display: string | null;
        floatReference: PageFloats.FloatReference;
        floatSide: string | null;
        clearSide: string | null;
        floatMinWrapBlock: Css.Numeric | null;
        columnSpan: Css.Val | null;
        verticalAlign: string;
        captionSide: string;
        inlineBorderSpacing: number;
        blockBorderSpacing: number;
        flexContainer: boolean;
        whitespace: Whitespace_$0;
        hyphenateCharacter: string | null;
        breakWord: boolean;
        establishesBFC: boolean;
        containingBlockForAbsolute: boolean;
        breakBefore: string | null;
        breakAfter: string | null;
        viewNode: Node;
        clearSpacer: Node;
        inheritedProps: {
            [key: string]: number | string | Css.Val;
        };
        vertical: boolean;
        direction: string;
        firstPseudo: FirstPseudo_$0;
        lang: string | null;
        preprocessedTextContent: Diff.Change[] | null;
        formattingContext: FormattingContext_$0;
        repeatOnBreak: string | null;
        pluginProps: {
            [key: string]: string | number | undefined | null | (number | null)[];
        };
        fragmentIndex: number;
        afterIfContinues: Selectors.AfterIfContinues;
        footnotePolicy: Css.Ident | null;
        constructor(sourceNode: Node, parent: NodeContext_$0, boxOffset: number);
        resetView(): void;
        private cloneItem;
        modify(): NodeContext_$0;
        copy(): NodeContext_$0;
        clone(): NodeContext_$0;
        toNodePositionStep(): NodePositionStep_$0;
        toNodePosition(): NodePosition_$0;
        isInsideBFC(): boolean;
        getContainingBlockForAbsolute(): NodeContext_$0;
        walkUpBlocks(callback: (p1: NodeContext_$0) => any): void;
        belongsTo(formattingContext: FormattingContext_$0): boolean;
    }
    class ChunkPosition_$0 implements Vtree.ChunkPosition_$0 {
        primary: NodePosition_$0;
        floats: NodePosition_$0[];
        constructor(primary: NodePosition_$0);
        clone(): ChunkPosition_$0;
        isSamePosition(other: ChunkPosition_$0): boolean;
    }
    class FlowChunkPosition {
        chunkPosition: ChunkPosition_$0;
        readonly flowChunk: FlowChunk;
        constructor(chunkPosition: ChunkPosition_$0, flowChunk: FlowChunk);
        clone(): FlowChunkPosition;
        isSamePosition(other: FlowChunkPosition): boolean;
    }
    class FlowPosition {
        positions: FlowChunkPosition[];
        startSide: string;
        breakAfter: string | null;
        clone(): FlowPosition;
        isSamePosition(other: FlowPosition): boolean;
        hasContent(offset: number): boolean;
    }
    class LayoutPosition {
        page: number;
        flows: {
            [key: string]: Flow;
        };
        flowPositions: {
            [key: string]: FlowPosition;
        };
        highestSeenOffset: number;
        highestSeenNode: Node;
        lookupPositionOffset: number;
        clone(): LayoutPosition;
        isSamePosition(other: LayoutPosition): boolean;
        hasContent(name: string, offset: number): boolean;
        startSideOfFlow(name: string): string;
        firstFlowChunkOfFlow(name: string): FlowChunk | null;
    }
    class Container_$0 implements Vtree.Container_$0 {
        element: Element;
        left: number;
        top: number;
        marginLeft: number;
        marginRight: number;
        marginTop: number;
        marginBottom: number;
        borderLeft: number;
        borderRight: number;
        borderTop: number;
        borderBottom: number;
        paddingLeft: number;
        paddingRight: number;
        paddingTop: number;
        paddingBottom: number;
        width: number;
        height: number;
        originX: number;
        originY: number;
        exclusions: GeometryUtil.Shape[];
        innerShape: GeometryUtil.Shape;
        computedBlockSize: number;
        snapWidth: number;
        snapHeight: number;
        snapOffsetX: number;
        snapOffsetY: number;
        vertical: boolean;
        constructor(element: Element);
        getInsetTop(): number;
        getInsetBottom(): number;
        getInsetLeft(): number;
        getInsetRight(): number;
        getInsetBefore(): number;
        getInsetAfter(): number;
        getInsetStart(): number;
        getInsetEnd(): number;
        getBeforeEdge(box: ClientRect_$0): number;
        getAfterEdge(box: ClientRect_$0): number;
        getStartEdge(box: ClientRect_$0): number;
        getEndEdge(box: ClientRect_$0): number;
        getInlineSize(box: ClientRect_$0): number;
        getBoxSize(box: ClientRect_$0): number;
        getBoxDir(): number;
        getInlineDir(): number;
        copyFrom(other: Container_$0): void;
        setVerticalPosition(top: number, height: number): void;
        setHorizontalPosition(left: number, width: number): void;
        setBlockPosition(start: number, extent: number): void;
        setInlinePosition(start: number, extent: number): void;
        clear(): void;
        getInnerShape(): GeometryUtil.Shape;
        getInnerRect(): GeometryUtil.Rect;
        getPaddingRect(): GeometryUtil.Rect;
        getOuterShape(outerShapeProp: Css.Val, context: Exprs.Context): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
    }
    type ExprContentListener_$0 = Vtree.ExprContentListener_$0;
    class ContentPropertyHandler extends Css.Visitor {
        readonly elem: Element;
        readonly context: Exprs.Context;
        readonly rootContentValue: Css.Val;
        readonly exprContentListener: ExprContentListener_$0;
        constructor(elem: Element, context: Exprs.Context, rootContentValue: Css.Val, exprContentListener: ExprContentListener_$0);
        private visitStrInner;
        visitStr(str: Css.Str): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function nonTrivialContent(val: Css.Val): boolean;
}
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace CssCascade_$0 {
    interface ElementStyle_$0 extends CssCascade.ElementStyle_$0 {
    }
    const inheritedProps: {
        azimuth: boolean;
        "border-collapse": boolean;
        "border-spacing": boolean;
        "caption-side": boolean;
        "clip-rule": boolean;
        color: boolean;
        "color-interpolation": boolean;
        "color-rendering": boolean;
        cursor: boolean;
        direction: boolean;
        elevation: boolean;
        "empty-cells": boolean;
        fill: boolean;
        "fill-opacity": boolean;
        "fill-rule": boolean;
        "font-kerning": boolean;
        "font-size": boolean;
        "font-size-adjust": boolean;
        "font-family": boolean;
        "font-feature-settings": boolean;
        "font-style": boolean;
        "font-stretch": boolean;
        "font-variant": boolean;
        "font-weight": boolean;
        "glyph-orientation-vertical": boolean;
        hyphens: boolean;
        "hyphenate-character": boolean;
        "hyphenate-limit-chars": boolean;
        "hyphenate-limit-last": boolean;
        "image-rendering": boolean;
        "image-resolution": boolean;
        "letter-spacing": boolean;
        "line-break": boolean;
        "line-height": boolean;
        "list-style-image": boolean;
        "list-style-position": boolean;
        "list-style-type": boolean;
        marker: boolean;
        "marker-end": boolean;
        "marker-mid": boolean;
        "marker-start": boolean;
        orphans: boolean;
        "overflow-wrap": boolean;
        "paint-order": boolean;
        "pointer-events": boolean;
        "pitch-range": boolean;
        quotes: boolean;
        richness: boolean;
        "ruby-align": boolean;
        "ruby-position": boolean;
        "speak-header": boolean;
        "speak-numeral": boolean;
        "speak-punctuation": boolean;
        "speech-rate": boolean;
        "shape-rendering": boolean;
        stress: boolean;
        stroke: boolean;
        "stroke-dasharray": boolean;
        "stroke-dashoffset": boolean;
        "stroke-linecap": boolean;
        "stroke-linejoin": boolean;
        "stroke-miterlimit": boolean;
        "stroke-opacity": boolean;
        "stroke-width": boolean;
        "tab-size": boolean;
        "text-align": boolean;
        "text-align-last": boolean;
        "text-anchor": boolean;
        "text-decoration-skip": boolean;
        "text-emphasis-color": boolean;
        "text-emphasis-position": boolean;
        "text-emphasis-style": boolean;
        "text-combine-upright": boolean;
        "text-indent": boolean;
        "text-justify": boolean;
        "text-rendering": boolean;
        "text-size-adjust": boolean;
        "text-transform": boolean;
        "text-underline-position": boolean;
        visibility: boolean;
        "voice-family": boolean;
        volume: boolean;
        "white-space": boolean;
        widows: boolean;
        "word-break": boolean;
        "word-spacing": boolean;
        "word-wrap": boolean;
        "writing-mode": boolean;
    };
    const polyfilledInheritedProps: string[];
    function getPolyfilledInheritedProps(): string[];
    const supportedNamespaces: {
        "http://www.idpf.org/2007/ops": boolean;
        "http://www.w3.org/1999/xhtml": boolean;
        "http://www.w3.org/2000/svg": boolean;
    };
    const coupledPatterns: string[];
    const coupledExtentPatterns: string[];
    const geomNames: {
        [key: string]: boolean;
    };
    function buildCouplingMap(sideMap: {
        [key: string]: string;
    }, extentMap: {
        [key: string]: string;
    }): {
        [key: string]: string;
    };
    const couplingMapVert: {
        [key: string]: string;
    };
    const couplingMapHor: {
        [key: string]: string;
    };
    const couplingMapVertRtl: {
        [key: string]: string;
    };
    const couplingMapHorRtl: {
        [key: string]: string;
    };
    class CascadeValue {
        readonly value: Css.Val;
        readonly priority: number;
        constructor(value: Css.Val, priority: number);
        getBaseValue(): CascadeValue;
        filterValue(visitor: Css.Visitor): CascadeValue;
        increaseSpecificity(specificity: number): CascadeValue;
        evaluate(context: Exprs.Context, propName: string): Css.Val;
        isEnabled(context: Exprs.Context): boolean;
    }
    class ConditionalCascadeValue extends CascadeValue {
        readonly condition: Exprs.Val;
        constructor(value: Css.Val, priority: number, condition: Exprs.Val);
        getBaseValue(): CascadeValue;
        filterValue(visitor: Css.Visitor): CascadeValue;
        increaseSpecificity(specificity: number): CascadeValue;
        isEnabled(context: Exprs.Context): boolean;
    }
    function cascadeValues(context: Exprs.Context, tv: CascadeValue, av: CascadeValue): CascadeValue;
    type ElementStyleMap = {
        [key: string]: ElementStyle_$0;
    };
    const SPECIALS: {
        "region-id": boolean;
        "fragment-selector-id": boolean;
    };
    function isSpecialName(name: string): boolean;
    function isMapName(name: string): boolean;
    function isPropName(name: string): boolean;
    function isInherited(name: string): boolean;
    function getProp(style: ElementStyle_$0, name: string): CascadeValue;
    function setProp(style: ElementStyle_$0, name: string, value: CascadeValue): any;
    function getStyleMap(style: ElementStyle_$0, name: string): ElementStyleMap;
    function getMutableStyleMap(style: ElementStyle_$0, name: string): ElementStyleMap;
    const getViewConditionalStyleMap: (style: ElementStyle_$0) => {
        matcher: Matchers.Matcher;
        styles: ElementStyleMap;
    }[];
    function getSpecial(style: ElementStyle_$0, name: string): CascadeValue[];
    function getMutableSpecial(style: ElementStyle_$0, name: string): CascadeValue[];
    function mergeIn(context: Exprs.Context, target: ElementStyle_$0, style: ElementStyle_$0, specificity: number, pseudoelement: string | null, regionId: string | null, viewConditionMatcher: Matchers.Matcher | null): void;
    function mergeAll(context: Exprs.Context, styles: ElementStyle_$0[]): ElementStyle_$0;
    function chainActions(chain: ChainedAction[], action: CascadeAction): CascadeAction;
    class InheritanceVisitor extends Css.FilterVisitor {
        readonly props: ElementStyle_$0;
        readonly context: Exprs.Context;
        propName: string;
        constructor(props: ElementStyle_$0, context: Exprs.Context);
        setPropName(name: string): void;
        private getFontSize;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function convertFontRelativeLengthToPx(numeric: Css.Numeric, baseFontSize: number, context: Exprs.Context): Css.Numeric;
    function convertFontSizeToPx(numeric: Css.Numeric, parentFontSize: number, context: Exprs.Context): Css.Numeric;
    type ActionTable = {
        [key: string]: CascadeAction;
    };
    class CascadeAction {
        apply(cascadeInstance: CascadeInstance): void;
        mergeWith(other: CascadeAction): CascadeAction;
        clone(): CascadeAction;
    }
    class ConditionItemAction extends CascadeAction {
        readonly conditionItem: ConditionItem;
        constructor(conditionItem: ConditionItem);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CompoundAction extends CascadeAction {
        readonly list: CascadeAction[];
        constructor(list: CascadeAction[]);
        apply(cascadeInstance: CascadeInstance): void;
        mergeWith(other: CascadeAction): CascadeAction;
        clone(): CascadeAction;
    }
    class ApplyRuleAction extends CascadeAction {
        readonly style: ElementStyle_$0;
        readonly specificity: number;
        readonly pseudoelement: string | null;
        readonly regionId: string | null;
        readonly viewConditionId: string | null;
        constructor(style: ElementStyle_$0, specificity: number, pseudoelement: string | null, regionId: string | null, viewConditionId: string | null);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class ChainedAction extends CascadeAction {
        chained: CascadeAction;
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckClassAction extends ChainedAction {
        readonly className: string;
        constructor(className: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckIdAction extends ChainedAction {
        readonly id: string;
        constructor(id: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckLocalNameAction extends ChainedAction {
        readonly localName: string;
        constructor(localName: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckNSTagAction extends ChainedAction {
        readonly ns: string;
        readonly localName: string;
        constructor(ns: string, localName: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckTargetEpubTypeAction extends ChainedAction {
        readonly epubTypePatt: RegExp;
        constructor(epubTypePatt: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckNamespaceAction extends ChainedAction {
        readonly ns: string;
        constructor(ns: string);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckAttributePresentAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        constructor(ns: string, name: string);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckAttributeEqAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        readonly value: string;
        constructor(ns: string, name: string, value: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckNamespaceSupportedAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        constructor(ns: string, name: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckAttributeRegExpAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        readonly regexp: RegExp;
        constructor(ns: string, name: string, regexp: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckLangAction extends ChainedAction {
        readonly langRegExp: RegExp;
        constructor(langRegExp: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class IsFirstAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsRootAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthAction extends ChainedAction {
        readonly a: number;
        readonly b: number;
        constructor(a: number, b: number);
        matchANPlusB(order: number): boolean;
    }
    class IsNthSiblingAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthSiblingOfTypeAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthLastSiblingAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthLastSiblingOfTypeAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsEmptyAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsEnabledAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsDisabledAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsCheckedAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class CheckConditionAction extends ChainedAction {
        readonly condition: string;
        constructor(condition: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class CheckAppliedAction extends CascadeAction {
        applied: boolean;
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        clone(): CascadeAction;
    }
    class NegateActionsSet extends ChainedAction {
        checkAppliedAction: CheckAppliedAction;
        firstAction: CascadeAction;
        constructor(list: ChainedAction[]);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    interface ConditionItem {
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AbstractConditionItem {
        readonly condition: string;
        readonly viewConditionId: string | null;
        readonly viewCondition: Matchers.Matcher;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        increment(cascadeInstance: CascadeInstance): void;
        decrement(cascadeInstance: CascadeInstance): void;
        buildViewConditionMatcher(cascadeInstance: CascadeInstance): Matchers.Matcher;
    }
    class DescendantConditionItem extends AbstractConditionItem implements ConditionItem {
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class ChildConditionItem extends AbstractConditionItem implements ConditionItem {
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AdjacentSiblingConditionItem extends AbstractConditionItem implements ConditionItem {
        fired: boolean;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class FollowingSiblingConditionItem extends AbstractConditionItem implements ConditionItem {
        fired: boolean;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AfterPseudoelementItem implements ConditionItem {
        readonly afterprop: ElementStyle_$0;
        readonly element: Element;
        constructor(afterprop: ElementStyle_$0, element: Element);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class RestoreLangItem implements ConditionItem {
        readonly lang: string;
        constructor(lang: string);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class QuotesScopeItem implements ConditionItem {
        readonly oldQuotes: Css.Str[];
        constructor(oldQuotes: Css.Str[]);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    type CounterValues = {
        [key: string]: number[];
    };
    interface CounterListener {
        countersOfId(id: string, counters: CounterValues): any;
        getExprContentListener(): Vtree_$0.ExprContentListener;
    }
    interface CounterResolver {
        getPageCounterVal(name: string, format: (p1: number | null) => string): Exprs.Val;
        getPageCountersVal(name: string, format: (p1: number[]) => string): Exprs.Val;
        getTargetCounterVal(url: string, name: string, format: (p1: number | null) => string): Exprs.Val;
        getTargetCountersVal(url: string, name: string, format: (p1: number[]) => string): Exprs.Val;
        setStyler(styler: any): any;
    }
    class AttrValueFilterVisitor extends Css.FilterVisitor {
        element: Element;
        constructor(element: Element);
        private createValueFromString;
        visitFunc(func: Css.Func): Css.Val;
    }
    class ContentPropVisitor extends Css.FilterVisitor {
        cascade: CascadeInstance;
        element: Element;
        readonly counterResolver: CounterResolver;
        constructor(cascade: CascadeInstance, element: Element, counterResolver: CounterResolver);
        visitIdent(ident: Css.Ident): Css.Val;
        private format;
        visitFuncCounter(values: Css.Val[]): Css.Val;
        visitFuncCounters(values: Css.Val[]): Css.Val;
        visitFuncTargetCounter(values: Css.Val[]): Css.Val;
        visitFuncTargetCounters(values: Css.Val[]): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
    }
    function roman(num: number): string;
    const additiveNumbering: {
        roman: (string | number)[];
        armenian: (string | number)[];
        georgian: (string | number)[];
        hebrew: (string | number)[];
    };
    const alphabeticNumbering: {
        latin: string;
        alpha: string;
        greek: string;
        russian: string;
    };
    const fixed: {
        square: string;
        disc: string;
        circle: string;
        none: string;
    };
    function additiveFormat(entries: any[], num: number): string;
    function expandAlphabet(str: string): string[] | null;
    function alphabeticFormat(alphabetStr: string, num: number): string;
    type ChineseNumbering = {
        digits: string;
        markers: string;
        negative: string;
        formal: boolean;
    };
    const chineseTradInformal: ChineseNumbering;
    function chineseCounter(num: number, numbering: ChineseNumbering): string;
    const ORDER_INCREMENT: number;
    function copyTable(src: ActionTable, dst: ActionTable): void;
    class Cascade {
        nsCount: number;
        nsPrefix: {
            [key: string]: string;
        };
        tags: ActionTable;
        nstags: ActionTable;
        epubtypes: ActionTable;
        classes: ActionTable;
        ids: ActionTable;
        pagetypes: ActionTable;
        order: number;
        clone(): Cascade;
        insertInTable(table: ActionTable, key: string, action: CascadeAction): void;
        createInstance(context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: any): CascadeInstance;
        nextOrder(): number;
    }
    class CascadeInstance {
        readonly context: Exprs.Context;
        readonly counterListener: CounterListener;
        readonly counterResolver: CounterResolver;
        code: Cascade;
        stack: ConditionItem[][];
        conditions: {
            [key: string]: number;
        };
        currentElement: Element | null;
        currentElementOffset: number | null;
        currentStyle: ElementStyle_$0 | null;
        currentClassNames: string[] | null;
        currentLocalName: string;
        currentNamespace: string;
        currentId: string;
        currentXmlId: string;
        currentNSTag: string;
        currentEpubTypes: string[] | null;
        currentPageType: string | null;
        isFirst: boolean;
        isRoot: boolean;
        counters: {
            [key: string]: number[];
        };
        counterScoping: {
            [key: string]: boolean;
        }[];
        quotes: Css.Str[];
        quoteDepth: number;
        lang: string;
        siblingOrderStack: number[];
        currentSiblingOrder: number;
        siblingTypeCountsStack: {
            [key: string]: {
                [key: string]: number;
            };
        }[];
        currentSiblingTypeCounts: {
            [key: string]: {
                [key: string]: number;
            };
        };
        currentFollowingSiblingOrder: number | null;
        followingSiblingOrderStack: (number | null)[];
        followingSiblingTypeCountsStack: {
            [key: string]: {
                [key: string]: number;
            };
        }[];
        currentFollowingSiblingTypeCounts: {
            [key: string]: {
                [key: string]: number;
            };
        };
        viewConditions: {
            [key: string]: Matchers.Matcher[];
        };
        dependentConditions: string[];
        elementStack: Element[];
        currentDoc?: Document | null;
        constructor(cascade: Cascade, context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: string);
        pushConditionItem(item: ConditionItem): void;
        increment(condition: string, viewCondition: Matchers.Matcher): void;
        decrement(condition: string, viewCondition: Matchers.Matcher): void;
        buildViewConditionMatcher(viewConditionId: string | null): Matchers.Matcher;
        applyAction(table: ActionTable, key: string): void;
        pushRule(classes: string[], pageType: string | null, baseStyle: ElementStyle_$0): void;
        defineCounter(counterName: string, value: number): void;
        pushCounters(props: ElementStyle_$0): void;
        popCounters(): void;
        processPseudoelementProps(pseudoprops: ElementStyle_$0, element: Element): void;
        pushElement(element: Element, baseStyle: ElementStyle_$0, elementOffset: number): void;
        private applyAttrFilterInner;
        private applyAttrFilter;
        private applyActions;
        private pop;
        popRule(): void;
        popElement(element: Element): void;
    }
    const EMPTY: any[];
    const pseudoNames: string[];
    enum ParseState {
        TOP = 0,
        SELECTOR = 1,
        RULE = 2
    }
    let uaBaseCascade: Cascade;
    function setUABaseCascade(value: Cascade): void;
    class CascadeParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
        readonly condition: Exprs.Val;
        readonly regionId: string | null;
        readonly validatorSet: CssValidator.ValidatorSet;
        chain: ChainedAction[];
        specificity: number;
        elementStyle: ElementStyle_$0;
        conditionCount: number;
        pseudoelement: string | null;
        footnoteContent: boolean;
        cascade: Cascade;
        state: ParseState;
        viewConditionId: string | null;
        insideSelectorRule: ParseState;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, condition: Exprs.Val, parent: CascadeParserHandler, regionId: string | null, validatorSet: CssValidator.ValidatorSet, topLevel: boolean);
        insertNonPrimary(action: CascadeAction): void;
        processChain(action: CascadeAction): void;
        isInsideSelectorRule(mnemonics: string): boolean;
        tagSelector(ns: string | null, name: string | null): void;
        classSelector(name: string): void;
        pseudoclassSelector(name: string, params: (number | string)[]): void;
        pseudoelementSelector(name: string, params: (number | string)[]): void;
        idSelector(id: string): void;
        attributeSelector(ns: string, name: string, op: CssTokenizer.TokenType, value: string | null): void;
        descendantSelector(): void;
        childSelector(): void;
        adjacentSiblingSelector(): void;
        followingSiblingSelector(): void;
        nextSelector(): void;
        startSelectorRule(): void;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        startStylesheet(flavor: CssParser.StylesheetFlavor): void;
        startRuleBody(): void;
        endRule(): void;
        finishChain(): void;
        makeApplyRuleAction(specificity: number): ApplyRuleAction;
        special(name: string, value: Css.Val): void;
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
        finish(): Cascade;
        startFuncWithSelector(funcName: string): void;
    }
    const nthSelectorActionClasses: {
        [key: string]: typeof IsNthAction;
    };
    let conditionCount: number;
    class NotParameterParserHandler extends CascadeParserHandler {
        readonly parent: CascadeParserHandler;
        parentChain: ChainedAction[];
        constructor(parent: CascadeParserHandler);
        startFuncWithSelector(funcName: string): void;
        startRuleBody(): void;
        nextSelector(): void;
        endFuncWithSelector(): void;
        error(mnemonics: string, token: CssTokenizer.Token): void;
    }
    class DefineParserHandler extends CssParser.SlaveParserHandler {
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler);
        property(name: string, value: Css.Val, important: boolean): void;
    }
    class PropSetParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
        readonly condition: Exprs.Val;
        readonly elementStyle: ElementStyle_$0;
        readonly validatorSet: CssValidator.ValidatorSet;
        order: number;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, condition: Exprs.Val, elementStyle: ElementStyle_$0, validatorSet: CssValidator.ValidatorSet);
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    class PropertyParserHandler extends CssParser.ErrorHandler implements CssValidator.PropertyReceiver {
        readonly validatorSet: CssValidator.ValidatorSet;
        elementStyle: ElementStyle_$0;
        order: number;
        constructor(scope: Exprs.LexicalScope, validatorSet: CssValidator.ValidatorSet);
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    function forEachViewConditionalStyles(style: ElementStyle_$0, callback: (p1: ElementStyle_$0) => any): void;
    function mergeViewConditionalStyles(cascMap: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, style: ElementStyle_$0): void;
    function parseStyleAttribute_$0(scope: Exprs.LexicalScope, validatorSet: CssValidator.ValidatorSet, baseURL: string, styleAttrValue: string): ElementStyle_$0;
    function isVertical(cascaded: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, vertical: boolean): boolean;
    function isRtl(cascaded: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, rtl: boolean): boolean;
    function flattenCascadedStyle(style: ElementStyle_$0, context: Exprs.Context, regionIds: string[], isFootnote: boolean, nodeContext: Vtree_$0.NodeContext): {
        [key: string]: CascadeValue;
    };
    function forEachStylesInRegion(style: ElementStyle_$0, regionIds: string[], isFootnote: boolean, callback: (p1: string, p2: ElementStyle_$0) => any): void;
    function mergeStyle(to: {
        [key: string]: CascadeValue;
    }, from: ElementStyle_$0, context: Exprs.Context): void;
    const convertToPhysical: <T>(src: {
        [key: string]: CascadeValue;
    }, dest: {
        [key: string]: T;
    }, vertical: boolean, rtl: boolean, transform: (p1: string, p2: CascadeValue) => T) => void;
}
declare namespace Exprs {
    type Preferences = {
        fontFamily: string;
        lineHeight: number;
        margin: number;
        hyphenate: boolean;
        columnWidth: number;
        horizontal: boolean;
        nightMode: boolean;
        spreadView: boolean;
        pageBorder: number;
        enabledMediaTypes: {
            [key: string]: boolean;
        };
        defaultPaperSize?: {
            [key: string]: number;
        };
    };
    function defaultPreferences(): Preferences;
    function clonePreferences(pref: Preferences): Preferences;
    const defaultPreferencesInstance: Preferences;
    const Special: {
        PENDING: Pending;
    };
    type Result = string | number | boolean | undefined;
    type PendingResult = Special | Result;
    function letterbox(viewW: number, viewH: number, objW: number, objH: number): string;
    function cssString(str: string): string;
    function cssIdent(name: string): string;
    function makeQualifiedName(objName: string | null, memberName: string): string;
    let nextKeyIndex: number;
    class LexicalScope {
        parent: LexicalScope;
        resolver?: (p1: string, p2: boolean) => Val;
        scopeKey: string;
        children: LexicalScope[];
        zero: Const;
        one: Const;
        _true: Const;
        _false: Const;
        values: {
            [key: string]: Val;
        };
        funcs: {
            [key: string]: Val;
        };
        builtIns: {
            [key: string]: (...p1: Result[]) => Result;
        };
        constructor(parent: LexicalScope, resolver?: (p1: string, p2: boolean) => Val);
        defineBuiltInName(name: string, fn: () => Result): void;
        defineName(qualifiedName: string, val: Val): void;
        defineFunc(qualifiedName: string, val: Val): void;
        defineBuiltIn(qualifiedName: string, fn: (...p1: Result[]) => Result): void;
    }
    function isAbsoluteLengthUnit(unit: string): boolean;
    function isViewportRelativeLengthUnit(unit: string): boolean;
    function isFontRelativeLengthUnit(unit: string): boolean;
    const defaultUnitSizes: {
        [key: string]: number;
    };
    function needUnitConversion(unit: string): boolean;
    type ScopeContext = {
        [key: string]: Result;
    };
    class Context {
        readonly rootScope: LexicalScope;
        readonly viewportWidth: number;
        readonly viewportHeight: number;
        protected actualPageWidth: number | null;
        pageWidth: () => number;
        protected actualPageHeight: number | null;
        pageHeight: () => number;
        initialFontSize: number;
        rootFontSize: number | null;
        fontSize: () => number;
        pref: Preferences;
        scopes: {
            [key: string]: ScopeContext;
        };
        pageAreaWidth: number | null;
        pageAreaHeight: number | null;
        pageVertical: boolean | null;
        pubTitle: string | null;
        docTitle: string | null;
        constructor(rootScope: LexicalScope, viewportWidth: number, viewportHeight: number, fontSize: number);
        private getScopeContext;
        clearScope(scope: LexicalScope): void;
        queryUnitSize(unit: string, isRoot: boolean): number;
        evalName(scope: LexicalScope, qualifiedName: string): Val;
        evalCall(scope: LexicalScope, qualifiedName: string, params: Val[], noBuiltInEval: boolean): Val;
        evalMediaName(name: string, not: boolean): boolean;
        evalMediaTest(feature: string, value: Val): boolean;
        queryVal(scope: LexicalScope, key: string): Result | undefined;
        storeVal(scope: LexicalScope, key: string, val: Result): void;
    }
    type DependencyCache = {
        [key: string]: boolean | Special;
    };
    class Val {
        scope: LexicalScope;
        key: string;
        constructor(scope: LexicalScope);
        toString(): string;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        expand(context: Context, params: Val[]): Val;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        dependOuter(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        depend(other: Val, context: Context): boolean;
        evaluate(context: Context): Result;
        isMediaName(): boolean;
    }
    class Prefix extends Val {
        val: Val;
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Infix extends Val {
        lhs: Val;
        rhs: Val;
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Logical extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Comparison extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Additive extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Multiplicative extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Not extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class Negate extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class And extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class AndMedia extends And {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Or extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class OrMedia extends Or {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Lt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Le extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Gt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ge extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Eq extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ne extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Add extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Subtract extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Multiply extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Divide extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Modulo extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Numeric extends Val {
        num: number;
        unit: string;
        constructor(scope: LexicalScope, num: number, unit: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class Named extends Val {
        qualifiedName: string;
        constructor(scope: LexicalScope, qualifiedName: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    }
    class MediaName extends Val {
        not: boolean;
        name: string;
        value: Val;
        constructor(scope: LexicalScope, not: boolean, name: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        isMediaName(): boolean;
    }
    class Native extends Val {
        fn: () => Result;
        str: string;
        constructor(scope: LexicalScope, fn: () => Result, str: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    function appendValArray(buf: Base.StringBuffer, arr: Val[]): void;
    function expandValArray(context: Context, arr: Val[], params: Val[]): Val[];
    function evalValArray(context: Context, arr: Val[]): Result[];
    class Call extends Val {
        qualifiedName: string;
        params: Val[];
        constructor(scope: LexicalScope, qualifiedName: string, params: Val[]);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Cond extends Val {
        cond: Val;
        ifTrue: Val;
        ifFalse: Val;
        constructor(scope: LexicalScope, cond: Val, ifTrue: Val, ifFalse: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Const extends Val {
        val: Result;
        constructor(scope: LexicalScope, val: Result);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class MediaTest extends Val {
        name: MediaName;
        value: Val;
        constructor(scope: LexicalScope, name: MediaName, value: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Param extends Val {
        index: number;
        constructor(scope: LexicalScope, index: number);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    function and(scope: LexicalScope, v1: Val, v2: Val): Val;
    function add(scope: LexicalScope, v1: Val, v2: Val): Val;
    function sub(scope: LexicalScope, v1: Val, v2: Val): Val;
    function mul(scope: LexicalScope, v1: Val, v2: Val): Val;
    function div(scope: LexicalScope, v1: Val, v2: Val): Val;
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
declare namespace TaskUtil {
    class Fetcher<T> {
        readonly fetch: () => Task.Result<T>;
        name: string;
        arrived: boolean;
        resource: T;
        task: Task.Task;
        piggybacks: ((p1: any) => void)[] | null;
        constructor(fetch: () => Task.Result<T>, opt_name?: string);
        start(): void;
        piggyback(fn: (p1: T) => void): void;
        get(): Task.Result<T>;
        hasArrived(): boolean;
    }
    const waitForFetchers: <T>(fetchers: Fetcher<T>[]) => Task.Result<boolean>;
    function loadElement(elem: Element, src: string): Fetcher<string>;
}
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace CssCascade {
    interface ElementStyle_$0 extends CssCascade.ElementStyle_$0 {
    }
    const inheritedProps: {
        azimuth: boolean;
        "border-collapse": boolean;
        "border-spacing": boolean;
        "caption-side": boolean;
        "clip-rule": boolean;
        color: boolean;
        "color-interpolation": boolean;
        "color-rendering": boolean;
        cursor: boolean;
        direction: boolean;
        elevation: boolean;
        "empty-cells": boolean;
        fill: boolean;
        "fill-opacity": boolean;
        "fill-rule": boolean;
        "font-kerning": boolean;
        "font-size": boolean;
        "font-size-adjust": boolean;
        "font-family": boolean;
        "font-feature-settings": boolean;
        "font-style": boolean;
        "font-stretch": boolean;
        "font-variant": boolean;
        "font-weight": boolean;
        "glyph-orientation-vertical": boolean;
        hyphens: boolean;
        "hyphenate-character": boolean;
        "hyphenate-limit-chars": boolean;
        "hyphenate-limit-last": boolean;
        "image-rendering": boolean;
        "image-resolution": boolean;
        "letter-spacing": boolean;
        "line-break": boolean;
        "line-height": boolean;
        "list-style-image": boolean;
        "list-style-position": boolean;
        "list-style-type": boolean;
        marker: boolean;
        "marker-end": boolean;
        "marker-mid": boolean;
        "marker-start": boolean;
        orphans: boolean;
        "overflow-wrap": boolean;
        "paint-order": boolean;
        "pointer-events": boolean;
        "pitch-range": boolean;
        quotes: boolean;
        richness: boolean;
        "ruby-align": boolean;
        "ruby-position": boolean;
        "speak-header": boolean;
        "speak-numeral": boolean;
        "speak-punctuation": boolean;
        "speech-rate": boolean;
        "shape-rendering": boolean;
        stress: boolean;
        stroke: boolean;
        "stroke-dasharray": boolean;
        "stroke-dashoffset": boolean;
        "stroke-linecap": boolean;
        "stroke-linejoin": boolean;
        "stroke-miterlimit": boolean;
        "stroke-opacity": boolean;
        "stroke-width": boolean;
        "tab-size": boolean;
        "text-align": boolean;
        "text-align-last": boolean;
        "text-anchor": boolean;
        "text-decoration-skip": boolean;
        "text-emphasis-color": boolean;
        "text-emphasis-position": boolean;
        "text-emphasis-style": boolean;
        "text-combine-upright": boolean;
        "text-indent": boolean;
        "text-justify": boolean;
        "text-rendering": boolean;
        "text-size-adjust": boolean;
        "text-transform": boolean;
        "text-underline-position": boolean;
        visibility: boolean;
        "voice-family": boolean;
        volume: boolean;
        "white-space": boolean;
        widows: boolean;
        "word-break": boolean;
        "word-spacing": boolean;
        "word-wrap": boolean;
        "writing-mode": boolean;
    };
    const polyfilledInheritedProps: string[];
    function getPolyfilledInheritedProps(): string[];
    const supportedNamespaces: {
        "http://www.idpf.org/2007/ops": boolean;
        "http://www.w3.org/1999/xhtml": boolean;
        "http://www.w3.org/2000/svg": boolean;
    };
    const coupledPatterns: string[];
    const coupledExtentPatterns: string[];
    const geomNames: {
        [key: string]: boolean;
    };
    function buildCouplingMap(sideMap: {
        [key: string]: string;
    }, extentMap: {
        [key: string]: string;
    }): {
        [key: string]: string;
    };
    const couplingMapVert: {
        [key: string]: string;
    };
    const couplingMapHor: {
        [key: string]: string;
    };
    const couplingMapVertRtl: {
        [key: string]: string;
    };
    const couplingMapHorRtl: {
        [key: string]: string;
    };
    class CascadeValue {
        readonly value: Css.Val;
        readonly priority: number;
        constructor(value: Css.Val, priority: number);
        getBaseValue(): CascadeValue;
        filterValue(visitor: Css.Visitor): CascadeValue;
        increaseSpecificity(specificity: number): CascadeValue;
        evaluate(context: Exprs.Context, propName: string): Css.Val;
        isEnabled(context: Exprs.Context): boolean;
    }
    class ConditionalCascadeValue extends CascadeValue {
        readonly condition: Exprs.Val;
        constructor(value: Css.Val, priority: number, condition: Exprs.Val);
        getBaseValue(): CascadeValue;
        filterValue(visitor: Css.Visitor): CascadeValue;
        increaseSpecificity(specificity: number): CascadeValue;
        isEnabled(context: Exprs.Context): boolean;
    }
    function cascadeValues(context: Exprs.Context, tv: CascadeValue, av: CascadeValue): CascadeValue;
    type ElementStyleMap = {
        [key: string]: ElementStyle_$0;
    };
    const SPECIALS: {
        "region-id": boolean;
        "fragment-selector-id": boolean;
    };
    function isSpecialName(name: string): boolean;
    function isMapName(name: string): boolean;
    function isPropName(name: string): boolean;
    function isInherited(name: string): boolean;
    function getProp(style: ElementStyle_$0, name: string): CascadeValue;
    function setProp(style: ElementStyle_$0, name: string, value: CascadeValue): any;
    function getStyleMap(style: ElementStyle_$0, name: string): ElementStyleMap;
    function getMutableStyleMap(style: ElementStyle_$0, name: string): ElementStyleMap;
    const getViewConditionalStyleMap: (style: ElementStyle_$0) => {
        matcher: Matchers.Matcher;
        styles: ElementStyleMap;
    }[];
    function getSpecial(style: ElementStyle_$0, name: string): CascadeValue[];
    function getMutableSpecial(style: ElementStyle_$0, name: string): CascadeValue[];
    function mergeIn(context: Exprs.Context, target: ElementStyle_$0, style: ElementStyle_$0, specificity: number, pseudoelement: string | null, regionId: string | null, viewConditionMatcher: Matchers.Matcher | null): void;
    function mergeAll(context: Exprs.Context, styles: ElementStyle_$0[]): ElementStyle_$0;
    function chainActions(chain: ChainedAction[], action: CascadeAction): CascadeAction;
    class InheritanceVisitor extends Css.FilterVisitor {
        readonly props: ElementStyle_$0;
        readonly context: Exprs.Context;
        propName: string;
        constructor(props: ElementStyle_$0, context: Exprs.Context);
        setPropName(name: string): void;
        private getFontSize;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function convertFontRelativeLengthToPx(numeric: Css.Numeric, baseFontSize: number, context: Exprs.Context): Css.Numeric;
    function convertFontSizeToPx(numeric: Css.Numeric, parentFontSize: number, context: Exprs.Context): Css.Numeric;
    type ActionTable = {
        [key: string]: CascadeAction;
    };
    class CascadeAction {
        apply(cascadeInstance: CascadeInstance): void;
        mergeWith(other: CascadeAction): CascadeAction;
        clone(): CascadeAction;
    }
    class ConditionItemAction extends CascadeAction {
        readonly conditionItem: ConditionItem;
        constructor(conditionItem: ConditionItem);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CompoundAction extends CascadeAction {
        readonly list: CascadeAction[];
        constructor(list: CascadeAction[]);
        apply(cascadeInstance: CascadeInstance): void;
        mergeWith(other: CascadeAction): CascadeAction;
        clone(): CascadeAction;
    }
    class ApplyRuleAction extends CascadeAction {
        readonly style: ElementStyle_$0;
        readonly specificity: number;
        readonly pseudoelement: string | null;
        readonly regionId: string | null;
        readonly viewConditionId: string | null;
        constructor(style: ElementStyle_$0, specificity: number, pseudoelement: string | null, regionId: string | null, viewConditionId: string | null);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class ChainedAction extends CascadeAction {
        chained: CascadeAction;
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckClassAction extends ChainedAction {
        readonly className: string;
        constructor(className: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckIdAction extends ChainedAction {
        readonly id: string;
        constructor(id: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckLocalNameAction extends ChainedAction {
        readonly localName: string;
        constructor(localName: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckNSTagAction extends ChainedAction {
        readonly ns: string;
        readonly localName: string;
        constructor(ns: string, localName: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckTargetEpubTypeAction extends ChainedAction {
        readonly epubTypePatt: RegExp;
        constructor(epubTypePatt: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckNamespaceAction extends ChainedAction {
        readonly ns: string;
        constructor(ns: string);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckAttributePresentAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        constructor(ns: string, name: string);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckAttributeEqAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        readonly value: string;
        constructor(ns: string, name: string, value: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckNamespaceSupportedAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        constructor(ns: string, name: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckAttributeRegExpAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        readonly regexp: RegExp;
        constructor(ns: string, name: string, regexp: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckLangAction extends ChainedAction {
        readonly langRegExp: RegExp;
        constructor(langRegExp: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class IsFirstAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsRootAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthAction extends ChainedAction {
        readonly a: number;
        readonly b: number;
        constructor(a: number, b: number);
        matchANPlusB(order: number): boolean;
    }
    class IsNthSiblingAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthSiblingOfTypeAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthLastSiblingAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthLastSiblingOfTypeAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsEmptyAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsEnabledAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsDisabledAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsCheckedAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class CheckConditionAction extends ChainedAction {
        readonly condition: string;
        constructor(condition: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class CheckAppliedAction extends CascadeAction {
        applied: boolean;
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        clone(): CascadeAction;
    }
    class NegateActionsSet extends ChainedAction {
        checkAppliedAction: CheckAppliedAction;
        firstAction: CascadeAction;
        constructor(list: ChainedAction[]);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    interface ConditionItem {
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AbstractConditionItem {
        readonly condition: string;
        readonly viewConditionId: string | null;
        readonly viewCondition: Matchers.Matcher;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        increment(cascadeInstance: CascadeInstance): void;
        decrement(cascadeInstance: CascadeInstance): void;
        buildViewConditionMatcher(cascadeInstance: CascadeInstance): Matchers.Matcher;
    }
    class DescendantConditionItem extends AbstractConditionItem implements ConditionItem {
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class ChildConditionItem extends AbstractConditionItem implements ConditionItem {
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AdjacentSiblingConditionItem extends AbstractConditionItem implements ConditionItem {
        fired: boolean;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class FollowingSiblingConditionItem extends AbstractConditionItem implements ConditionItem {
        fired: boolean;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AfterPseudoelementItem implements ConditionItem {
        readonly afterprop: ElementStyle_$0;
        readonly element: Element;
        constructor(afterprop: ElementStyle_$0, element: Element);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class RestoreLangItem implements ConditionItem {
        readonly lang: string;
        constructor(lang: string);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class QuotesScopeItem implements ConditionItem {
        readonly oldQuotes: Css.Str[];
        constructor(oldQuotes: Css.Str[]);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    type CounterValues = {
        [key: string]: number[];
    };
    interface CounterListener {
        countersOfId(id: string, counters: CounterValues): any;
        getExprContentListener(): Vtree_$0.ExprContentListener;
    }
    interface CounterResolver {
        getPageCounterVal(name: string, format: (p1: number | null) => string): Exprs.Val;
        getPageCountersVal(name: string, format: (p1: number[]) => string): Exprs.Val;
        getTargetCounterVal(url: string, name: string, format: (p1: number | null) => string): Exprs.Val;
        getTargetCountersVal(url: string, name: string, format: (p1: number[]) => string): Exprs.Val;
        setStyler(styler: any): any;
    }
    class AttrValueFilterVisitor extends Css.FilterVisitor {
        element: Element;
        constructor(element: Element);
        private createValueFromString;
        visitFunc(func: Css.Func): Css.Val;
    }
    class ContentPropVisitor extends Css.FilterVisitor {
        cascade: CascadeInstance;
        element: Element;
        readonly counterResolver: CounterResolver;
        constructor(cascade: CascadeInstance, element: Element, counterResolver: CounterResolver);
        visitIdent(ident: Css.Ident): Css.Val;
        private format;
        visitFuncCounter(values: Css.Val[]): Css.Val;
        visitFuncCounters(values: Css.Val[]): Css.Val;
        visitFuncTargetCounter(values: Css.Val[]): Css.Val;
        visitFuncTargetCounters(values: Css.Val[]): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
    }
    function roman(num: number): string;
    const additiveNumbering: {
        roman: (string | number)[];
        armenian: (string | number)[];
        georgian: (string | number)[];
        hebrew: (string | number)[];
    };
    const alphabeticNumbering: {
        latin: string;
        alpha: string;
        greek: string;
        russian: string;
    };
    const fixed: {
        square: string;
        disc: string;
        circle: string;
        none: string;
    };
    function additiveFormat(entries: any[], num: number): string;
    function expandAlphabet(str: string): string[] | null;
    function alphabeticFormat(alphabetStr: string, num: number): string;
    type ChineseNumbering = {
        digits: string;
        markers: string;
        negative: string;
        formal: boolean;
    };
    const chineseTradInformal: ChineseNumbering;
    function chineseCounter(num: number, numbering: ChineseNumbering): string;
    const ORDER_INCREMENT: number;
    function copyTable(src: ActionTable, dst: ActionTable): void;
    class Cascade {
        nsCount: number;
        nsPrefix: {
            [key: string]: string;
        };
        tags: ActionTable;
        nstags: ActionTable;
        epubtypes: ActionTable;
        classes: ActionTable;
        ids: ActionTable;
        pagetypes: ActionTable;
        order: number;
        clone(): Cascade;
        insertInTable(table: ActionTable, key: string, action: CascadeAction): void;
        createInstance(context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: any): CascadeInstance;
        nextOrder(): number;
    }
    class CascadeInstance {
        readonly context: Exprs.Context;
        readonly counterListener: CounterListener;
        readonly counterResolver: CounterResolver;
        code: Cascade;
        stack: ConditionItem[][];
        conditions: {
            [key: string]: number;
        };
        currentElement: Element | null;
        currentElementOffset: number | null;
        currentStyle: ElementStyle_$0 | null;
        currentClassNames: string[] | null;
        currentLocalName: string;
        currentNamespace: string;
        currentId: string;
        currentXmlId: string;
        currentNSTag: string;
        currentEpubTypes: string[] | null;
        currentPageType: string | null;
        isFirst: boolean;
        isRoot: boolean;
        counters: {
            [key: string]: number[];
        };
        counterScoping: {
            [key: string]: boolean;
        }[];
        quotes: Css.Str[];
        quoteDepth: number;
        lang: string;
        siblingOrderStack: number[];
        currentSiblingOrder: number;
        siblingTypeCountsStack: {
            [key: string]: {
                [key: string]: number;
            };
        }[];
        currentSiblingTypeCounts: {
            [key: string]: {
                [key: string]: number;
            };
        };
        currentFollowingSiblingOrder: number | null;
        followingSiblingOrderStack: (number | null)[];
        followingSiblingTypeCountsStack: {
            [key: string]: {
                [key: string]: number;
            };
        }[];
        currentFollowingSiblingTypeCounts: {
            [key: string]: {
                [key: string]: number;
            };
        };
        viewConditions: {
            [key: string]: Matchers.Matcher[];
        };
        dependentConditions: string[];
        elementStack: Element[];
        currentDoc?: Document | null;
        constructor(cascade: Cascade, context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: string);
        pushConditionItem(item: ConditionItem): void;
        increment(condition: string, viewCondition: Matchers.Matcher): void;
        decrement(condition: string, viewCondition: Matchers.Matcher): void;
        buildViewConditionMatcher(viewConditionId: string | null): Matchers.Matcher;
        applyAction(table: ActionTable, key: string): void;
        pushRule(classes: string[], pageType: string | null, baseStyle: ElementStyle_$0): void;
        defineCounter(counterName: string, value: number): void;
        pushCounters(props: ElementStyle_$0): void;
        popCounters(): void;
        processPseudoelementProps(pseudoprops: ElementStyle_$0, element: Element): void;
        pushElement(element: Element, baseStyle: ElementStyle_$0, elementOffset: number): void;
        private applyAttrFilterInner;
        private applyAttrFilter;
        private applyActions;
        private pop;
        popRule(): void;
        popElement(element: Element): void;
    }
    const EMPTY: any[];
    const pseudoNames: string[];
    enum ParseState {
        TOP = 0,
        SELECTOR = 1,
        RULE = 2
    }
    let uaBaseCascade: Cascade;
    function setUABaseCascade(value: Cascade): void;
    class CascadeParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
        readonly condition: Exprs.Val;
        readonly regionId: string | null;
        readonly validatorSet: CssValidator.ValidatorSet;
        chain: ChainedAction[];
        specificity: number;
        elementStyle: ElementStyle_$0;
        conditionCount: number;
        pseudoelement: string | null;
        footnoteContent: boolean;
        cascade: Cascade;
        state: ParseState;
        viewConditionId: string | null;
        insideSelectorRule: ParseState;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, condition: Exprs.Val, parent: CascadeParserHandler, regionId: string | null, validatorSet: CssValidator.ValidatorSet, topLevel: boolean);
        insertNonPrimary(action: CascadeAction): void;
        processChain(action: CascadeAction): void;
        isInsideSelectorRule(mnemonics: string): boolean;
        tagSelector(ns: string | null, name: string | null): void;
        classSelector(name: string): void;
        pseudoclassSelector(name: string, params: (number | string)[]): void;
        pseudoelementSelector(name: string, params: (number | string)[]): void;
        idSelector(id: string): void;
        attributeSelector(ns: string, name: string, op: CssTokenizer.TokenType, value: string | null): void;
        descendantSelector(): void;
        childSelector(): void;
        adjacentSiblingSelector(): void;
        followingSiblingSelector(): void;
        nextSelector(): void;
        startSelectorRule(): void;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        startStylesheet(flavor: CssParser.StylesheetFlavor): void;
        startRuleBody(): void;
        endRule(): void;
        finishChain(): void;
        makeApplyRuleAction(specificity: number): ApplyRuleAction;
        special(name: string, value: Css.Val): void;
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
        finish(): Cascade;
        startFuncWithSelector(funcName: string): void;
    }
    const nthSelectorActionClasses: {
        [key: string]: typeof IsNthAction;
    };
    let conditionCount: number;
    class NotParameterParserHandler extends CascadeParserHandler {
        readonly parent: CascadeParserHandler;
        parentChain: ChainedAction[];
        constructor(parent: CascadeParserHandler);
        startFuncWithSelector(funcName: string): void;
        startRuleBody(): void;
        nextSelector(): void;
        endFuncWithSelector(): void;
        error(mnemonics: string, token: CssTokenizer.Token): void;
    }
    class DefineParserHandler extends CssParser.SlaveParserHandler {
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler);
        property(name: string, value: Css.Val, important: boolean): void;
    }
    class PropSetParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
        readonly condition: Exprs.Val;
        readonly elementStyle: ElementStyle_$0;
        readonly validatorSet: CssValidator.ValidatorSet;
        order: number;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, condition: Exprs.Val, elementStyle: ElementStyle_$0, validatorSet: CssValidator.ValidatorSet);
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    class PropertyParserHandler extends CssParser.ErrorHandler implements CssValidator.PropertyReceiver {
        readonly validatorSet: CssValidator.ValidatorSet;
        elementStyle: ElementStyle_$0;
        order: number;
        constructor(scope: Exprs.LexicalScope, validatorSet: CssValidator.ValidatorSet);
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    function forEachViewConditionalStyles(style: ElementStyle_$0, callback: (p1: ElementStyle_$0) => any): void;
    function mergeViewConditionalStyles(cascMap: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, style: ElementStyle_$0): void;
    function parseStyleAttribute_$0(scope: Exprs.LexicalScope, validatorSet: CssValidator.ValidatorSet, baseURL: string, styleAttrValue: string): ElementStyle_$0;
    function isVertical(cascaded: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, vertical: boolean): boolean;
    function isRtl(cascaded: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, rtl: boolean): boolean;
    function flattenCascadedStyle(style: ElementStyle_$0, context: Exprs.Context, regionIds: string[], isFootnote: boolean, nodeContext: Vtree_$0.NodeContext): {
        [key: string]: CascadeValue;
    };
    function forEachStylesInRegion(style: ElementStyle_$0, regionIds: string[], isFootnote: boolean, callback: (p1: string, p2: ElementStyle_$0) => any): void;
    function mergeStyle(to: {
        [key: string]: CascadeValue;
    }, from: ElementStyle_$0, context: Exprs.Context): void;
    const convertToPhysical: <T>(src: {
        [key: string]: CascadeValue;
    }, dest: {
        [key: string]: T;
    }, vertical: boolean, rtl: boolean, transform: (p1: string, p2: CascadeValue) => T) => void;
}
declare namespace CssParser {
    const SPECIFICITY_USER_AGENT: number;
    const SPECIFICITY_USER: number;
    const SPECIFICITY_AUTHOR: number;
    const SPECIFICITY_STYLE: number;
    const SPECIFICITY_STYLE_IMPORTANT: number;
    const SPECIFICITY_AUTHOR_IMPORTANT: number;
    const SPECIFICITY_USER_IMPORTANT: number;
    enum StylesheetFlavor {
        USER_AGENT = "UA",
        USER = "User",
        AUTHOR = "Author"
    }
    function colorFromHash(text: string): Css.Color;
    class ParserHandler implements CssTokenizer.TokenizerHandler {
        scope: Exprs.LexicalScope;
        flavor: StylesheetFlavor;
        constructor(scope: Exprs.LexicalScope);
        getCurrentToken(): CssTokenizer.Token;
        getScope(): Exprs.LexicalScope;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        startStylesheet(flavor: StylesheetFlavor): void;
        tagSelector(ns: string | null, name: string | null): void;
        classSelector(name: string): void;
        pseudoclassSelector(name: string, params: (number | string)[]): void;
        pseudoelementSelector(name: string, params: (number | string)[]): void;
        idSelector(id: string): void;
        attributeSelector(ns: string, name: string, op: CssTokenizer.TokenType, value: string | null): void;
        descendantSelector(): void;
        childSelector(): void;
        adjacentSiblingSelector(): void;
        followingSiblingSelector(): void;
        nextSelector(): void;
        startSelectorRule(): void;
        startFontFaceRule(): void;
        startFootnoteRule(pseudoelem: string | null): void;
        startViewportRule(): void;
        startDefineRule(): void;
        startRegionRule(): void;
        startPageRule(): void;
        startPageMarginBoxRule(name: string): void;
        startWhenRule(expr: Css.Expr): void;
        startMediaRule(expr: Css.Expr): void;
        startFlowRule(flowName: string): void;
        startPageTemplateRule(): void;
        startPageMasterRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionGroupRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startRuleBody(): void;
        property(name: string, value: Css.Val, important: boolean): void;
        endRule(): void;
        startFuncWithSelector(funcName: string): void;
        endFuncWithSelector(): void;
        getImportantSpecificity(): number;
        getBaseSpecificity(): number;
    }
    class DispatchParserHandler extends ParserHandler {
        stack: ParserHandler[];
        tokenizer: CssTokenizer.Tokenizer;
        slave: ParserHandler;
        constructor();
        pushHandler(slave: ParserHandler): void;
        popHandler(): void;
        getCurrentToken(): CssTokenizer.Token;
        getScope(): Exprs.LexicalScope;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        errorMsg(mnemonics: string, token: CssTokenizer.Token): void;
        startStylesheet(flavor: StylesheetFlavor): void;
        tagSelector(ns: string | null, name: string | null): void;
        classSelector(name: string): void;
        pseudoclassSelector(name: string, params: (number | string)[]): void;
        pseudoelementSelector(name: string, params: (number | string)[]): void;
        idSelector(id: string): void;
        attributeSelector(ns: string, name: string, op: CssTokenizer.TokenType, value: string | null): void;
        descendantSelector(): void;
        childSelector(): void;
        adjacentSiblingSelector(): void;
        followingSiblingSelector(): void;
        nextSelector(): void;
        startSelectorRule(): void;
        startFontFaceRule(): void;
        startFootnoteRule(pseudoelem: string | null): void;
        startViewportRule(): void;
        startDefineRule(): void;
        startRegionRule(): void;
        startPageRule(): void;
        startPageMarginBoxRule(name: string): void;
        startWhenRule(expr: Css.Expr): void;
        startFlowRule(flowName: string): void;
        startPageTemplateRule(): void;
        startPageMasterRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionGroupRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startRuleBody(): void;
        property(name: string, value: Css.Val, important: boolean): void;
        endRule(): void;
        startFuncWithSelector(funcName: string): void;
        endFuncWithSelector(): void;
    }
    class SkippingParserHandler extends ParserHandler {
        owner: DispatchParserHandler;
        readonly topLevel: any;
        depth: number;
        flavor: StylesheetFlavor;
        constructor(scope: Exprs.LexicalScope, owner: DispatchParserHandler, topLevel: any);
        getCurrentToken(): CssTokenizer.Token;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        startRuleBody(): void;
        endRule(): void;
    }
    class SlaveParserHandler extends SkippingParserHandler {
        constructor(scope: Exprs.LexicalScope, owner: DispatchParserHandler, topLevel: boolean);
        report(message: string): void;
        reportAndSkip(message: string): void;
        startSelectorRule(): void;
        startFontFaceRule(): void;
        startFootnoteRule(pseudoelem: string | null): void;
        startViewportRule(): void;
        startDefineRule(): void;
        startRegionRule(): void;
        startPageRule(): void;
        startWhenRule(expr: Css.Expr): void;
        startFlowRule(flowName: string): void;
        startPageTemplateRule(): void;
        startPageMasterRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionGroupRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startFuncWithSelector(funcName: string): void;
        endFuncWithSelector(): void;
        property(name: string, value: Css.Val, important: boolean): void;
    }
    const actionsBase: Action_$0[];
    const actionsStyleAttribute: Action_$0[];
    const actionsSelector: Action_$0[];
    const actionsSelectorInFunc: Action_$0[];
    const actionsSelectorCont: Action_$0[];
    const actionsSelectorStart: Action_$0[];
    const actionsPropVal: Action_$0[];
    const actionsExprVal: Action_$0[];
    const actionsExprOp: Action_$0[];
    const actionsError: Action_$0[];
    const actionsErrorDecl: Action_$0[];
    const actionsErrorSelector: Action_$0[];
    const priority: number[];
    enum Action_$0 {
        SELECTOR_NAME_1 = 1,
        SELECTOR_NAME = 2,
        SELECTOR_ANY_1 = 3,
        SELECTOR_ANY = 4,
        SELECTOR_ID_1 = 5,
        SELECTOR_ID = 6,
        SELECTOR_CLASS_1 = 7,
        SELECTOR_CLASS = 8,
        SELECTOR_ATTR_1 = 9,
        SELECTOR_ATTR = 10,
        SELECTOR_CHILD = 11,
        SELECTOR_SIBLING = 12,
        SELECTOR_BODY = 13,
        SELECTOR_PSEUDOCLASS = 14,
        VAL_IDENT = 15,
        VAL_HASH = 16,
        VAL_NUM = 17,
        VAL_INT = 18,
        VAL_NUMERIC = 19,
        VAL_STR = 20,
        VAL_URL = 21,
        VAL_COMMA = 22,
        VAL_SLASH = 23,
        VAL_FUNC = 24,
        VAL_C_PAR = 25,
        VAL_END = 26,
        RULE_END = 27,
        IDENT = 28,
        SELECTOR_START = 29,
        AT = 30,
        EXPR_IDENT = 31,
        EXPR_NUM = 32,
        EXPR_NUMERIC = 33,
        EXPR_STR = 34,
        EXPR_PARAM = 35,
        EXPR_PREFIX = 36,
        EXPR_INFIX = 37,
        EXPR_FUNC = 38,
        EXPR_C_PAR = 39,
        EXPR_O_PAR = 40,
        SELECTOR_NEXT = 41,
        SELECTOR_PSEUDOELEM = 42,
        EXPR_O_BRC = 43,
        VAL_FINISH = 44,
        EXPR_INFIX_NAME = 45,
        PROP = 46,
        VAL_BANG = 47,
        VAL_BRC = 48,
        EXPR_SEMICOL = 49,
        ERROR_PUSH = 50,
        ERROR_POP = 51,
        ERROR_POP_DECL = 52,
        ERROR_SEMICOL = 53,
        VAL_PLUS = 54,
        SELECTOR_PSEUDOCLASS_1 = 55,
        SELECTOR_FOLLOWING_SIBLING = 56,
        DONE = 200
    }
    const OP_MEDIA_AND: number;
    enum ExprContext {
        PROP = 0,
        WHEN = 1,
        MEDIA = 2,
        IMPORT = 3
    }
    class Parser {
        actions: Action_$0[];
        tokenizer: CssTokenizer.Tokenizer;
        readonly handler: ParserHandler;
        baseURL: string;
        valStack: any[];
        namespacePrefixToURI: {
            [key: string]: string;
        };
        defaultNamespaceURI: string | null;
        propName: string | null;
        propImportant: boolean;
        exprContext: ExprContext;
        result: Css.Val;
        importReady: boolean;
        importURL: string | null;
        importCondition: Css.Expr;
        errorBrackets: number[];
        ruleStack: string[];
        regionRule: boolean;
        pageRule: boolean;
        constructor(actions: Action_$0[], tokenizer: CssTokenizer.Tokenizer, handler: ParserHandler, baseURL: string);
        extractVals(sep: string, index: number): Css.Val[];
        valStackReduce(sep: string, token: CssTokenizer.Token): Css.Val;
        exprError(mnemonics: string, token: CssTokenizer.Token): void;
        exprStackReduce(op: number, token: CssTokenizer.Token): boolean;
        readPseudoParams(): (number | string)[];
        private readNthPseudoParams;
        makeCondition(classes: string | null, condition: Exprs.Val): Css.Expr;
        isInsidePropertyOnlyRule(): boolean;
        runParser(count: number, parsingValue: any, parsingStyleAttr: boolean, parsingMediaQuery: any, parsingFunctionParam: any): boolean;
    }
    class ErrorHandler extends ParserHandler {
        readonly scope: Exprs.LexicalScope;
        constructor(scope: Exprs.LexicalScope);
        error(mnemonics: string, token: CssTokenizer.Token): void;
        getScope(): Exprs.LexicalScope;
    }
    function parseStylesheet(tokenizer: CssTokenizer.Tokenizer, handler: ParserHandler, baseURL: string, classes: string | null, media: string | null): Task.Result<boolean>;
    function parseStylesheetFromText(text: string, handler: ParserHandler, baseURL: string, classes: string | null, media: string | null): Task.Result<boolean>;
    function parseStylesheetFromURL(url: string, handler: ParserHandler, classes: string | null, media: string | null): Task.Result<boolean>;
    function parseValue(scope: Exprs.LexicalScope, tokenizer: CssTokenizer.Tokenizer, baseURL: string): Css.Val;
    function parseStyleAttribute(tokenizer: CssTokenizer.Tokenizer, handler: ParserHandler, baseURL: string): void;
    function parseMediaQuery(tokenizer: CssTokenizer.Tokenizer, handler: ParserHandler, baseURL: string): Css.Expr;
    const numProp: {
        [key: string]: boolean;
    };
    function takesOnlyNum(propName: string): boolean;
    function evaluateExprToCSS(context: Exprs.Context, val: Exprs.Val, propName: string): Css.Val;
    function evaluateCSSToCSS(context: Exprs.Context, val: Css.Val, propName: string): Css.Val;
}
declare namespace CssValidator {
    interface PropertyReceiver {
        unknownProperty(name: string, value: Css.Val): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    class Node {
        validator: PropertyValidator;
        success: Node;
        failure: Node;
        code: number;
        constructor(validator: PropertyValidator);
        isSpecial(): boolean;
        markAsStartGroup(): void;
        isStartGroup(): boolean;
        markAsEndGroup(): void;
        isEndGroup(): boolean;
        markAsStartAlternate(index: number): void;
        isStartAlternate(): boolean;
        markAsEndAlternate(index: number): void;
        isEndAlternate(): boolean;
        getAlternate(): number;
    }
    class Connection {
        where: number;
        success: boolean;
        what: number;
        constructor(where: number, success: boolean);
    }
    enum Add_$0 {
        FOLLOW = 1,
        OPTIONAL = 2,
        REPEATED = 3,
        ALTERNATE = 4
    }
    class ValidatingGroup {
        nodes: Node[];
        connections: Connection[];
        match: number[];
        nomatch: number[];
        error: number[];
        emptyHead: boolean;
        connect(arr: number[], nodeIndex: number): void;
        clone(): ValidatingGroup;
        private addSpecialToArr;
        endSpecialGroup(): void;
        startSpecialGroup(): void;
        endClause(clause: number): void;
        startClause(clause: number): void;
        addPrimitive(validator: PropertyValidator): void;
        isSimple(): boolean;
        isPrimitive(): boolean;
        addGroup(group: ValidatingGroup, how: Add_$0): void;
        finish(successTerminal: Node, failTerminal: Node): Node;
    }
    const ALLOW_EMPTY = 1;
    const ALLOW_STR = 2;
    const ALLOW_IDENT = 4;
    const ALLOW_POS_NUMERIC = 8;
    const ALLOW_POS_NUM = 16;
    const ALLOW_POS_INT = 32;
    const ALLOW_COLOR = 64;
    const ALLOW_URL = 128;
    const ALLOW_NEGATIVE = 256;
    const ALLOW_ZERO = 512;
    const ALLOW_ZERO_PERCENT = 1024;
    const ALLOW_SLASH = 2048;
    type ValueMap = {
        [key: string]: Css.Val;
    };
    class PropertyValidator extends Css.Visitor {
        constructor();
        validateForShorthand(values: Css.Val[], index: number): Css.Val[];
    }
    class PrimitiveValidator extends PropertyValidator {
        readonly allowed: number;
        readonly idents: ValueMap;
        readonly units: ValueMap;
        constructor(allowed: number, idents: ValueMap, units: ValueMap);
        visitEmpty(empty: Css.Val): Css.Val;
        visitSlash(slash: Css.Val): Css.Val;
        visitStr(str: Css.Str): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitNum(num: Css.Num): Css.Val;
        visitInt(num: Css.Int): Css.Val;
        visitColor(color: Css.Color): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
        combine(other: PrimitiveValidator): PrimitiveValidator;
    }
    const ALWAYS_FAIL: PrimitiveValidator;
    class ListValidator extends PropertyValidator {
        successTerminal: Node;
        failureTerminal: Node;
        first: Node;
        constructor(group: ValidatingGroup);
        validateList(arr: Css.Val[], slice: boolean, startIndex: number): Css.Val[];
        validateSingle(inval: Css.Val): Css.Val;
        visitEmpty(empty: Css.Val): Css.Val;
        visitSlash(slash: Css.Val): Css.Val;
        visitStr(str: Css.Str): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitNum(num: Css.Num): Css.Val;
        visitInt(num: Css.Int): Css.Val;
        visitColor(color: Css.Color): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    class SpaceListValidator extends ListValidator {
        constructor(group: ValidatingGroup);
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        validateForShorthand(values: Css.Val[], index: number): Css.Val[];
    }
    class CommaListValidator extends ListValidator {
        constructor(group: ValidatingGroup);
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        validateForShorthand(values: Css.Val[], index: number): Css.Val[];
    }
    class FuncValidator extends ListValidator {
        readonly name: string;
        constructor(name: string, group: ValidatingGroup);
        validateSingle(inval: Css.Val): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
    }
    class ShorthandSyntaxNode {
        tryParse(values: Css.Val[], index: number, shorthandValidator: ShorthandValidator): number;
        success(rval: Css.Val, shorthandValidator: ShorthandValidator): void;
    }
    class ShorthandSyntaxProperty extends ShorthandSyntaxNode {
        readonly name: string;
        validator: PropertyValidator;
        constructor(validatorSet: ValidatorSet, name: string);
        tryParse(values: Css.Val[], index: number, shorthandValidator: ShorthandValidator): number;
        success(rval: Css.Val, shorthandValidator: ShorthandValidator): void;
    }
    class ShorthandSyntaxPropertyN extends ShorthandSyntaxProperty {
        readonly names: string[];
        constructor(validatorSet: ValidatorSet, names: string[]);
        success(rval: Css.Val, shorthandValidator: ShorthandValidator): void;
    }
    class ShorthandSyntaxCompound extends ShorthandSyntaxNode {
        readonly nodes: ShorthandSyntaxNode[];
        readonly slash: boolean;
        constructor(nodes: ShorthandSyntaxNode[], slash: boolean);
        tryParse(values: Css.Val[], index: number, shorthandValidator: ShorthandValidator): number;
    }
    class ShorthandValidator extends Css.Visitor {
        syntax: ShorthandSyntaxNode[];
        propList: string[];
        error: boolean;
        values: ValueMap;
        validatorSet: ValidatorSet;
        setOwner(validatorSet: ValidatorSet): void;
        syntaxNodeForProperty(name: string): ShorthandSyntaxNode;
        clone(): this;
        init(syntax: ShorthandSyntaxNode[], propList: string[]): void;
        finish(important: boolean, receiver: PropertyReceiver): boolean;
        propagateInherit(important: boolean, receiver: PropertyReceiver): void;
        validateList(list: Css.Val[]): number;
        validateSingle(val: Css.Val): Css.Val;
        visitEmpty(empty: Css.Val): Css.Val;
        visitStr(str: Css.Str): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitNum(num: Css.Num): Css.Val;
        visitInt(num: Css.Int): Css.Val;
        visitColor(color: Css.Color): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    class SimpleShorthandValidator extends ShorthandValidator {
        constructor();
        validateList(list: Css.Val[]): number;
    }
    class InsetsShorthandValidator extends ShorthandValidator {
        constructor();
        validateList(list: Css.Val[]): number;
        createSyntaxNode(): ShorthandSyntaxPropertyN;
    }
    class InsetsSlashShorthandValidator extends ShorthandValidator {
        constructor();
        validateList(list: Css.Val[]): number;
    }
    class CommaShorthandValidator extends SimpleShorthandValidator {
        constructor();
        mergeIn(acc: {
            [key: string]: Css.Val[];
        }, values: ValueMap): void;
        visitCommaList(list: Css.CommaList): Css.Val;
    }
    class FontShorthandValidator extends SimpleShorthandValidator {
        constructor();
        init(syntax: ShorthandSyntaxNode[], propList: string[]): void;
        validateList(list: Css.Val[]): number;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
    }
    const shorthandValidators: {
        [key: string]: typeof ShorthandValidator;
    };
    class ValidatorSet {
        validators: {
            [key: string]: PropertyValidator;
        };
        prefixes: {
            [key: string]: {
                [key: string]: boolean;
            };
        };
        defaultValues: ValueMap;
        namedValidators: {
            [key: string]: ValidatingGroup;
        };
        systemFonts: {
            [key: string]: ValueMap;
        };
        shorthands: {
            [key: string]: ShorthandValidator;
        };
        layoutProps: ValueMap;
        backgroundProps: ValueMap;
        private addReplacement;
        private newGroup;
        private addCounts;
        private primitive;
        private newFunc;
        initBuiltInValidators(): void;
        private isBuiltIn;
        private readNameAndPrefixes;
        private parseValidators;
        private parseDefaults;
        private parseShorthands;
        parse(text: string): void;
        makePropSet(propList: string[]): ValueMap;
        validatePropertyAndHandleShorthand(name: string, value: Css.Val, important: boolean, receiver: PropertyReceiver): void;
    }
    function baseValidatorSet(): ValidatorSet;
}
declare namespace Exprs {
    type Preferences = {
        fontFamily: string;
        lineHeight: number;
        margin: number;
        hyphenate: boolean;
        columnWidth: number;
        horizontal: boolean;
        nightMode: boolean;
        spreadView: boolean;
        pageBorder: number;
        enabledMediaTypes: {
            [key: string]: boolean;
        };
        defaultPaperSize?: {
            [key: string]: number;
        };
    };
    function defaultPreferences(): Preferences;
    function clonePreferences(pref: Preferences): Preferences;
    const defaultPreferencesInstance: Preferences;
    const Special: {
        PENDING: Pending;
    };
    type Result = string | number | boolean | undefined;
    type PendingResult = Special | Result;
    function letterbox(viewW: number, viewH: number, objW: number, objH: number): string;
    function cssString(str: string): string;
    function cssIdent(name: string): string;
    function makeQualifiedName(objName: string | null, memberName: string): string;
    let nextKeyIndex: number;
    class LexicalScope {
        parent: LexicalScope;
        resolver?: (p1: string, p2: boolean) => Val;
        scopeKey: string;
        children: LexicalScope[];
        zero: Const;
        one: Const;
        _true: Const;
        _false: Const;
        values: {
            [key: string]: Val;
        };
        funcs: {
            [key: string]: Val;
        };
        builtIns: {
            [key: string]: (...p1: Result[]) => Result;
        };
        constructor(parent: LexicalScope, resolver?: (p1: string, p2: boolean) => Val);
        defineBuiltInName(name: string, fn: () => Result): void;
        defineName(qualifiedName: string, val: Val): void;
        defineFunc(qualifiedName: string, val: Val): void;
        defineBuiltIn(qualifiedName: string, fn: (...p1: Result[]) => Result): void;
    }
    function isAbsoluteLengthUnit(unit: string): boolean;
    function isViewportRelativeLengthUnit(unit: string): boolean;
    function isFontRelativeLengthUnit(unit: string): boolean;
    const defaultUnitSizes: {
        [key: string]: number;
    };
    function needUnitConversion(unit: string): boolean;
    type ScopeContext = {
        [key: string]: Result;
    };
    class Context {
        readonly rootScope: LexicalScope;
        readonly viewportWidth: number;
        readonly viewportHeight: number;
        protected actualPageWidth: number | null;
        pageWidth: () => number;
        protected actualPageHeight: number | null;
        pageHeight: () => number;
        initialFontSize: number;
        rootFontSize: number | null;
        fontSize: () => number;
        pref: Preferences;
        scopes: {
            [key: string]: ScopeContext;
        };
        pageAreaWidth: number | null;
        pageAreaHeight: number | null;
        pageVertical: boolean | null;
        pubTitle: string | null;
        docTitle: string | null;
        constructor(rootScope: LexicalScope, viewportWidth: number, viewportHeight: number, fontSize: number);
        private getScopeContext;
        clearScope(scope: LexicalScope): void;
        queryUnitSize(unit: string, isRoot: boolean): number;
        evalName(scope: LexicalScope, qualifiedName: string): Val;
        evalCall(scope: LexicalScope, qualifiedName: string, params: Val[], noBuiltInEval: boolean): Val;
        evalMediaName(name: string, not: boolean): boolean;
        evalMediaTest(feature: string, value: Val): boolean;
        queryVal(scope: LexicalScope, key: string): Result | undefined;
        storeVal(scope: LexicalScope, key: string, val: Result): void;
    }
    type DependencyCache = {
        [key: string]: boolean | Special;
    };
    class Val {
        scope: LexicalScope;
        key: string;
        constructor(scope: LexicalScope);
        toString(): string;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        expand(context: Context, params: Val[]): Val;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        dependOuter(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        depend(other: Val, context: Context): boolean;
        evaluate(context: Context): Result;
        isMediaName(): boolean;
    }
    class Prefix extends Val {
        val: Val;
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Infix extends Val {
        lhs: Val;
        rhs: Val;
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Logical extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Comparison extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Additive extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Multiplicative extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Not extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class Negate extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class And extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class AndMedia extends And {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Or extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class OrMedia extends Or {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Lt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Le extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Gt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ge extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Eq extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ne extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Add extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Subtract extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Multiply extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Divide extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Modulo extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Numeric extends Val {
        num: number;
        unit: string;
        constructor(scope: LexicalScope, num: number, unit: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class Named extends Val {
        qualifiedName: string;
        constructor(scope: LexicalScope, qualifiedName: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    }
    class MediaName extends Val {
        not: boolean;
        name: string;
        value: Val;
        constructor(scope: LexicalScope, not: boolean, name: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        isMediaName(): boolean;
    }
    class Native extends Val {
        fn: () => Result;
        str: string;
        constructor(scope: LexicalScope, fn: () => Result, str: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    function appendValArray(buf: Base.StringBuffer, arr: Val[]): void;
    function expandValArray(context: Context, arr: Val[], params: Val[]): Val[];
    function evalValArray(context: Context, arr: Val[]): Result[];
    class Call extends Val {
        qualifiedName: string;
        params: Val[];
        constructor(scope: LexicalScope, qualifiedName: string, params: Val[]);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Cond extends Val {
        cond: Val;
        ifTrue: Val;
        ifFalse: Val;
        constructor(scope: LexicalScope, cond: Val, ifTrue: Val, ifFalse: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Const extends Val {
        val: Result;
        constructor(scope: LexicalScope, val: Result);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class MediaTest extends Val {
        name: MediaName;
        value: Val;
        constructor(scope: LexicalScope, name: MediaName, value: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Param extends Val {
        index: number;
        constructor(scope: LexicalScope, index: number);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    function and(scope: LexicalScope, v1: Val, v2: Val): Val;
    function add(scope: LexicalScope, v1: Val, v2: Val): Val;
    function sub(scope: LexicalScope, v1: Val, v2: Val): Val;
    function mul(scope: LexicalScope, v1: Val, v2: Val): Val;
    function div(scope: LexicalScope, v1: Val, v2: Val): Val;
}
declare namespace Font {
    const traitProps: {
        [key: string]: Css.Val;
    };
    const bogusFontData: string;
    let bogusFontCounter: number;
    function makeFontTraitKey(properties: {
        [key: string]: Css.Val;
    }): string;
    function fillDefaults(properties: {
        [key: string]: Css.Val;
    }): void;
    function prepareProperties(properties: CssCascade_$0.ElementStyle, context: Exprs.Context): {
        [key: string]: Css.Val;
    };
    class Face {
        readonly properties: {
            [key: string]: Css.Val;
        };
        fontTraitKey: string;
        src: string | null;
        blobURLs: string[];
        blobs: Blob[];
        family: string | null;
        constructor(properties: {
            [key: string]: Css.Val;
        });
        traitsEqual(other: Face): boolean;
        makeAtRule(src: string, fontBytes: Blob): string;
    }
    class DocumentFaces {
        readonly deobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null;
        familyMap: {
            [key: string]: string;
        };
        constructor(deobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null);
        registerFamily(srcFace: Face, viewFace: Face): void;
        filterFontFamily(val: Css.Val): Css.Val;
    }
    class Mapper {
        readonly head: Element;
        readonly body: Element;
        srcURLMap: {
            [key: string]: TaskUtil.Fetcher<Face>;
        };
        familyPrefix: string;
        familyCounter: number;
        constructor(head: Element, body: Element, opt_familyPrefix?: string);
        getViewFontFamily(srcFace: Face, documentFaces: DocumentFaces): string;
        private initFont;
        loadFont(srcFace: Face, documentFaces: DocumentFaces): TaskUtil.Fetcher<Face>;
        findOrLoadFonts(srcFaces: Face[], documentFaces: DocumentFaces): Task.Result<boolean>;
    }
}
declare namespace Vtree_$0 {
    const delayedProps: {
        transform: boolean;
        "transform-origin": boolean;
    };
    const delayedPropsIfRelativePositioned: {
        top: boolean;
        bottom: boolean;
        left: boolean;
        right: boolean;
    };
    class DelayedItem {
        target: Element;
        name: string;
        value: Css.Val;
        constructor(target: Element, name: string, value: Css.Val);
    }
    type PageHyperlinkEvent = {
        type: string;
        target: any;
        currentTarget: any;
        anchorElement: Element;
        href: string;
    };
    type Trigger = {
        observer: string;
        event: string;
        action: string;
        ref: string;
    };
    const actions: {
        show: (obj: any) => void;
        hide: (obj: any) => void;
        play: (obj: any) => void;
        pause: (obj: any) => void;
        resume: (obj: any) => void;
        mute: (obj: any) => void;
        unmute: (obj: any) => void;
    };
    function makeListener(refs: Element[], action: string): EventListener | null;
    class Page extends Base.SimpleEventTarget {
        readonly container: HTMLElement;
        readonly bleedBox: HTMLElement;
        private static AUTO_PAGE_WIDTH_ATTRIBUTE;
        private static AUTO_PAGE_HEIGHT_ATTRIBUTE;
        pageAreaElement: HTMLElement | null;
        delayedItems: DelayedItem[];
        hrefHandler: (e: Event) => void;
        elementsById: {
            [key: string]: Element[];
        };
        dimensions: {
            width: number;
            height: number;
        };
        isFirstPage: boolean;
        isLastPage: boolean;
        isAutoPageWidth: boolean;
        isAutoPageHeight: boolean;
        spineIndex: number;
        position: LayoutPosition;
        offset: number;
        side: Constants.PageSide | null;
        fetchers: TaskUtil.Fetcher<{}>[];
        marginBoxes: {
            top: {
                [key: string]: Container_$0;
            };
            bottom: {
                [key: string]: Container_$0;
            };
            left: {
                [key: string]: Container_$0;
            };
            right: {
                [key: string]: Container_$0;
            };
        };
        constructor(container: HTMLElement, bleedBox: HTMLElement);
        setAutoPageWidth(isAuto: boolean): void;
        setAutoPageHeight(isAuto: boolean): void;
        registerElementWithId(element: Element, id: string): void;
        finish(triggers: Trigger[], clientLayout: ClientLayout_$0): void;
        zoom(scale: number): void;
        getPageAreaElement(): HTMLElement;
    }
    type Spread = {
        left: Page;
        right: Page;
    };
    const SPECIAL_ATTR = "data-adapt-spec";
    const Whitespace_$0: typeof Vtree.Whitespace_$0;
    type Whitespace_$0 = Vtree.Whitespace_$0;
    function whitespaceFromPropertyValue(whitespace: string): Whitespace_$0 | null;
    function canIgnore(node: Node, whitespace: Whitespace_$0): boolean;
    class Flow {
        readonly flowName: string;
        readonly parentFlowName: string | null;
        forcedBreakOffsets: number[];
        formattingContext: FormattingContext_$0 | null;
        constructor(flowName: string, parentFlowName: string | null);
    }
    class FlowChunk {
        flowName: string;
        element: Element;
        startOffset: number;
        priority: number;
        linger: number;
        exclusive: boolean;
        repeated: boolean;
        last: boolean;
        breakBefore: string | null;
        startPage: number;
        constructor(flowName: string, element: Element, startOffset: number, priority: number, linger: number, exclusive: boolean, repeated: boolean, last: boolean, breakBefore: string | null);
        isBetter(other: FlowChunk): boolean;
    }
    type ClientRect_$0 = Vtree.ClientRect_$0;
    function clientrectIncreasingTop(r1: ClientRect_$0, r2: ClientRect_$0): number;
    function clientrectDecreasingRight(r1: ClientRect_$0, r2: ClientRect_$0): number;
    type ClientLayout_$0 = Vtree.ClientLayout_$0;
    type LayoutContext_$0 = Vtree.LayoutContext_$0;
    type FormattingContext_$0 = Vtree.FormattingContext_$0;
    function eachAncestorFormattingContext(nodeContext: NodeContext_$0, callback: (p1: FormattingContext_$0) => any): void;
    type NodePositionStep_$0 = Vtree.NodePositionStep_$0;
    function isSameNodePositionStep(nps1: NodePositionStep_$0, nps2: NodePositionStep_$0): boolean;
    type NodePosition_$0 = Vtree.NodePosition_$0;
    function isSameNodePosition(np1: NodePosition_$0 | null, np2: NodePosition_$0 | null): boolean;
    function newNodePositionFromNode(node: Node): NodePosition_$0;
    function newNodePositionFromNodeContext(nodeContext: Vtree.NodeContext_$0, initialFragmentIndex: number | null): NodePosition_$0;
    function makeNodeContextFromNodePositionStep(step: NodePositionStep_$0, parent: Vtree.NodeContext_$0): NodeContext_$0;
    const ShadowType_$0: typeof Vtree.ShadowType_$0;
    type ShadowType_$0 = Vtree.ShadowType_$0;
    class ShadowContext_$0 implements Vtree.ShadowContext_$0 {
        readonly owner: Element;
        readonly root: Element;
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly parentShadow: ShadowContext_$0;
        readonly type: ShadowType_$0;
        readonly styler: object;
        subShadow: ShadowContext_$0;
        constructor(owner: Element, root: Element, xmldoc: XmlDoc.XMLDocHolder, parentShadow: ShadowContext_$0, superShadow: ShadowContext_$0, type: ShadowType_$0, styler: object);
        equals(other: ShadowContext_$0): boolean;
    }
    function isSameShadowContext(sc1: ShadowContext_$0, sc2: ShadowContext_$0): boolean;
    class FirstPseudo_$0 implements Vtree.FirstPseudo_$0 {
        readonly outer: FirstPseudo_$0;
        readonly count: number;
        constructor(outer: FirstPseudo_$0, count: number);
    }
    class NodeContext_$0 implements Vtree.NodeContext_$0 {
        sourceNode: Node;
        parent: NodeContext_$0;
        boxOffset: number;
        offsetInNode: number;
        after: boolean;
        shadowType: ShadowType_$0;
        shadowContext: ShadowContext_$0;
        nodeShadow: ShadowContext_$0;
        shadowSibling: NodeContext_$0;
        shared: boolean;
        inline: boolean;
        overflow: boolean;
        breakPenalty: number;
        display: string | null;
        floatReference: PageFloats.FloatReference;
        floatSide: string | null;
        clearSide: string | null;
        floatMinWrapBlock: Css.Numeric | null;
        columnSpan: Css.Val | null;
        verticalAlign: string;
        captionSide: string;
        inlineBorderSpacing: number;
        blockBorderSpacing: number;
        flexContainer: boolean;
        whitespace: Whitespace_$0;
        hyphenateCharacter: string | null;
        breakWord: boolean;
        establishesBFC: boolean;
        containingBlockForAbsolute: boolean;
        breakBefore: string | null;
        breakAfter: string | null;
        viewNode: Node;
        clearSpacer: Node;
        inheritedProps: {
            [key: string]: number | string | Css.Val;
        };
        vertical: boolean;
        direction: string;
        firstPseudo: FirstPseudo_$0;
        lang: string | null;
        preprocessedTextContent: Diff.Change[] | null;
        formattingContext: FormattingContext_$0;
        repeatOnBreak: string | null;
        pluginProps: {
            [key: string]: string | number | undefined | null | (number | null)[];
        };
        fragmentIndex: number;
        afterIfContinues: Selectors.AfterIfContinues;
        footnotePolicy: Css.Ident | null;
        constructor(sourceNode: Node, parent: NodeContext_$0, boxOffset: number);
        resetView(): void;
        private cloneItem;
        modify(): NodeContext_$0;
        copy(): NodeContext_$0;
        clone(): NodeContext_$0;
        toNodePositionStep(): NodePositionStep_$0;
        toNodePosition(): NodePosition_$0;
        isInsideBFC(): boolean;
        getContainingBlockForAbsolute(): NodeContext_$0;
        walkUpBlocks(callback: (p1: NodeContext_$0) => any): void;
        belongsTo(formattingContext: FormattingContext_$0): boolean;
    }
    class ChunkPosition_$0 implements Vtree.ChunkPosition_$0 {
        primary: NodePosition_$0;
        floats: NodePosition_$0[];
        constructor(primary: NodePosition_$0);
        clone(): ChunkPosition_$0;
        isSamePosition(other: ChunkPosition_$0): boolean;
    }
    class FlowChunkPosition {
        chunkPosition: ChunkPosition_$0;
        readonly flowChunk: FlowChunk;
        constructor(chunkPosition: ChunkPosition_$0, flowChunk: FlowChunk);
        clone(): FlowChunkPosition;
        isSamePosition(other: FlowChunkPosition): boolean;
    }
    class FlowPosition {
        positions: FlowChunkPosition[];
        startSide: string;
        breakAfter: string | null;
        clone(): FlowPosition;
        isSamePosition(other: FlowPosition): boolean;
        hasContent(offset: number): boolean;
    }
    class LayoutPosition {
        page: number;
        flows: {
            [key: string]: Flow;
        };
        flowPositions: {
            [key: string]: FlowPosition;
        };
        highestSeenOffset: number;
        highestSeenNode: Node;
        lookupPositionOffset: number;
        clone(): LayoutPosition;
        isSamePosition(other: LayoutPosition): boolean;
        hasContent(name: string, offset: number): boolean;
        startSideOfFlow(name: string): string;
        firstFlowChunkOfFlow(name: string): FlowChunk | null;
    }
    class Container_$0 implements Vtree.Container_$0 {
        element: Element;
        left: number;
        top: number;
        marginLeft: number;
        marginRight: number;
        marginTop: number;
        marginBottom: number;
        borderLeft: number;
        borderRight: number;
        borderTop: number;
        borderBottom: number;
        paddingLeft: number;
        paddingRight: number;
        paddingTop: number;
        paddingBottom: number;
        width: number;
        height: number;
        originX: number;
        originY: number;
        exclusions: GeometryUtil.Shape[];
        innerShape: GeometryUtil.Shape;
        computedBlockSize: number;
        snapWidth: number;
        snapHeight: number;
        snapOffsetX: number;
        snapOffsetY: number;
        vertical: boolean;
        constructor(element: Element);
        getInsetTop(): number;
        getInsetBottom(): number;
        getInsetLeft(): number;
        getInsetRight(): number;
        getInsetBefore(): number;
        getInsetAfter(): number;
        getInsetStart(): number;
        getInsetEnd(): number;
        getBeforeEdge(box: ClientRect_$0): number;
        getAfterEdge(box: ClientRect_$0): number;
        getStartEdge(box: ClientRect_$0): number;
        getEndEdge(box: ClientRect_$0): number;
        getInlineSize(box: ClientRect_$0): number;
        getBoxSize(box: ClientRect_$0): number;
        getBoxDir(): number;
        getInlineDir(): number;
        copyFrom(other: Container_$0): void;
        setVerticalPosition(top: number, height: number): void;
        setHorizontalPosition(left: number, width: number): void;
        setBlockPosition(start: number, extent: number): void;
        setInlinePosition(start: number, extent: number): void;
        clear(): void;
        getInnerShape(): GeometryUtil.Shape;
        getInnerRect(): GeometryUtil.Rect;
        getPaddingRect(): GeometryUtil.Rect;
        getOuterShape(outerShapeProp: Css.Val, context: Exprs.Context): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
    }
    type ExprContentListener_$0 = Vtree.ExprContentListener_$0;
    class ContentPropertyHandler extends Css.Visitor {
        readonly elem: Element;
        readonly context: Exprs.Context;
        readonly rootContentValue: Css.Val;
        readonly exprContentListener: ExprContentListener_$0;
        constructor(elem: Element, context: Exprs.Context, rootContentValue: Css.Val, exprContentListener: ExprContentListener_$0);
        private visitStrInner;
        visitStr(str: Css.Str): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function nonTrivialContent(val: Css.Val): boolean;
}
declare namespace Constants {
    let isDebug: boolean;
    function setDebug(value: boolean): void;
    enum PageProgression {
        LTR = "ltr",
        RTL = "rtl"
    }
    function pageProgressionOf(str: string): PageProgression;
    enum PageSide {
        LEFT = "left",
        RIGHT = "right"
    }
    enum ReadyState {
        LOADING = "loading",
        INTERACTIVE = "interactive",
        COMPLETE = "complete"
    }
    const constants: {
        PageProgression: typeof PageProgression;
        PageSide: typeof PageSide;
        ReadyState: typeof ReadyState;
    };
}
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace CssCascade {
    interface ElementStyle_$0 extends CssCascade.ElementStyle_$0 {
    }
    const inheritedProps: {
        azimuth: boolean;
        "border-collapse": boolean;
        "border-spacing": boolean;
        "caption-side": boolean;
        "clip-rule": boolean;
        color: boolean;
        "color-interpolation": boolean;
        "color-rendering": boolean;
        cursor: boolean;
        direction: boolean;
        elevation: boolean;
        "empty-cells": boolean;
        fill: boolean;
        "fill-opacity": boolean;
        "fill-rule": boolean;
        "font-kerning": boolean;
        "font-size": boolean;
        "font-size-adjust": boolean;
        "font-family": boolean;
        "font-feature-settings": boolean;
        "font-style": boolean;
        "font-stretch": boolean;
        "font-variant": boolean;
        "font-weight": boolean;
        "glyph-orientation-vertical": boolean;
        hyphens: boolean;
        "hyphenate-character": boolean;
        "hyphenate-limit-chars": boolean;
        "hyphenate-limit-last": boolean;
        "image-rendering": boolean;
        "image-resolution": boolean;
        "letter-spacing": boolean;
        "line-break": boolean;
        "line-height": boolean;
        "list-style-image": boolean;
        "list-style-position": boolean;
        "list-style-type": boolean;
        marker: boolean;
        "marker-end": boolean;
        "marker-mid": boolean;
        "marker-start": boolean;
        orphans: boolean;
        "overflow-wrap": boolean;
        "paint-order": boolean;
        "pointer-events": boolean;
        "pitch-range": boolean;
        quotes: boolean;
        richness: boolean;
        "ruby-align": boolean;
        "ruby-position": boolean;
        "speak-header": boolean;
        "speak-numeral": boolean;
        "speak-punctuation": boolean;
        "speech-rate": boolean;
        "shape-rendering": boolean;
        stress: boolean;
        stroke: boolean;
        "stroke-dasharray": boolean;
        "stroke-dashoffset": boolean;
        "stroke-linecap": boolean;
        "stroke-linejoin": boolean;
        "stroke-miterlimit": boolean;
        "stroke-opacity": boolean;
        "stroke-width": boolean;
        "tab-size": boolean;
        "text-align": boolean;
        "text-align-last": boolean;
        "text-anchor": boolean;
        "text-decoration-skip": boolean;
        "text-emphasis-color": boolean;
        "text-emphasis-position": boolean;
        "text-emphasis-style": boolean;
        "text-combine-upright": boolean;
        "text-indent": boolean;
        "text-justify": boolean;
        "text-rendering": boolean;
        "text-size-adjust": boolean;
        "text-transform": boolean;
        "text-underline-position": boolean;
        visibility: boolean;
        "voice-family": boolean;
        volume: boolean;
        "white-space": boolean;
        widows: boolean;
        "word-break": boolean;
        "word-spacing": boolean;
        "word-wrap": boolean;
        "writing-mode": boolean;
    };
    const polyfilledInheritedProps: string[];
    function getPolyfilledInheritedProps(): string[];
    const supportedNamespaces: {
        "http://www.idpf.org/2007/ops": boolean;
        "http://www.w3.org/1999/xhtml": boolean;
        "http://www.w3.org/2000/svg": boolean;
    };
    const coupledPatterns: string[];
    const coupledExtentPatterns: string[];
    const geomNames: {
        [key: string]: boolean;
    };
    function buildCouplingMap(sideMap: {
        [key: string]: string;
    }, extentMap: {
        [key: string]: string;
    }): {
        [key: string]: string;
    };
    const couplingMapVert: {
        [key: string]: string;
    };
    const couplingMapHor: {
        [key: string]: string;
    };
    const couplingMapVertRtl: {
        [key: string]: string;
    };
    const couplingMapHorRtl: {
        [key: string]: string;
    };
    class CascadeValue {
        readonly value: Css.Val;
        readonly priority: number;
        constructor(value: Css.Val, priority: number);
        getBaseValue(): CascadeValue;
        filterValue(visitor: Css.Visitor): CascadeValue;
        increaseSpecificity(specificity: number): CascadeValue;
        evaluate(context: Exprs.Context, propName: string): Css.Val;
        isEnabled(context: Exprs.Context): boolean;
    }
    class ConditionalCascadeValue extends CascadeValue {
        readonly condition: Exprs.Val;
        constructor(value: Css.Val, priority: number, condition: Exprs.Val);
        getBaseValue(): CascadeValue;
        filterValue(visitor: Css.Visitor): CascadeValue;
        increaseSpecificity(specificity: number): CascadeValue;
        isEnabled(context: Exprs.Context): boolean;
    }
    function cascadeValues(context: Exprs.Context, tv: CascadeValue, av: CascadeValue): CascadeValue;
    type ElementStyleMap = {
        [key: string]: ElementStyle_$0;
    };
    const SPECIALS: {
        "region-id": boolean;
        "fragment-selector-id": boolean;
    };
    function isSpecialName(name: string): boolean;
    function isMapName(name: string): boolean;
    function isPropName(name: string): boolean;
    function isInherited(name: string): boolean;
    function getProp(style: ElementStyle_$0, name: string): CascadeValue;
    function setProp(style: ElementStyle_$0, name: string, value: CascadeValue): any;
    function getStyleMap(style: ElementStyle_$0, name: string): ElementStyleMap;
    function getMutableStyleMap(style: ElementStyle_$0, name: string): ElementStyleMap;
    const getViewConditionalStyleMap: (style: ElementStyle_$0) => {
        matcher: Matchers.Matcher;
        styles: ElementStyleMap;
    }[];
    function getSpecial(style: ElementStyle_$0, name: string): CascadeValue[];
    function getMutableSpecial(style: ElementStyle_$0, name: string): CascadeValue[];
    function mergeIn(context: Exprs.Context, target: ElementStyle_$0, style: ElementStyle_$0, specificity: number, pseudoelement: string | null, regionId: string | null, viewConditionMatcher: Matchers.Matcher | null): void;
    function mergeAll(context: Exprs.Context, styles: ElementStyle_$0[]): ElementStyle_$0;
    function chainActions(chain: ChainedAction[], action: CascadeAction): CascadeAction;
    class InheritanceVisitor extends Css.FilterVisitor {
        readonly props: ElementStyle_$0;
        readonly context: Exprs.Context;
        propName: string;
        constructor(props: ElementStyle_$0, context: Exprs.Context);
        setPropName(name: string): void;
        private getFontSize;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function convertFontRelativeLengthToPx(numeric: Css.Numeric, baseFontSize: number, context: Exprs.Context): Css.Numeric;
    function convertFontSizeToPx(numeric: Css.Numeric, parentFontSize: number, context: Exprs.Context): Css.Numeric;
    type ActionTable = {
        [key: string]: CascadeAction;
    };
    class CascadeAction {
        apply(cascadeInstance: CascadeInstance): void;
        mergeWith(other: CascadeAction): CascadeAction;
        clone(): CascadeAction;
    }
    class ConditionItemAction extends CascadeAction {
        readonly conditionItem: ConditionItem;
        constructor(conditionItem: ConditionItem);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CompoundAction extends CascadeAction {
        readonly list: CascadeAction[];
        constructor(list: CascadeAction[]);
        apply(cascadeInstance: CascadeInstance): void;
        mergeWith(other: CascadeAction): CascadeAction;
        clone(): CascadeAction;
    }
    class ApplyRuleAction extends CascadeAction {
        readonly style: ElementStyle_$0;
        readonly specificity: number;
        readonly pseudoelement: string | null;
        readonly regionId: string | null;
        readonly viewConditionId: string | null;
        constructor(style: ElementStyle_$0, specificity: number, pseudoelement: string | null, regionId: string | null, viewConditionId: string | null);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class ChainedAction extends CascadeAction {
        chained: CascadeAction;
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckClassAction extends ChainedAction {
        readonly className: string;
        constructor(className: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckIdAction extends ChainedAction {
        readonly id: string;
        constructor(id: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckLocalNameAction extends ChainedAction {
        readonly localName: string;
        constructor(localName: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckNSTagAction extends ChainedAction {
        readonly ns: string;
        readonly localName: string;
        constructor(ns: string, localName: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckTargetEpubTypeAction extends ChainedAction {
        readonly epubTypePatt: RegExp;
        constructor(epubTypePatt: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckNamespaceAction extends ChainedAction {
        readonly ns: string;
        constructor(ns: string);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckAttributePresentAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        constructor(ns: string, name: string);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckAttributeEqAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        readonly value: string;
        constructor(ns: string, name: string, value: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckNamespaceSupportedAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        constructor(ns: string, name: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckAttributeRegExpAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        readonly regexp: RegExp;
        constructor(ns: string, name: string, regexp: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckLangAction extends ChainedAction {
        readonly langRegExp: RegExp;
        constructor(langRegExp: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class IsFirstAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsRootAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthAction extends ChainedAction {
        readonly a: number;
        readonly b: number;
        constructor(a: number, b: number);
        matchANPlusB(order: number): boolean;
    }
    class IsNthSiblingAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthSiblingOfTypeAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthLastSiblingAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthLastSiblingOfTypeAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsEmptyAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsEnabledAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsDisabledAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsCheckedAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class CheckConditionAction extends ChainedAction {
        readonly condition: string;
        constructor(condition: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class CheckAppliedAction extends CascadeAction {
        applied: boolean;
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        clone(): CascadeAction;
    }
    class NegateActionsSet extends ChainedAction {
        checkAppliedAction: CheckAppliedAction;
        firstAction: CascadeAction;
        constructor(list: ChainedAction[]);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    interface ConditionItem {
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AbstractConditionItem {
        readonly condition: string;
        readonly viewConditionId: string | null;
        readonly viewCondition: Matchers.Matcher;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        increment(cascadeInstance: CascadeInstance): void;
        decrement(cascadeInstance: CascadeInstance): void;
        buildViewConditionMatcher(cascadeInstance: CascadeInstance): Matchers.Matcher;
    }
    class DescendantConditionItem extends AbstractConditionItem implements ConditionItem {
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class ChildConditionItem extends AbstractConditionItem implements ConditionItem {
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AdjacentSiblingConditionItem extends AbstractConditionItem implements ConditionItem {
        fired: boolean;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class FollowingSiblingConditionItem extends AbstractConditionItem implements ConditionItem {
        fired: boolean;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AfterPseudoelementItem implements ConditionItem {
        readonly afterprop: ElementStyle_$0;
        readonly element: Element;
        constructor(afterprop: ElementStyle_$0, element: Element);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class RestoreLangItem implements ConditionItem {
        readonly lang: string;
        constructor(lang: string);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class QuotesScopeItem implements ConditionItem {
        readonly oldQuotes: Css.Str[];
        constructor(oldQuotes: Css.Str[]);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    type CounterValues = {
        [key: string]: number[];
    };
    interface CounterListener {
        countersOfId(id: string, counters: CounterValues): any;
        getExprContentListener(): Vtree_$0.ExprContentListener;
    }
    interface CounterResolver {
        getPageCounterVal(name: string, format: (p1: number | null) => string): Exprs.Val;
        getPageCountersVal(name: string, format: (p1: number[]) => string): Exprs.Val;
        getTargetCounterVal(url: string, name: string, format: (p1: number | null) => string): Exprs.Val;
        getTargetCountersVal(url: string, name: string, format: (p1: number[]) => string): Exprs.Val;
        setStyler(styler: any): any;
    }
    class AttrValueFilterVisitor extends Css.FilterVisitor {
        element: Element;
        constructor(element: Element);
        private createValueFromString;
        visitFunc(func: Css.Func): Css.Val;
    }
    class ContentPropVisitor extends Css.FilterVisitor {
        cascade: CascadeInstance;
        element: Element;
        readonly counterResolver: CounterResolver;
        constructor(cascade: CascadeInstance, element: Element, counterResolver: CounterResolver);
        visitIdent(ident: Css.Ident): Css.Val;
        private format;
        visitFuncCounter(values: Css.Val[]): Css.Val;
        visitFuncCounters(values: Css.Val[]): Css.Val;
        visitFuncTargetCounter(values: Css.Val[]): Css.Val;
        visitFuncTargetCounters(values: Css.Val[]): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
    }
    function roman(num: number): string;
    const additiveNumbering: {
        roman: (string | number)[];
        armenian: (string | number)[];
        georgian: (string | number)[];
        hebrew: (string | number)[];
    };
    const alphabeticNumbering: {
        latin: string;
        alpha: string;
        greek: string;
        russian: string;
    };
    const fixed: {
        square: string;
        disc: string;
        circle: string;
        none: string;
    };
    function additiveFormat(entries: any[], num: number): string;
    function expandAlphabet(str: string): string[] | null;
    function alphabeticFormat(alphabetStr: string, num: number): string;
    type ChineseNumbering = {
        digits: string;
        markers: string;
        negative: string;
        formal: boolean;
    };
    const chineseTradInformal: ChineseNumbering;
    function chineseCounter(num: number, numbering: ChineseNumbering): string;
    const ORDER_INCREMENT: number;
    function copyTable(src: ActionTable, dst: ActionTable): void;
    class Cascade {
        nsCount: number;
        nsPrefix: {
            [key: string]: string;
        };
        tags: ActionTable;
        nstags: ActionTable;
        epubtypes: ActionTable;
        classes: ActionTable;
        ids: ActionTable;
        pagetypes: ActionTable;
        order: number;
        clone(): Cascade;
        insertInTable(table: ActionTable, key: string, action: CascadeAction): void;
        createInstance(context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: any): CascadeInstance;
        nextOrder(): number;
    }
    class CascadeInstance {
        readonly context: Exprs.Context;
        readonly counterListener: CounterListener;
        readonly counterResolver: CounterResolver;
        code: Cascade;
        stack: ConditionItem[][];
        conditions: {
            [key: string]: number;
        };
        currentElement: Element | null;
        currentElementOffset: number | null;
        currentStyle: ElementStyle_$0 | null;
        currentClassNames: string[] | null;
        currentLocalName: string;
        currentNamespace: string;
        currentId: string;
        currentXmlId: string;
        currentNSTag: string;
        currentEpubTypes: string[] | null;
        currentPageType: string | null;
        isFirst: boolean;
        isRoot: boolean;
        counters: {
            [key: string]: number[];
        };
        counterScoping: {
            [key: string]: boolean;
        }[];
        quotes: Css.Str[];
        quoteDepth: number;
        lang: string;
        siblingOrderStack: number[];
        currentSiblingOrder: number;
        siblingTypeCountsStack: {
            [key: string]: {
                [key: string]: number;
            };
        }[];
        currentSiblingTypeCounts: {
            [key: string]: {
                [key: string]: number;
            };
        };
        currentFollowingSiblingOrder: number | null;
        followingSiblingOrderStack: (number | null)[];
        followingSiblingTypeCountsStack: {
            [key: string]: {
                [key: string]: number;
            };
        }[];
        currentFollowingSiblingTypeCounts: {
            [key: string]: {
                [key: string]: number;
            };
        };
        viewConditions: {
            [key: string]: Matchers.Matcher[];
        };
        dependentConditions: string[];
        elementStack: Element[];
        currentDoc?: Document | null;
        constructor(cascade: Cascade, context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: string);
        pushConditionItem(item: ConditionItem): void;
        increment(condition: string, viewCondition: Matchers.Matcher): void;
        decrement(condition: string, viewCondition: Matchers.Matcher): void;
        buildViewConditionMatcher(viewConditionId: string | null): Matchers.Matcher;
        applyAction(table: ActionTable, key: string): void;
        pushRule(classes: string[], pageType: string | null, baseStyle: ElementStyle_$0): void;
        defineCounter(counterName: string, value: number): void;
        pushCounters(props: ElementStyle_$0): void;
        popCounters(): void;
        processPseudoelementProps(pseudoprops: ElementStyle_$0, element: Element): void;
        pushElement(element: Element, baseStyle: ElementStyle_$0, elementOffset: number): void;
        private applyAttrFilterInner;
        private applyAttrFilter;
        private applyActions;
        private pop;
        popRule(): void;
        popElement(element: Element): void;
    }
    const EMPTY: any[];
    const pseudoNames: string[];
    enum ParseState {
        TOP = 0,
        SELECTOR = 1,
        RULE = 2
    }
    let uaBaseCascade: Cascade;
    function setUABaseCascade(value: Cascade): void;
    class CascadeParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
        readonly condition: Exprs.Val;
        readonly regionId: string | null;
        readonly validatorSet: CssValidator.ValidatorSet;
        chain: ChainedAction[];
        specificity: number;
        elementStyle: ElementStyle_$0;
        conditionCount: number;
        pseudoelement: string | null;
        footnoteContent: boolean;
        cascade: Cascade;
        state: ParseState;
        viewConditionId: string | null;
        insideSelectorRule: ParseState;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, condition: Exprs.Val, parent: CascadeParserHandler, regionId: string | null, validatorSet: CssValidator.ValidatorSet, topLevel: boolean);
        insertNonPrimary(action: CascadeAction): void;
        processChain(action: CascadeAction): void;
        isInsideSelectorRule(mnemonics: string): boolean;
        tagSelector(ns: string | null, name: string | null): void;
        classSelector(name: string): void;
        pseudoclassSelector(name: string, params: (number | string)[]): void;
        pseudoelementSelector(name: string, params: (number | string)[]): void;
        idSelector(id: string): void;
        attributeSelector(ns: string, name: string, op: CssTokenizer.TokenType, value: string | null): void;
        descendantSelector(): void;
        childSelector(): void;
        adjacentSiblingSelector(): void;
        followingSiblingSelector(): void;
        nextSelector(): void;
        startSelectorRule(): void;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        startStylesheet(flavor: CssParser.StylesheetFlavor): void;
        startRuleBody(): void;
        endRule(): void;
        finishChain(): void;
        makeApplyRuleAction(specificity: number): ApplyRuleAction;
        special(name: string, value: Css.Val): void;
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
        finish(): Cascade;
        startFuncWithSelector(funcName: string): void;
    }
    const nthSelectorActionClasses: {
        [key: string]: typeof IsNthAction;
    };
    let conditionCount: number;
    class NotParameterParserHandler extends CascadeParserHandler {
        readonly parent: CascadeParserHandler;
        parentChain: ChainedAction[];
        constructor(parent: CascadeParserHandler);
        startFuncWithSelector(funcName: string): void;
        startRuleBody(): void;
        nextSelector(): void;
        endFuncWithSelector(): void;
        error(mnemonics: string, token: CssTokenizer.Token): void;
    }
    class DefineParserHandler extends CssParser.SlaveParserHandler {
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler);
        property(name: string, value: Css.Val, important: boolean): void;
    }
    class PropSetParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
        readonly condition: Exprs.Val;
        readonly elementStyle: ElementStyle_$0;
        readonly validatorSet: CssValidator.ValidatorSet;
        order: number;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, condition: Exprs.Val, elementStyle: ElementStyle_$0, validatorSet: CssValidator.ValidatorSet);
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    class PropertyParserHandler extends CssParser.ErrorHandler implements CssValidator.PropertyReceiver {
        readonly validatorSet: CssValidator.ValidatorSet;
        elementStyle: ElementStyle_$0;
        order: number;
        constructor(scope: Exprs.LexicalScope, validatorSet: CssValidator.ValidatorSet);
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    function forEachViewConditionalStyles(style: ElementStyle_$0, callback: (p1: ElementStyle_$0) => any): void;
    function mergeViewConditionalStyles(cascMap: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, style: ElementStyle_$0): void;
    function parseStyleAttribute_$0(scope: Exprs.LexicalScope, validatorSet: CssValidator.ValidatorSet, baseURL: string, styleAttrValue: string): ElementStyle_$0;
    function isVertical(cascaded: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, vertical: boolean): boolean;
    function isRtl(cascaded: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, rtl: boolean): boolean;
    function flattenCascadedStyle(style: ElementStyle_$0, context: Exprs.Context, regionIds: string[], isFootnote: boolean, nodeContext: Vtree_$0.NodeContext): {
        [key: string]: CascadeValue;
    };
    function forEachStylesInRegion(style: ElementStyle_$0, regionIds: string[], isFootnote: boolean, callback: (p1: string, p2: ElementStyle_$0) => any): void;
    function mergeStyle(to: {
        [key: string]: CascadeValue;
    }, from: ElementStyle_$0, context: Exprs.Context): void;
    const convertToPhysical: <T>(src: {
        [key: string]: CascadeValue;
    }, dest: {
        [key: string]: T;
    }, vertical: boolean, rtl: boolean, transform: (p1: string, p2: CascadeValue) => T) => void;
}
declare namespace CssParser {
    const SPECIFICITY_USER_AGENT: number;
    const SPECIFICITY_USER: number;
    const SPECIFICITY_AUTHOR: number;
    const SPECIFICITY_STYLE: number;
    const SPECIFICITY_STYLE_IMPORTANT: number;
    const SPECIFICITY_AUTHOR_IMPORTANT: number;
    const SPECIFICITY_USER_IMPORTANT: number;
    enum StylesheetFlavor {
        USER_AGENT = "UA",
        USER = "User",
        AUTHOR = "Author"
    }
    function colorFromHash(text: string): Css.Color;
    class ParserHandler implements CssTokenizer.TokenizerHandler {
        scope: Exprs.LexicalScope;
        flavor: StylesheetFlavor;
        constructor(scope: Exprs.LexicalScope);
        getCurrentToken(): CssTokenizer.Token;
        getScope(): Exprs.LexicalScope;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        startStylesheet(flavor: StylesheetFlavor): void;
        tagSelector(ns: string | null, name: string | null): void;
        classSelector(name: string): void;
        pseudoclassSelector(name: string, params: (number | string)[]): void;
        pseudoelementSelector(name: string, params: (number | string)[]): void;
        idSelector(id: string): void;
        attributeSelector(ns: string, name: string, op: CssTokenizer.TokenType, value: string | null): void;
        descendantSelector(): void;
        childSelector(): void;
        adjacentSiblingSelector(): void;
        followingSiblingSelector(): void;
        nextSelector(): void;
        startSelectorRule(): void;
        startFontFaceRule(): void;
        startFootnoteRule(pseudoelem: string | null): void;
        startViewportRule(): void;
        startDefineRule(): void;
        startRegionRule(): void;
        startPageRule(): void;
        startPageMarginBoxRule(name: string): void;
        startWhenRule(expr: Css.Expr): void;
        startMediaRule(expr: Css.Expr): void;
        startFlowRule(flowName: string): void;
        startPageTemplateRule(): void;
        startPageMasterRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionGroupRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startRuleBody(): void;
        property(name: string, value: Css.Val, important: boolean): void;
        endRule(): void;
        startFuncWithSelector(funcName: string): void;
        endFuncWithSelector(): void;
        getImportantSpecificity(): number;
        getBaseSpecificity(): number;
    }
    class DispatchParserHandler extends ParserHandler {
        stack: ParserHandler[];
        tokenizer: CssTokenizer.Tokenizer;
        slave: ParserHandler;
        constructor();
        pushHandler(slave: ParserHandler): void;
        popHandler(): void;
        getCurrentToken(): CssTokenizer.Token;
        getScope(): Exprs.LexicalScope;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        errorMsg(mnemonics: string, token: CssTokenizer.Token): void;
        startStylesheet(flavor: StylesheetFlavor): void;
        tagSelector(ns: string | null, name: string | null): void;
        classSelector(name: string): void;
        pseudoclassSelector(name: string, params: (number | string)[]): void;
        pseudoelementSelector(name: string, params: (number | string)[]): void;
        idSelector(id: string): void;
        attributeSelector(ns: string, name: string, op: CssTokenizer.TokenType, value: string | null): void;
        descendantSelector(): void;
        childSelector(): void;
        adjacentSiblingSelector(): void;
        followingSiblingSelector(): void;
        nextSelector(): void;
        startSelectorRule(): void;
        startFontFaceRule(): void;
        startFootnoteRule(pseudoelem: string | null): void;
        startViewportRule(): void;
        startDefineRule(): void;
        startRegionRule(): void;
        startPageRule(): void;
        startPageMarginBoxRule(name: string): void;
        startWhenRule(expr: Css.Expr): void;
        startFlowRule(flowName: string): void;
        startPageTemplateRule(): void;
        startPageMasterRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionGroupRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startRuleBody(): void;
        property(name: string, value: Css.Val, important: boolean): void;
        endRule(): void;
        startFuncWithSelector(funcName: string): void;
        endFuncWithSelector(): void;
    }
    class SkippingParserHandler extends ParserHandler {
        owner: DispatchParserHandler;
        readonly topLevel: any;
        depth: number;
        flavor: StylesheetFlavor;
        constructor(scope: Exprs.LexicalScope, owner: DispatchParserHandler, topLevel: any);
        getCurrentToken(): CssTokenizer.Token;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        startRuleBody(): void;
        endRule(): void;
    }
    class SlaveParserHandler extends SkippingParserHandler {
        constructor(scope: Exprs.LexicalScope, owner: DispatchParserHandler, topLevel: boolean);
        report(message: string): void;
        reportAndSkip(message: string): void;
        startSelectorRule(): void;
        startFontFaceRule(): void;
        startFootnoteRule(pseudoelem: string | null): void;
        startViewportRule(): void;
        startDefineRule(): void;
        startRegionRule(): void;
        startPageRule(): void;
        startWhenRule(expr: Css.Expr): void;
        startFlowRule(flowName: string): void;
        startPageTemplateRule(): void;
        startPageMasterRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionGroupRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startFuncWithSelector(funcName: string): void;
        endFuncWithSelector(): void;
        property(name: string, value: Css.Val, important: boolean): void;
    }
    const actionsBase: Action_$0[];
    const actionsStyleAttribute: Action_$0[];
    const actionsSelector: Action_$0[];
    const actionsSelectorInFunc: Action_$0[];
    const actionsSelectorCont: Action_$0[];
    const actionsSelectorStart: Action_$0[];
    const actionsPropVal: Action_$0[];
    const actionsExprVal: Action_$0[];
    const actionsExprOp: Action_$0[];
    const actionsError: Action_$0[];
    const actionsErrorDecl: Action_$0[];
    const actionsErrorSelector: Action_$0[];
    const priority: number[];
    enum Action_$0 {
        SELECTOR_NAME_1 = 1,
        SELECTOR_NAME = 2,
        SELECTOR_ANY_1 = 3,
        SELECTOR_ANY = 4,
        SELECTOR_ID_1 = 5,
        SELECTOR_ID = 6,
        SELECTOR_CLASS_1 = 7,
        SELECTOR_CLASS = 8,
        SELECTOR_ATTR_1 = 9,
        SELECTOR_ATTR = 10,
        SELECTOR_CHILD = 11,
        SELECTOR_SIBLING = 12,
        SELECTOR_BODY = 13,
        SELECTOR_PSEUDOCLASS = 14,
        VAL_IDENT = 15,
        VAL_HASH = 16,
        VAL_NUM = 17,
        VAL_INT = 18,
        VAL_NUMERIC = 19,
        VAL_STR = 20,
        VAL_URL = 21,
        VAL_COMMA = 22,
        VAL_SLASH = 23,
        VAL_FUNC = 24,
        VAL_C_PAR = 25,
        VAL_END = 26,
        RULE_END = 27,
        IDENT = 28,
        SELECTOR_START = 29,
        AT = 30,
        EXPR_IDENT = 31,
        EXPR_NUM = 32,
        EXPR_NUMERIC = 33,
        EXPR_STR = 34,
        EXPR_PARAM = 35,
        EXPR_PREFIX = 36,
        EXPR_INFIX = 37,
        EXPR_FUNC = 38,
        EXPR_C_PAR = 39,
        EXPR_O_PAR = 40,
        SELECTOR_NEXT = 41,
        SELECTOR_PSEUDOELEM = 42,
        EXPR_O_BRC = 43,
        VAL_FINISH = 44,
        EXPR_INFIX_NAME = 45,
        PROP = 46,
        VAL_BANG = 47,
        VAL_BRC = 48,
        EXPR_SEMICOL = 49,
        ERROR_PUSH = 50,
        ERROR_POP = 51,
        ERROR_POP_DECL = 52,
        ERROR_SEMICOL = 53,
        VAL_PLUS = 54,
        SELECTOR_PSEUDOCLASS_1 = 55,
        SELECTOR_FOLLOWING_SIBLING = 56,
        DONE = 200
    }
    const OP_MEDIA_AND: number;
    enum ExprContext {
        PROP = 0,
        WHEN = 1,
        MEDIA = 2,
        IMPORT = 3
    }
    class Parser {
        actions: Action_$0[];
        tokenizer: CssTokenizer.Tokenizer;
        readonly handler: ParserHandler;
        baseURL: string;
        valStack: any[];
        namespacePrefixToURI: {
            [key: string]: string;
        };
        defaultNamespaceURI: string | null;
        propName: string | null;
        propImportant: boolean;
        exprContext: ExprContext;
        result: Css.Val;
        importReady: boolean;
        importURL: string | null;
        importCondition: Css.Expr;
        errorBrackets: number[];
        ruleStack: string[];
        regionRule: boolean;
        pageRule: boolean;
        constructor(actions: Action_$0[], tokenizer: CssTokenizer.Tokenizer, handler: ParserHandler, baseURL: string);
        extractVals(sep: string, index: number): Css.Val[];
        valStackReduce(sep: string, token: CssTokenizer.Token): Css.Val;
        exprError(mnemonics: string, token: CssTokenizer.Token): void;
        exprStackReduce(op: number, token: CssTokenizer.Token): boolean;
        readPseudoParams(): (number | string)[];
        private readNthPseudoParams;
        makeCondition(classes: string | null, condition: Exprs.Val): Css.Expr;
        isInsidePropertyOnlyRule(): boolean;
        runParser(count: number, parsingValue: any, parsingStyleAttr: boolean, parsingMediaQuery: any, parsingFunctionParam: any): boolean;
    }
    class ErrorHandler extends ParserHandler {
        readonly scope: Exprs.LexicalScope;
        constructor(scope: Exprs.LexicalScope);
        error(mnemonics: string, token: CssTokenizer.Token): void;
        getScope(): Exprs.LexicalScope;
    }
    function parseStylesheet(tokenizer: CssTokenizer.Tokenizer, handler: ParserHandler, baseURL: string, classes: string | null, media: string | null): Task.Result<boolean>;
    function parseStylesheetFromText(text: string, handler: ParserHandler, baseURL: string, classes: string | null, media: string | null): Task.Result<boolean>;
    function parseStylesheetFromURL(url: string, handler: ParserHandler, classes: string | null, media: string | null): Task.Result<boolean>;
    function parseValue(scope: Exprs.LexicalScope, tokenizer: CssTokenizer.Tokenizer, baseURL: string): Css.Val;
    function parseStyleAttribute(tokenizer: CssTokenizer.Tokenizer, handler: ParserHandler, baseURL: string): void;
    function parseMediaQuery(tokenizer: CssTokenizer.Tokenizer, handler: ParserHandler, baseURL: string): Css.Expr;
    const numProp: {
        [key: string]: boolean;
    };
    function takesOnlyNum(propName: string): boolean;
    function evaluateExprToCSS(context: Exprs.Context, val: Exprs.Val, propName: string): Css.Val;
    function evaluateCSSToCSS(context: Exprs.Context, val: Css.Val, propName: string): Css.Val;
}
declare namespace CssValidator {
    interface PropertyReceiver {
        unknownProperty(name: string, value: Css.Val): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    class Node {
        validator: PropertyValidator;
        success: Node;
        failure: Node;
        code: number;
        constructor(validator: PropertyValidator);
        isSpecial(): boolean;
        markAsStartGroup(): void;
        isStartGroup(): boolean;
        markAsEndGroup(): void;
        isEndGroup(): boolean;
        markAsStartAlternate(index: number): void;
        isStartAlternate(): boolean;
        markAsEndAlternate(index: number): void;
        isEndAlternate(): boolean;
        getAlternate(): number;
    }
    class Connection {
        where: number;
        success: boolean;
        what: number;
        constructor(where: number, success: boolean);
    }
    enum Add_$0 {
        FOLLOW = 1,
        OPTIONAL = 2,
        REPEATED = 3,
        ALTERNATE = 4
    }
    class ValidatingGroup {
        nodes: Node[];
        connections: Connection[];
        match: number[];
        nomatch: number[];
        error: number[];
        emptyHead: boolean;
        connect(arr: number[], nodeIndex: number): void;
        clone(): ValidatingGroup;
        private addSpecialToArr;
        endSpecialGroup(): void;
        startSpecialGroup(): void;
        endClause(clause: number): void;
        startClause(clause: number): void;
        addPrimitive(validator: PropertyValidator): void;
        isSimple(): boolean;
        isPrimitive(): boolean;
        addGroup(group: ValidatingGroup, how: Add_$0): void;
        finish(successTerminal: Node, failTerminal: Node): Node;
    }
    const ALLOW_EMPTY = 1;
    const ALLOW_STR = 2;
    const ALLOW_IDENT = 4;
    const ALLOW_POS_NUMERIC = 8;
    const ALLOW_POS_NUM = 16;
    const ALLOW_POS_INT = 32;
    const ALLOW_COLOR = 64;
    const ALLOW_URL = 128;
    const ALLOW_NEGATIVE = 256;
    const ALLOW_ZERO = 512;
    const ALLOW_ZERO_PERCENT = 1024;
    const ALLOW_SLASH = 2048;
    type ValueMap = {
        [key: string]: Css.Val;
    };
    class PropertyValidator extends Css.Visitor {
        constructor();
        validateForShorthand(values: Css.Val[], index: number): Css.Val[];
    }
    class PrimitiveValidator extends PropertyValidator {
        readonly allowed: number;
        readonly idents: ValueMap;
        readonly units: ValueMap;
        constructor(allowed: number, idents: ValueMap, units: ValueMap);
        visitEmpty(empty: Css.Val): Css.Val;
        visitSlash(slash: Css.Val): Css.Val;
        visitStr(str: Css.Str): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitNum(num: Css.Num): Css.Val;
        visitInt(num: Css.Int): Css.Val;
        visitColor(color: Css.Color): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
        combine(other: PrimitiveValidator): PrimitiveValidator;
    }
    const ALWAYS_FAIL: PrimitiveValidator;
    class ListValidator extends PropertyValidator {
        successTerminal: Node;
        failureTerminal: Node;
        first: Node;
        constructor(group: ValidatingGroup);
        validateList(arr: Css.Val[], slice: boolean, startIndex: number): Css.Val[];
        validateSingle(inval: Css.Val): Css.Val;
        visitEmpty(empty: Css.Val): Css.Val;
        visitSlash(slash: Css.Val): Css.Val;
        visitStr(str: Css.Str): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitNum(num: Css.Num): Css.Val;
        visitInt(num: Css.Int): Css.Val;
        visitColor(color: Css.Color): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    class SpaceListValidator extends ListValidator {
        constructor(group: ValidatingGroup);
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        validateForShorthand(values: Css.Val[], index: number): Css.Val[];
    }
    class CommaListValidator extends ListValidator {
        constructor(group: ValidatingGroup);
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        validateForShorthand(values: Css.Val[], index: number): Css.Val[];
    }
    class FuncValidator extends ListValidator {
        readonly name: string;
        constructor(name: string, group: ValidatingGroup);
        validateSingle(inval: Css.Val): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
    }
    class ShorthandSyntaxNode {
        tryParse(values: Css.Val[], index: number, shorthandValidator: ShorthandValidator): number;
        success(rval: Css.Val, shorthandValidator: ShorthandValidator): void;
    }
    class ShorthandSyntaxProperty extends ShorthandSyntaxNode {
        readonly name: string;
        validator: PropertyValidator;
        constructor(validatorSet: ValidatorSet, name: string);
        tryParse(values: Css.Val[], index: number, shorthandValidator: ShorthandValidator): number;
        success(rval: Css.Val, shorthandValidator: ShorthandValidator): void;
    }
    class ShorthandSyntaxPropertyN extends ShorthandSyntaxProperty {
        readonly names: string[];
        constructor(validatorSet: ValidatorSet, names: string[]);
        success(rval: Css.Val, shorthandValidator: ShorthandValidator): void;
    }
    class ShorthandSyntaxCompound extends ShorthandSyntaxNode {
        readonly nodes: ShorthandSyntaxNode[];
        readonly slash: boolean;
        constructor(nodes: ShorthandSyntaxNode[], slash: boolean);
        tryParse(values: Css.Val[], index: number, shorthandValidator: ShorthandValidator): number;
    }
    class ShorthandValidator extends Css.Visitor {
        syntax: ShorthandSyntaxNode[];
        propList: string[];
        error: boolean;
        values: ValueMap;
        validatorSet: ValidatorSet;
        setOwner(validatorSet: ValidatorSet): void;
        syntaxNodeForProperty(name: string): ShorthandSyntaxNode;
        clone(): this;
        init(syntax: ShorthandSyntaxNode[], propList: string[]): void;
        finish(important: boolean, receiver: PropertyReceiver): boolean;
        propagateInherit(important: boolean, receiver: PropertyReceiver): void;
        validateList(list: Css.Val[]): number;
        validateSingle(val: Css.Val): Css.Val;
        visitEmpty(empty: Css.Val): Css.Val;
        visitStr(str: Css.Str): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitNum(num: Css.Num): Css.Val;
        visitInt(num: Css.Int): Css.Val;
        visitColor(color: Css.Color): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    class SimpleShorthandValidator extends ShorthandValidator {
        constructor();
        validateList(list: Css.Val[]): number;
    }
    class InsetsShorthandValidator extends ShorthandValidator {
        constructor();
        validateList(list: Css.Val[]): number;
        createSyntaxNode(): ShorthandSyntaxPropertyN;
    }
    class InsetsSlashShorthandValidator extends ShorthandValidator {
        constructor();
        validateList(list: Css.Val[]): number;
    }
    class CommaShorthandValidator extends SimpleShorthandValidator {
        constructor();
        mergeIn(acc: {
            [key: string]: Css.Val[];
        }, values: ValueMap): void;
        visitCommaList(list: Css.CommaList): Css.Val;
    }
    class FontShorthandValidator extends SimpleShorthandValidator {
        constructor();
        init(syntax: ShorthandSyntaxNode[], propList: string[]): void;
        validateList(list: Css.Val[]): number;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
    }
    const shorthandValidators: {
        [key: string]: typeof ShorthandValidator;
    };
    class ValidatorSet {
        validators: {
            [key: string]: PropertyValidator;
        };
        prefixes: {
            [key: string]: {
                [key: string]: boolean;
            };
        };
        defaultValues: ValueMap;
        namedValidators: {
            [key: string]: ValidatingGroup;
        };
        systemFonts: {
            [key: string]: ValueMap;
        };
        shorthands: {
            [key: string]: ShorthandValidator;
        };
        layoutProps: ValueMap;
        backgroundProps: ValueMap;
        private addReplacement;
        private newGroup;
        private addCounts;
        private primitive;
        private newFunc;
        initBuiltInValidators(): void;
        private isBuiltIn;
        private readNameAndPrefixes;
        private parseValidators;
        private parseDefaults;
        private parseShorthands;
        parse(text: string): void;
        makePropSet(propList: string[]): ValueMap;
        validatePropertyAndHandleShorthand(name: string, value: Css.Val, important: boolean, receiver: PropertyReceiver): void;
    }
    function baseValidatorSet(): ValidatorSet;
}
declare namespace Exprs {
    type Preferences = {
        fontFamily: string;
        lineHeight: number;
        margin: number;
        hyphenate: boolean;
        columnWidth: number;
        horizontal: boolean;
        nightMode: boolean;
        spreadView: boolean;
        pageBorder: number;
        enabledMediaTypes: {
            [key: string]: boolean;
        };
        defaultPaperSize?: {
            [key: string]: number;
        };
    };
    function defaultPreferences(): Preferences;
    function clonePreferences(pref: Preferences): Preferences;
    const defaultPreferencesInstance: Preferences;
    const Special: {
        PENDING: Pending;
    };
    type Result = string | number | boolean | undefined;
    type PendingResult = Special | Result;
    function letterbox(viewW: number, viewH: number, objW: number, objH: number): string;
    function cssString(str: string): string;
    function cssIdent(name: string): string;
    function makeQualifiedName(objName: string | null, memberName: string): string;
    let nextKeyIndex: number;
    class LexicalScope {
        parent: LexicalScope;
        resolver?: (p1: string, p2: boolean) => Val;
        scopeKey: string;
        children: LexicalScope[];
        zero: Const;
        one: Const;
        _true: Const;
        _false: Const;
        values: {
            [key: string]: Val;
        };
        funcs: {
            [key: string]: Val;
        };
        builtIns: {
            [key: string]: (...p1: Result[]) => Result;
        };
        constructor(parent: LexicalScope, resolver?: (p1: string, p2: boolean) => Val);
        defineBuiltInName(name: string, fn: () => Result): void;
        defineName(qualifiedName: string, val: Val): void;
        defineFunc(qualifiedName: string, val: Val): void;
        defineBuiltIn(qualifiedName: string, fn: (...p1: Result[]) => Result): void;
    }
    function isAbsoluteLengthUnit(unit: string): boolean;
    function isViewportRelativeLengthUnit(unit: string): boolean;
    function isFontRelativeLengthUnit(unit: string): boolean;
    const defaultUnitSizes: {
        [key: string]: number;
    };
    function needUnitConversion(unit: string): boolean;
    type ScopeContext = {
        [key: string]: Result;
    };
    class Context {
        readonly rootScope: LexicalScope;
        readonly viewportWidth: number;
        readonly viewportHeight: number;
        protected actualPageWidth: number | null;
        pageWidth: () => number;
        protected actualPageHeight: number | null;
        pageHeight: () => number;
        initialFontSize: number;
        rootFontSize: number | null;
        fontSize: () => number;
        pref: Preferences;
        scopes: {
            [key: string]: ScopeContext;
        };
        pageAreaWidth: number | null;
        pageAreaHeight: number | null;
        pageVertical: boolean | null;
        pubTitle: string | null;
        docTitle: string | null;
        constructor(rootScope: LexicalScope, viewportWidth: number, viewportHeight: number, fontSize: number);
        private getScopeContext;
        clearScope(scope: LexicalScope): void;
        queryUnitSize(unit: string, isRoot: boolean): number;
        evalName(scope: LexicalScope, qualifiedName: string): Val;
        evalCall(scope: LexicalScope, qualifiedName: string, params: Val[], noBuiltInEval: boolean): Val;
        evalMediaName(name: string, not: boolean): boolean;
        evalMediaTest(feature: string, value: Val): boolean;
        queryVal(scope: LexicalScope, key: string): Result | undefined;
        storeVal(scope: LexicalScope, key: string, val: Result): void;
    }
    type DependencyCache = {
        [key: string]: boolean | Special;
    };
    class Val {
        scope: LexicalScope;
        key: string;
        constructor(scope: LexicalScope);
        toString(): string;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        expand(context: Context, params: Val[]): Val;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        dependOuter(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        depend(other: Val, context: Context): boolean;
        evaluate(context: Context): Result;
        isMediaName(): boolean;
    }
    class Prefix extends Val {
        val: Val;
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Infix extends Val {
        lhs: Val;
        rhs: Val;
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Logical extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Comparison extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Additive extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Multiplicative extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Not extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class Negate extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class And extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class AndMedia extends And {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Or extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class OrMedia extends Or {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Lt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Le extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Gt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ge extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Eq extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ne extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Add extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Subtract extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Multiply extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Divide extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Modulo extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Numeric extends Val {
        num: number;
        unit: string;
        constructor(scope: LexicalScope, num: number, unit: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class Named extends Val {
        qualifiedName: string;
        constructor(scope: LexicalScope, qualifiedName: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    }
    class MediaName extends Val {
        not: boolean;
        name: string;
        value: Val;
        constructor(scope: LexicalScope, not: boolean, name: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        isMediaName(): boolean;
    }
    class Native extends Val {
        fn: () => Result;
        str: string;
        constructor(scope: LexicalScope, fn: () => Result, str: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    function appendValArray(buf: Base.StringBuffer, arr: Val[]): void;
    function expandValArray(context: Context, arr: Val[], params: Val[]): Val[];
    function evalValArray(context: Context, arr: Val[]): Result[];
    class Call extends Val {
        qualifiedName: string;
        params: Val[];
        constructor(scope: LexicalScope, qualifiedName: string, params: Val[]);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Cond extends Val {
        cond: Val;
        ifTrue: Val;
        ifFalse: Val;
        constructor(scope: LexicalScope, cond: Val, ifTrue: Val, ifFalse: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Const extends Val {
        val: Result;
        constructor(scope: LexicalScope, val: Result);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class MediaTest extends Val {
        name: MediaName;
        value: Val;
        constructor(scope: LexicalScope, name: MediaName, value: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Param extends Val {
        index: number;
        constructor(scope: LexicalScope, index: number);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    function and(scope: LexicalScope, v1: Val, v2: Val): Val;
    function add(scope: LexicalScope, v1: Val, v2: Val): Val;
    function sub(scope: LexicalScope, v1: Val, v2: Val): Val;
    function mul(scope: LexicalScope, v1: Val, v2: Val): Val;
    function div(scope: LexicalScope, v1: Val, v2: Val): Val;
}
declare namespace Font {
    const traitProps: {
        [key: string]: Css.Val;
    };
    const bogusFontData: string;
    let bogusFontCounter: number;
    function makeFontTraitKey(properties: {
        [key: string]: Css.Val;
    }): string;
    function fillDefaults(properties: {
        [key: string]: Css.Val;
    }): void;
    function prepareProperties(properties: CssCascade_$0.ElementStyle, context: Exprs.Context): {
        [key: string]: Css.Val;
    };
    class Face {
        readonly properties: {
            [key: string]: Css.Val;
        };
        fontTraitKey: string;
        src: string | null;
        blobURLs: string[];
        blobs: Blob[];
        family: string | null;
        constructor(properties: {
            [key: string]: Css.Val;
        });
        traitsEqual(other: Face): boolean;
        makeAtRule(src: string, fontBytes: Blob): string;
    }
    class DocumentFaces {
        readonly deobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null;
        familyMap: {
            [key: string]: string;
        };
        constructor(deobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null);
        registerFamily(srcFace: Face, viewFace: Face): void;
        filterFontFamily(val: Css.Val): Css.Val;
    }
    class Mapper {
        readonly head: Element;
        readonly body: Element;
        srcURLMap: {
            [key: string]: TaskUtil.Fetcher<Face>;
        };
        familyPrefix: string;
        familyCounter: number;
        constructor(head: Element, body: Element, opt_familyPrefix?: string);
        getViewFontFamily(srcFace: Face, documentFaces: DocumentFaces): string;
        private initFont;
        loadFont(srcFace: Face, documentFaces: DocumentFaces): TaskUtil.Fetcher<Face>;
        findOrLoadFonts(srcFaces: Face[], documentFaces: DocumentFaces): Task.Result<boolean>;
    }
}
declare namespace PageMaster {
    let keyCount: number;
    abstract class PageBox<I extends PageBoxInstance = PageBoxInstance<any>> {
        readonly name: string | null;
        readonly pseudoName: string | null;
        readonly classes: string[];
        readonly parent: PageBox;
        specified: CssCascade.ElementStyle;
        children: PageBox[];
        pageMaster: PageMaster;
        index: number;
        key: string;
        protected _scope: Exprs.LexicalScope;
        get scope(): Exprs.LexicalScope;
        constructor(scope: Exprs.LexicalScope, name: string | null, pseudoName: string | null, classes: string[], parent: PageBox);
        createInstance(parentInstance: PageBoxInstance): PageBoxInstance;
        clone(param: {
            parent?: PageBox;
            pseudoName?: string;
        }): PageBox<I>;
        copySpecified(dest: PageBox): void;
        cloneChildren(parent: PageBox): void;
    }
    class RootPageBox extends PageBox<RootPageBoxInstance> {
        constructor(scope: Exprs.LexicalScope);
    }
    class PageMasterScope extends Exprs.LexicalScope {
        pageMaster: PageMaster;
        constructor(scope: Exprs.LexicalScope, pageMaster: PageMaster);
    }
    class PageMaster<I extends PageMasterInstance = PageMasterInstance<any>> extends PageBox<I> {
        readonly condition: Exprs.Val;
        readonly specificity: number;
        pageMaster: PageMaster;
        keyMap: {
            [key: string]: string;
        };
        constructor(scope: Exprs.LexicalScope, name: string | null, pseudoName: string | null, classes: string[], parent: RootPageBox, condition: Exprs.Val, specificity: number);
        createInstance(parentInstance: any): PageBoxInstance;
        clone(param: any): PageMaster;
        resetScope(): void;
    }
    class PartitionGroup extends PageBox<PartitionGroupInstance> {
        pageMaster: PageMaster;
        constructor(scope: Exprs.LexicalScope, name: string | null, pseudoName: string | null, classes: string[], parent: PageBox);
        createInstance(parentInstance: PageBoxInstance): PageBoxInstance;
        clone(param: any): PartitionGroup;
    }
    class Partition<I extends PartitionInstance = PartitionInstance> extends PageBox<I> {
        pageMaster: PageMaster;
        constructor(scope: Exprs.LexicalScope, name: string | null, pseudoName: string | null, classes: string[], parent: PageBox);
        createInstance(parentInstance: any): PageBoxInstance;
        clone(param: any): Partition;
    }
    function toExprIdent(scope: Exprs.LexicalScope, val: Css.Val, def: string): Exprs.Val;
    function toExprAuto(scope: Exprs.LexicalScope, val: Css.Val, ref: Exprs.Val): Exprs.Val;
    function toExprNormal(scope: Exprs.LexicalScope, val: Css.Val, ref: Exprs.Val): Exprs.Val;
    function toExprZero(scope: Exprs.LexicalScope, val: Css.Val, ref: Exprs.Val): Exprs.Val;
    function toExprZeroAuto(scope: Exprs.LexicalScope, val: Css.Val, ref: Exprs.Val): Exprs.Val;
    function toExprZeroBorder(scope: Exprs.LexicalScope, val: Css.Val, styleVal: Css.Val, ref: Exprs.Val): Exprs.Val;
    function toExprBool(scope: Exprs.LexicalScope, val: Css.Val, def: Exprs.Val): Exprs.Val;
    interface InstanceHolder extends Exprs.Context {
        registerInstance(key: string, instance: PageBoxInstance): void;
        lookupInstance(key: string): PageBoxInstance;
    }
    class PageBoxInstance<P extends PageBox = PageBox<any>> {
        readonly parentInstance: PageBoxInstance;
        readonly pageBox: P;
        protected cascaded: CssCascade.ElementStyle;
        style: {
            [key: string]: Css.Val;
        };
        private autoWidth;
        private autoHeight;
        children: PageBoxInstance[];
        isAutoWidth: boolean;
        isAutoHeight: boolean;
        isTopDependentOnAutoHeight: boolean;
        isRightDependentOnAutoWidth: boolean;
        private calculatedWidth;
        private calculatedHeight;
        pageMasterInstance: PageMasterInstance;
        namedValues: {
            [key: string]: Exprs.Val;
        };
        namedFuncs: {
            [key: string]: Exprs.Val;
        };
        vertical: boolean;
        rtl: boolean;
        suppressEmptyBoxGeneration: boolean;
        constructor(parentInstance: PageBoxInstance, pageBox: P);
        reset(): void;
        private addNamedValues;
        resolveName(name: string): Exprs.Val;
        resolveFunc(name: any): Exprs.Val;
        private initEnabled;
        boxSpecificEnabled(enabled: Exprs.Val): Exprs.Val;
        initHorizontal(): void;
        initVertical(): void;
        private initColumns;
        private depends;
        private init;
        getProp(context: Exprs.Context, name: string): Css.Val;
        getPropAsNumber(context: Exprs.Context, name: string): number;
        getSpecial(context: Exprs.Context, name: string): Css.Val[];
        getActiveRegions(context: Exprs.Context): string[];
        propagateProperty(context: Exprs.Context, container: Vtree_$0.Container, name: string, docFaces: Font.DocumentFaces): void;
        propagatePropertyToElement(context: Exprs.Context, element: Element, name: string, docFaces: Font.DocumentFaces): void;
        propagateDelayedProperty(context: Exprs.Context, container: Vtree_$0.Container, name: string, delayedItems: Vtree_$0.DelayedItem[]): void;
        assignLeftPosition(context: Exprs.Context, container: Vtree_$0.Container): void;
        assignRightPosition(context: Exprs.Context, container: Vtree_$0.Container): void;
        assignTopPosition(context: Exprs.Context, container: Vtree_$0.Container): void;
        assignBottomPosition(context: Exprs.Context, container: Vtree_$0.Container): void;
        assignBeforePosition(context: Exprs.Context, container: Vtree_$0.Container): void;
        assignAfterPosition(context: Exprs.Context, container: Vtree_$0.Container): void;
        assignStartEndPosition(context: Exprs.Context, container: Vtree_$0.Container): void;
        sizeWithMaxHeight(context: Exprs.Context, container: Vtree_$0.Container): void;
        sizeWithMaxWidth(context: Exprs.Context, container: Vtree_$0.Container): void;
        prepareContainer(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, docFaces: Font.DocumentFaces, clientLayout: Vtree_$0.ClientLayout): void;
        transferContentProps(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, docFaces: Font.DocumentFaces): void;
        transferSinglUriContentProps(context: Exprs.Context, element: Element, docFaces: Font.DocumentFaces): void;
        finishContainer(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, column: Vtree_$0.Container, columnCount: number, clientLayout: Vtree_$0.ClientLayout, docFaces: Font.DocumentFaces): void;
        applyCascadeAndInit(cascade: CssCascade.CascadeInstance, docElementStyle: CssCascade.ElementStyle): void;
        resolveAutoSizing(context: Exprs.Context): void;
    }
    const passPreProperties: string[];
    const passPostProperties: string[];
    const passContentProperties: string[];
    const passSingleUriContentProperties: string[];
    const delayedProperties: string[];
    const userAgentPageMasterPseudo = "background-host";
    class RootPageBoxInstance extends PageBoxInstance<RootPageBox> {
        constructor(pageBox: RootPageBox);
        applyCascadeAndInit(cascade: CssCascade.CascadeInstance, docElementStyle: CssCascade.ElementStyle): void;
    }
    class PageMasterInstance<P extends PageMaster = PageMaster<PageMasterInstance<any>>> extends PageBoxInstance<P> {
        pageMasterInstance: PageMasterInstance;
        constructor(parentInstance: PageBoxInstance, pageBox: P);
        boxSpecificEnabled(enabled: Exprs.Val): Exprs.Val;
        adjustPageLayout(context: Exprs.Context, page: Vtree_$0.Page, clientLayout: Vtree_$0.ClientLayout): void;
    }
    class PartitionGroupInstance extends PageBoxInstance<PartitionGroup> {
        pageMasterInstance: PageMasterInstance;
        constructor(parentInstance: PageBoxInstance, pageBox: PageBox);
    }
    class PartitionInstance<P extends Partition = Partition<PartitionInstance<any>>> extends PageBoxInstance<P> {
        pageMasterInstance: PageMasterInstance;
        constructor(parentInstance: PageBoxInstance, pageBox: P);
        processPartitionList(enabled: Exprs.Val, listVal: Css.Val, conflicting: boolean): Exprs.Val;
        boxSpecificEnabled(enabled: Exprs.Val): Exprs.Val;
        prepareContainer(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, docFaces: Font.DocumentFaces, clientLayout: Vtree_$0.ClientLayout): void;
    }
    class PageBoxParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
        readonly target: PageBox;
        readonly validatorSet: CssValidator.ValidatorSet;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, target: PageBox, validatorSet: CssValidator.ValidatorSet);
        property(name: string, value: Css.Val, important: boolean): void;
        unknownProperty(name: string, value: Css.Val): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    class PartitionParserHandler extends PageBoxParserHandler {
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, target: Partition, validatorSet: CssValidator.ValidatorSet);
    }
    class PartitionGroupParserHandler extends PageBoxParserHandler {
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, target: PartitionGroup, validatorSet: CssValidator.ValidatorSet);
        startPartitionRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionGroupRule(name: string | null, pseudoName: string | null, classes: string[]): void;
    }
    class PageMasterParserHandler extends PageBoxParserHandler {
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, target: PageMaster, validatorSet: CssValidator.ValidatorSet);
        startPartitionRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionGroupRule(name: string | null, pseudoName: string | null, classes: string[]): void;
    }
}
declare namespace Vtree_$0 {
    const delayedProps: {
        transform: boolean;
        "transform-origin": boolean;
    };
    const delayedPropsIfRelativePositioned: {
        top: boolean;
        bottom: boolean;
        left: boolean;
        right: boolean;
    };
    class DelayedItem {
        target: Element;
        name: string;
        value: Css.Val;
        constructor(target: Element, name: string, value: Css.Val);
    }
    type PageHyperlinkEvent = {
        type: string;
        target: any;
        currentTarget: any;
        anchorElement: Element;
        href: string;
    };
    type Trigger = {
        observer: string;
        event: string;
        action: string;
        ref: string;
    };
    const actions: {
        show: (obj: any) => void;
        hide: (obj: any) => void;
        play: (obj: any) => void;
        pause: (obj: any) => void;
        resume: (obj: any) => void;
        mute: (obj: any) => void;
        unmute: (obj: any) => void;
    };
    function makeListener(refs: Element[], action: string): EventListener | null;
    class Page extends Base.SimpleEventTarget {
        readonly container: HTMLElement;
        readonly bleedBox: HTMLElement;
        private static AUTO_PAGE_WIDTH_ATTRIBUTE;
        private static AUTO_PAGE_HEIGHT_ATTRIBUTE;
        pageAreaElement: HTMLElement | null;
        delayedItems: DelayedItem[];
        hrefHandler: (e: Event) => void;
        elementsById: {
            [key: string]: Element[];
        };
        dimensions: {
            width: number;
            height: number;
        };
        isFirstPage: boolean;
        isLastPage: boolean;
        isAutoPageWidth: boolean;
        isAutoPageHeight: boolean;
        spineIndex: number;
        position: LayoutPosition;
        offset: number;
        side: Constants.PageSide | null;
        fetchers: TaskUtil.Fetcher<{}>[];
        marginBoxes: {
            top: {
                [key: string]: Container_$0;
            };
            bottom: {
                [key: string]: Container_$0;
            };
            left: {
                [key: string]: Container_$0;
            };
            right: {
                [key: string]: Container_$0;
            };
        };
        constructor(container: HTMLElement, bleedBox: HTMLElement);
        setAutoPageWidth(isAuto: boolean): void;
        setAutoPageHeight(isAuto: boolean): void;
        registerElementWithId(element: Element, id: string): void;
        finish(triggers: Trigger[], clientLayout: ClientLayout_$0): void;
        zoom(scale: number): void;
        getPageAreaElement(): HTMLElement;
    }
    type Spread = {
        left: Page;
        right: Page;
    };
    const SPECIAL_ATTR = "data-adapt-spec";
    const Whitespace_$0: typeof Vtree.Whitespace_$0;
    type Whitespace_$0 = Vtree.Whitespace_$0;
    function whitespaceFromPropertyValue(whitespace: string): Whitespace_$0 | null;
    function canIgnore(node: Node, whitespace: Whitespace_$0): boolean;
    class Flow {
        readonly flowName: string;
        readonly parentFlowName: string | null;
        forcedBreakOffsets: number[];
        formattingContext: FormattingContext_$0 | null;
        constructor(flowName: string, parentFlowName: string | null);
    }
    class FlowChunk {
        flowName: string;
        element: Element;
        startOffset: number;
        priority: number;
        linger: number;
        exclusive: boolean;
        repeated: boolean;
        last: boolean;
        breakBefore: string | null;
        startPage: number;
        constructor(flowName: string, element: Element, startOffset: number, priority: number, linger: number, exclusive: boolean, repeated: boolean, last: boolean, breakBefore: string | null);
        isBetter(other: FlowChunk): boolean;
    }
    type ClientRect_$0 = Vtree.ClientRect_$0;
    function clientrectIncreasingTop(r1: ClientRect_$0, r2: ClientRect_$0): number;
    function clientrectDecreasingRight(r1: ClientRect_$0, r2: ClientRect_$0): number;
    type ClientLayout_$0 = Vtree.ClientLayout_$0;
    type LayoutContext_$0 = Vtree.LayoutContext_$0;
    type FormattingContext_$0 = Vtree.FormattingContext_$0;
    function eachAncestorFormattingContext(nodeContext: NodeContext_$0, callback: (p1: FormattingContext_$0) => any): void;
    type NodePositionStep_$0 = Vtree.NodePositionStep_$0;
    function isSameNodePositionStep(nps1: NodePositionStep_$0, nps2: NodePositionStep_$0): boolean;
    type NodePosition_$0 = Vtree.NodePosition_$0;
    function isSameNodePosition(np1: NodePosition_$0 | null, np2: NodePosition_$0 | null): boolean;
    function newNodePositionFromNode(node: Node): NodePosition_$0;
    function newNodePositionFromNodeContext(nodeContext: Vtree.NodeContext_$0, initialFragmentIndex: number | null): NodePosition_$0;
    function makeNodeContextFromNodePositionStep(step: NodePositionStep_$0, parent: Vtree.NodeContext_$0): NodeContext_$0;
    const ShadowType_$0: typeof Vtree.ShadowType_$0;
    type ShadowType_$0 = Vtree.ShadowType_$0;
    class ShadowContext_$0 implements Vtree.ShadowContext_$0 {
        readonly owner: Element;
        readonly root: Element;
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly parentShadow: ShadowContext_$0;
        readonly type: ShadowType_$0;
        readonly styler: object;
        subShadow: ShadowContext_$0;
        constructor(owner: Element, root: Element, xmldoc: XmlDoc.XMLDocHolder, parentShadow: ShadowContext_$0, superShadow: ShadowContext_$0, type: ShadowType_$0, styler: object);
        equals(other: ShadowContext_$0): boolean;
    }
    function isSameShadowContext(sc1: ShadowContext_$0, sc2: ShadowContext_$0): boolean;
    class FirstPseudo_$0 implements Vtree.FirstPseudo_$0 {
        readonly outer: FirstPseudo_$0;
        readonly count: number;
        constructor(outer: FirstPseudo_$0, count: number);
    }
    class NodeContext_$0 implements Vtree.NodeContext_$0 {
        sourceNode: Node;
        parent: NodeContext_$0;
        boxOffset: number;
        offsetInNode: number;
        after: boolean;
        shadowType: ShadowType_$0;
        shadowContext: ShadowContext_$0;
        nodeShadow: ShadowContext_$0;
        shadowSibling: NodeContext_$0;
        shared: boolean;
        inline: boolean;
        overflow: boolean;
        breakPenalty: number;
        display: string | null;
        floatReference: PageFloats.FloatReference;
        floatSide: string | null;
        clearSide: string | null;
        floatMinWrapBlock: Css.Numeric | null;
        columnSpan: Css.Val | null;
        verticalAlign: string;
        captionSide: string;
        inlineBorderSpacing: number;
        blockBorderSpacing: number;
        flexContainer: boolean;
        whitespace: Whitespace_$0;
        hyphenateCharacter: string | null;
        breakWord: boolean;
        establishesBFC: boolean;
        containingBlockForAbsolute: boolean;
        breakBefore: string | null;
        breakAfter: string | null;
        viewNode: Node;
        clearSpacer: Node;
        inheritedProps: {
            [key: string]: number | string | Css.Val;
        };
        vertical: boolean;
        direction: string;
        firstPseudo: FirstPseudo_$0;
        lang: string | null;
        preprocessedTextContent: Diff.Change[] | null;
        formattingContext: FormattingContext_$0;
        repeatOnBreak: string | null;
        pluginProps: {
            [key: string]: string | number | undefined | null | (number | null)[];
        };
        fragmentIndex: number;
        afterIfContinues: Selectors.AfterIfContinues;
        footnotePolicy: Css.Ident | null;
        constructor(sourceNode: Node, parent: NodeContext_$0, boxOffset: number);
        resetView(): void;
        private cloneItem;
        modify(): NodeContext_$0;
        copy(): NodeContext_$0;
        clone(): NodeContext_$0;
        toNodePositionStep(): NodePositionStep_$0;
        toNodePosition(): NodePosition_$0;
        isInsideBFC(): boolean;
        getContainingBlockForAbsolute(): NodeContext_$0;
        walkUpBlocks(callback: (p1: NodeContext_$0) => any): void;
        belongsTo(formattingContext: FormattingContext_$0): boolean;
    }
    class ChunkPosition_$0 implements Vtree.ChunkPosition_$0 {
        primary: NodePosition_$0;
        floats: NodePosition_$0[];
        constructor(primary: NodePosition_$0);
        clone(): ChunkPosition_$0;
        isSamePosition(other: ChunkPosition_$0): boolean;
    }
    class FlowChunkPosition {
        chunkPosition: ChunkPosition_$0;
        readonly flowChunk: FlowChunk;
        constructor(chunkPosition: ChunkPosition_$0, flowChunk: FlowChunk);
        clone(): FlowChunkPosition;
        isSamePosition(other: FlowChunkPosition): boolean;
    }
    class FlowPosition {
        positions: FlowChunkPosition[];
        startSide: string;
        breakAfter: string | null;
        clone(): FlowPosition;
        isSamePosition(other: FlowPosition): boolean;
        hasContent(offset: number): boolean;
    }
    class LayoutPosition {
        page: number;
        flows: {
            [key: string]: Flow;
        };
        flowPositions: {
            [key: string]: FlowPosition;
        };
        highestSeenOffset: number;
        highestSeenNode: Node;
        lookupPositionOffset: number;
        clone(): LayoutPosition;
        isSamePosition(other: LayoutPosition): boolean;
        hasContent(name: string, offset: number): boolean;
        startSideOfFlow(name: string): string;
        firstFlowChunkOfFlow(name: string): FlowChunk | null;
    }
    class Container_$0 implements Vtree.Container_$0 {
        element: Element;
        left: number;
        top: number;
        marginLeft: number;
        marginRight: number;
        marginTop: number;
        marginBottom: number;
        borderLeft: number;
        borderRight: number;
        borderTop: number;
        borderBottom: number;
        paddingLeft: number;
        paddingRight: number;
        paddingTop: number;
        paddingBottom: number;
        width: number;
        height: number;
        originX: number;
        originY: number;
        exclusions: GeometryUtil.Shape[];
        innerShape: GeometryUtil.Shape;
        computedBlockSize: number;
        snapWidth: number;
        snapHeight: number;
        snapOffsetX: number;
        snapOffsetY: number;
        vertical: boolean;
        constructor(element: Element);
        getInsetTop(): number;
        getInsetBottom(): number;
        getInsetLeft(): number;
        getInsetRight(): number;
        getInsetBefore(): number;
        getInsetAfter(): number;
        getInsetStart(): number;
        getInsetEnd(): number;
        getBeforeEdge(box: ClientRect_$0): number;
        getAfterEdge(box: ClientRect_$0): number;
        getStartEdge(box: ClientRect_$0): number;
        getEndEdge(box: ClientRect_$0): number;
        getInlineSize(box: ClientRect_$0): number;
        getBoxSize(box: ClientRect_$0): number;
        getBoxDir(): number;
        getInlineDir(): number;
        copyFrom(other: Container_$0): void;
        setVerticalPosition(top: number, height: number): void;
        setHorizontalPosition(left: number, width: number): void;
        setBlockPosition(start: number, extent: number): void;
        setInlinePosition(start: number, extent: number): void;
        clear(): void;
        getInnerShape(): GeometryUtil.Shape;
        getInnerRect(): GeometryUtil.Rect;
        getPaddingRect(): GeometryUtil.Rect;
        getOuterShape(outerShapeProp: Css.Val, context: Exprs.Context): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
    }
    type ExprContentListener_$0 = Vtree.ExprContentListener_$0;
    class ContentPropertyHandler extends Css.Visitor {
        readonly elem: Element;
        readonly context: Exprs.Context;
        readonly rootContentValue: Css.Val;
        readonly exprContentListener: ExprContentListener_$0;
        constructor(elem: Element, context: Exprs.Context, rootContentValue: Css.Val, exprContentListener: ExprContentListener_$0);
        private visitStrInner;
        visitStr(str: Css.Str): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function nonTrivialContent(val: Css.Val): boolean;
}
declare namespace Base {
    let emptyObj: {};
    type JSON = any;
    function jsonToString(json: JSON): string;
    function stringToJSON(str: string): JSON;
    function stripFragment(url: string): string;
    function stripFragmentAndQuery(url: string): string;
    let baseURL: string;
    function setBaseURL(value: string): void;
    let resourceBaseURL: string;
    function setResourceBaseURL(value: string): void;
    function resolveURL(relURL: string, baseURL: string): string;
    function convertSpecialURL(url: string): string;
    interface DocumentURLTransformer {
        transformFragment(fragment: string, baseURL: string): string;
        transformURL(url: string, baseURL: string): string;
        restoreURL(encoded: string): string[];
    }
    enum NS {
        FB2 = "http://www.gribuser.ru/xml/fictionbook/2.0",
        epub = "http://www.idpf.org/2007/ops",
        EV = "http://www.w3.org/2001/xml-events",
        MATHML = "http://www.w3.org/1998/Math/MathML",
        XML = "http://www.w3.org/XML/1998/namespace",
        XHTML = "http://www.w3.org/1999/xhtml",
        XLINK = "http://www.w3.org/1999/xlink",
        SHADOW = "http://www.pyroxy.com/ns/shadow",
        SVG = "http://www.w3.org/2000/svg",
        DC = "http://purl.org/dc/elements/1.1/",
        NCX = "http://www.daisy.org/z3986/2005/ncx/",
        SSE = "http://example.com/sse"
    }
    function getURLParam(name: string, opt_url?: string): string | null;
    function setURLParam(url: string, name: string, value: string): string;
    function asString(v: any): any;
    interface Comparable {
        compare(other: Comparable): number;
    }
    class PriorityQueue {
        queue: Comparable[];
        length(): number;
        add(item: Comparable): void;
        peek(): Comparable;
        remove(): Comparable;
    }
    function cssToJSProp(prefix: string, cssPropName: string): string;
    const knownPrefixes: string[];
    const propNameMap: {};
    function checkIfPropertySupported(prefix: string, prop: string): boolean;
    function getPrefixedPropertyNames(prop: string): string[] | null;
    function setCSSProperty(elem: Element, prop: string, value: string): void;
    function getCSSProperty(elem: Element, prop: string, opt_value?: string): string;
    function getLangAttribute(element: Element): string;
    class StringBuffer {
        list: string[];
        append(str: string): StringBuffer;
        clear(): void;
        toString(): string;
    }
    function escapeChar(str: string): string;
    function escapeCSSIdent(name: string): string;
    function escapeCSSStr(str: string): string;
    function lightURLEncode(str: string): string;
    function isLetter(ch: string): boolean;
    function escapeCharToHex(str: string, prefix?: string): string;
    function escapeNameStrToHex(str: string, prefix?: string): string;
    function escapeRegExp(str: string): string;
    function unescapeCharFromHex(str: string, prefix?: string): string;
    function unescapeStrFromHex(str: string, prefix?: string): string;
    function binarySearch(high: number, good: (p1: number) => boolean): number;
    function numberCompare(a: number, b: number): number;
    const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    function appendBase64(sb: StringBuffer, data: string): void;
    function indexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T;
    };
    function arrayToSet(arr: string[]): {
        [key: string]: boolean;
    };
    function multiIndexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T[];
    };
    function mapObj<P, R>(obj: {
        [key: string]: P;
    }, fn: (p1: P, p2: string) => R): {
        [key: string]: R;
    };
    function mapSize(obj: object): number;
    type Event = {
        type: string;
        target?: any;
        currentTarget?: any;
        preventDefault?: any;
        newPage?: any;
        anchorElement?: any;
        href?: any;
        content?: any;
    };
    type EventListener = (p1: Event) => void;
    class SimpleEventTarget {
        listeners: {
            [key: string]: EventListener[];
        };
        dispatchEvent(evt: Event): void;
        addEventListener(type: string, listener: EventListener, capture?: boolean): void;
        removeEventListener(type: string, listener: EventListener, capture?: boolean): void;
    }
    type EventTarget = SimpleEventTarget;
    let hasLShapeFloatBug: boolean | null;
    function checkLShapeFloatBug(body: HTMLElement): boolean;
    let hasVerticalBBoxBug: boolean | null;
    function checkVerticalBBoxBug(body: HTMLElement): boolean;
    let hasInlineBlockJustificationBug: boolean | null;
    function checkInlineBlockJustificationBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityAfterHyphenBug: boolean | null;
    function checkSoftWrapOpportunityAfterHyphenBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityByWbrBug: boolean | null;
    function checkSoftWrapOpportunityByWbrBug(body: HTMLElement): boolean;
}
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace CssCascade_$0 {
    interface ElementStyle_$0 extends CssCascade.ElementStyle_$0 {
    }
    const inheritedProps: {
        azimuth: boolean;
        "border-collapse": boolean;
        "border-spacing": boolean;
        "caption-side": boolean;
        "clip-rule": boolean;
        color: boolean;
        "color-interpolation": boolean;
        "color-rendering": boolean;
        cursor: boolean;
        direction: boolean;
        elevation: boolean;
        "empty-cells": boolean;
        fill: boolean;
        "fill-opacity": boolean;
        "fill-rule": boolean;
        "font-kerning": boolean;
        "font-size": boolean;
        "font-size-adjust": boolean;
        "font-family": boolean;
        "font-feature-settings": boolean;
        "font-style": boolean;
        "font-stretch": boolean;
        "font-variant": boolean;
        "font-weight": boolean;
        "glyph-orientation-vertical": boolean;
        hyphens: boolean;
        "hyphenate-character": boolean;
        "hyphenate-limit-chars": boolean;
        "hyphenate-limit-last": boolean;
        "image-rendering": boolean;
        "image-resolution": boolean;
        "letter-spacing": boolean;
        "line-break": boolean;
        "line-height": boolean;
        "list-style-image": boolean;
        "list-style-position": boolean;
        "list-style-type": boolean;
        marker: boolean;
        "marker-end": boolean;
        "marker-mid": boolean;
        "marker-start": boolean;
        orphans: boolean;
        "overflow-wrap": boolean;
        "paint-order": boolean;
        "pointer-events": boolean;
        "pitch-range": boolean;
        quotes: boolean;
        richness: boolean;
        "ruby-align": boolean;
        "ruby-position": boolean;
        "speak-header": boolean;
        "speak-numeral": boolean;
        "speak-punctuation": boolean;
        "speech-rate": boolean;
        "shape-rendering": boolean;
        stress: boolean;
        stroke: boolean;
        "stroke-dasharray": boolean;
        "stroke-dashoffset": boolean;
        "stroke-linecap": boolean;
        "stroke-linejoin": boolean;
        "stroke-miterlimit": boolean;
        "stroke-opacity": boolean;
        "stroke-width": boolean;
        "tab-size": boolean;
        "text-align": boolean;
        "text-align-last": boolean;
        "text-anchor": boolean;
        "text-decoration-skip": boolean;
        "text-emphasis-color": boolean;
        "text-emphasis-position": boolean;
        "text-emphasis-style": boolean;
        "text-combine-upright": boolean;
        "text-indent": boolean;
        "text-justify": boolean;
        "text-rendering": boolean;
        "text-size-adjust": boolean;
        "text-transform": boolean;
        "text-underline-position": boolean;
        visibility: boolean;
        "voice-family": boolean;
        volume: boolean;
        "white-space": boolean;
        widows: boolean;
        "word-break": boolean;
        "word-spacing": boolean;
        "word-wrap": boolean;
        "writing-mode": boolean;
    };
    const polyfilledInheritedProps: string[];
    function getPolyfilledInheritedProps(): string[];
    const supportedNamespaces: {
        "http://www.idpf.org/2007/ops": boolean;
        "http://www.w3.org/1999/xhtml": boolean;
        "http://www.w3.org/2000/svg": boolean;
    };
    const coupledPatterns: string[];
    const coupledExtentPatterns: string[];
    const geomNames: {
        [key: string]: boolean;
    };
    function buildCouplingMap(sideMap: {
        [key: string]: string;
    }, extentMap: {
        [key: string]: string;
    }): {
        [key: string]: string;
    };
    const couplingMapVert: {
        [key: string]: string;
    };
    const couplingMapHor: {
        [key: string]: string;
    };
    const couplingMapVertRtl: {
        [key: string]: string;
    };
    const couplingMapHorRtl: {
        [key: string]: string;
    };
    class CascadeValue {
        readonly value: Css.Val;
        readonly priority: number;
        constructor(value: Css.Val, priority: number);
        getBaseValue(): CascadeValue;
        filterValue(visitor: Css.Visitor): CascadeValue;
        increaseSpecificity(specificity: number): CascadeValue;
        evaluate(context: Exprs.Context, propName: string): Css.Val;
        isEnabled(context: Exprs.Context): boolean;
    }
    class ConditionalCascadeValue extends CascadeValue {
        readonly condition: Exprs.Val;
        constructor(value: Css.Val, priority: number, condition: Exprs.Val);
        getBaseValue(): CascadeValue;
        filterValue(visitor: Css.Visitor): CascadeValue;
        increaseSpecificity(specificity: number): CascadeValue;
        isEnabled(context: Exprs.Context): boolean;
    }
    function cascadeValues(context: Exprs.Context, tv: CascadeValue, av: CascadeValue): CascadeValue;
    type ElementStyleMap = {
        [key: string]: ElementStyle_$0;
    };
    const SPECIALS: {
        "region-id": boolean;
        "fragment-selector-id": boolean;
    };
    function isSpecialName(name: string): boolean;
    function isMapName(name: string): boolean;
    function isPropName(name: string): boolean;
    function isInherited(name: string): boolean;
    function getProp(style: ElementStyle_$0, name: string): CascadeValue;
    function setProp(style: ElementStyle_$0, name: string, value: CascadeValue): any;
    function getStyleMap(style: ElementStyle_$0, name: string): ElementStyleMap;
    function getMutableStyleMap(style: ElementStyle_$0, name: string): ElementStyleMap;
    const getViewConditionalStyleMap: (style: ElementStyle_$0) => {
        matcher: Matchers.Matcher;
        styles: ElementStyleMap;
    }[];
    function getSpecial(style: ElementStyle_$0, name: string): CascadeValue[];
    function getMutableSpecial(style: ElementStyle_$0, name: string): CascadeValue[];
    function mergeIn(context: Exprs.Context, target: ElementStyle_$0, style: ElementStyle_$0, specificity: number, pseudoelement: string | null, regionId: string | null, viewConditionMatcher: Matchers.Matcher | null): void;
    function mergeAll(context: Exprs.Context, styles: ElementStyle_$0[]): ElementStyle_$0;
    function chainActions(chain: ChainedAction[], action: CascadeAction): CascadeAction;
    class InheritanceVisitor extends Css.FilterVisitor {
        readonly props: ElementStyle_$0;
        readonly context: Exprs.Context;
        propName: string;
        constructor(props: ElementStyle_$0, context: Exprs.Context);
        setPropName(name: string): void;
        private getFontSize;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function convertFontRelativeLengthToPx(numeric: Css.Numeric, baseFontSize: number, context: Exprs.Context): Css.Numeric;
    function convertFontSizeToPx(numeric: Css.Numeric, parentFontSize: number, context: Exprs.Context): Css.Numeric;
    type ActionTable = {
        [key: string]: CascadeAction;
    };
    class CascadeAction {
        apply(cascadeInstance: CascadeInstance): void;
        mergeWith(other: CascadeAction): CascadeAction;
        clone(): CascadeAction;
    }
    class ConditionItemAction extends CascadeAction {
        readonly conditionItem: ConditionItem;
        constructor(conditionItem: ConditionItem);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CompoundAction extends CascadeAction {
        readonly list: CascadeAction[];
        constructor(list: CascadeAction[]);
        apply(cascadeInstance: CascadeInstance): void;
        mergeWith(other: CascadeAction): CascadeAction;
        clone(): CascadeAction;
    }
    class ApplyRuleAction extends CascadeAction {
        readonly style: ElementStyle_$0;
        readonly specificity: number;
        readonly pseudoelement: string | null;
        readonly regionId: string | null;
        readonly viewConditionId: string | null;
        constructor(style: ElementStyle_$0, specificity: number, pseudoelement: string | null, regionId: string | null, viewConditionId: string | null);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class ChainedAction extends CascadeAction {
        chained: CascadeAction;
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckClassAction extends ChainedAction {
        readonly className: string;
        constructor(className: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckIdAction extends ChainedAction {
        readonly id: string;
        constructor(id: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckLocalNameAction extends ChainedAction {
        readonly localName: string;
        constructor(localName: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckNSTagAction extends ChainedAction {
        readonly ns: string;
        readonly localName: string;
        constructor(ns: string, localName: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckTargetEpubTypeAction extends ChainedAction {
        readonly epubTypePatt: RegExp;
        constructor(epubTypePatt: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckNamespaceAction extends ChainedAction {
        readonly ns: string;
        constructor(ns: string);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckAttributePresentAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        constructor(ns: string, name: string);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckAttributeEqAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        readonly value: string;
        constructor(ns: string, name: string, value: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckNamespaceSupportedAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        constructor(ns: string, name: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckAttributeRegExpAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        readonly regexp: RegExp;
        constructor(ns: string, name: string, regexp: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckLangAction extends ChainedAction {
        readonly langRegExp: RegExp;
        constructor(langRegExp: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class IsFirstAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsRootAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthAction extends ChainedAction {
        readonly a: number;
        readonly b: number;
        constructor(a: number, b: number);
        matchANPlusB(order: number): boolean;
    }
    class IsNthSiblingAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthSiblingOfTypeAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthLastSiblingAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthLastSiblingOfTypeAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsEmptyAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsEnabledAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsDisabledAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsCheckedAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class CheckConditionAction extends ChainedAction {
        readonly condition: string;
        constructor(condition: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class CheckAppliedAction extends CascadeAction {
        applied: boolean;
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        clone(): CascadeAction;
    }
    class NegateActionsSet extends ChainedAction {
        checkAppliedAction: CheckAppliedAction;
        firstAction: CascadeAction;
        constructor(list: ChainedAction[]);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    interface ConditionItem {
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AbstractConditionItem {
        readonly condition: string;
        readonly viewConditionId: string | null;
        readonly viewCondition: Matchers.Matcher;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        increment(cascadeInstance: CascadeInstance): void;
        decrement(cascadeInstance: CascadeInstance): void;
        buildViewConditionMatcher(cascadeInstance: CascadeInstance): Matchers.Matcher;
    }
    class DescendantConditionItem extends AbstractConditionItem implements ConditionItem {
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class ChildConditionItem extends AbstractConditionItem implements ConditionItem {
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AdjacentSiblingConditionItem extends AbstractConditionItem implements ConditionItem {
        fired: boolean;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class FollowingSiblingConditionItem extends AbstractConditionItem implements ConditionItem {
        fired: boolean;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AfterPseudoelementItem implements ConditionItem {
        readonly afterprop: ElementStyle_$0;
        readonly element: Element;
        constructor(afterprop: ElementStyle_$0, element: Element);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class RestoreLangItem implements ConditionItem {
        readonly lang: string;
        constructor(lang: string);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class QuotesScopeItem implements ConditionItem {
        readonly oldQuotes: Css.Str[];
        constructor(oldQuotes: Css.Str[]);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    type CounterValues = {
        [key: string]: number[];
    };
    interface CounterListener {
        countersOfId(id: string, counters: CounterValues): any;
        getExprContentListener(): Vtree_$0.ExprContentListener;
    }
    interface CounterResolver {
        getPageCounterVal(name: string, format: (p1: number | null) => string): Exprs.Val;
        getPageCountersVal(name: string, format: (p1: number[]) => string): Exprs.Val;
        getTargetCounterVal(url: string, name: string, format: (p1: number | null) => string): Exprs.Val;
        getTargetCountersVal(url: string, name: string, format: (p1: number[]) => string): Exprs.Val;
        setStyler(styler: any): any;
    }
    class AttrValueFilterVisitor extends Css.FilterVisitor {
        element: Element;
        constructor(element: Element);
        private createValueFromString;
        visitFunc(func: Css.Func): Css.Val;
    }
    class ContentPropVisitor extends Css.FilterVisitor {
        cascade: CascadeInstance;
        element: Element;
        readonly counterResolver: CounterResolver;
        constructor(cascade: CascadeInstance, element: Element, counterResolver: CounterResolver);
        visitIdent(ident: Css.Ident): Css.Val;
        private format;
        visitFuncCounter(values: Css.Val[]): Css.Val;
        visitFuncCounters(values: Css.Val[]): Css.Val;
        visitFuncTargetCounter(values: Css.Val[]): Css.Val;
        visitFuncTargetCounters(values: Css.Val[]): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
    }
    function roman(num: number): string;
    const additiveNumbering: {
        roman: (string | number)[];
        armenian: (string | number)[];
        georgian: (string | number)[];
        hebrew: (string | number)[];
    };
    const alphabeticNumbering: {
        latin: string;
        alpha: string;
        greek: string;
        russian: string;
    };
    const fixed: {
        square: string;
        disc: string;
        circle: string;
        none: string;
    };
    function additiveFormat(entries: any[], num: number): string;
    function expandAlphabet(str: string): string[] | null;
    function alphabeticFormat(alphabetStr: string, num: number): string;
    type ChineseNumbering = {
        digits: string;
        markers: string;
        negative: string;
        formal: boolean;
    };
    const chineseTradInformal: ChineseNumbering;
    function chineseCounter(num: number, numbering: ChineseNumbering): string;
    const ORDER_INCREMENT: number;
    function copyTable(src: ActionTable, dst: ActionTable): void;
    class Cascade {
        nsCount: number;
        nsPrefix: {
            [key: string]: string;
        };
        tags: ActionTable;
        nstags: ActionTable;
        epubtypes: ActionTable;
        classes: ActionTable;
        ids: ActionTable;
        pagetypes: ActionTable;
        order: number;
        clone(): Cascade;
        insertInTable(table: ActionTable, key: string, action: CascadeAction): void;
        createInstance(context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: any): CascadeInstance;
        nextOrder(): number;
    }
    class CascadeInstance {
        readonly context: Exprs.Context;
        readonly counterListener: CounterListener;
        readonly counterResolver: CounterResolver;
        code: Cascade;
        stack: ConditionItem[][];
        conditions: {
            [key: string]: number;
        };
        currentElement: Element | null;
        currentElementOffset: number | null;
        currentStyle: ElementStyle_$0 | null;
        currentClassNames: string[] | null;
        currentLocalName: string;
        currentNamespace: string;
        currentId: string;
        currentXmlId: string;
        currentNSTag: string;
        currentEpubTypes: string[] | null;
        currentPageType: string | null;
        isFirst: boolean;
        isRoot: boolean;
        counters: {
            [key: string]: number[];
        };
        counterScoping: {
            [key: string]: boolean;
        }[];
        quotes: Css.Str[];
        quoteDepth: number;
        lang: string;
        siblingOrderStack: number[];
        currentSiblingOrder: number;
        siblingTypeCountsStack: {
            [key: string]: {
                [key: string]: number;
            };
        }[];
        currentSiblingTypeCounts: {
            [key: string]: {
                [key: string]: number;
            };
        };
        currentFollowingSiblingOrder: number | null;
        followingSiblingOrderStack: (number | null)[];
        followingSiblingTypeCountsStack: {
            [key: string]: {
                [key: string]: number;
            };
        }[];
        currentFollowingSiblingTypeCounts: {
            [key: string]: {
                [key: string]: number;
            };
        };
        viewConditions: {
            [key: string]: Matchers.Matcher[];
        };
        dependentConditions: string[];
        elementStack: Element[];
        currentDoc?: Document | null;
        constructor(cascade: Cascade, context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: string);
        pushConditionItem(item: ConditionItem): void;
        increment(condition: string, viewCondition: Matchers.Matcher): void;
        decrement(condition: string, viewCondition: Matchers.Matcher): void;
        buildViewConditionMatcher(viewConditionId: string | null): Matchers.Matcher;
        applyAction(table: ActionTable, key: string): void;
        pushRule(classes: string[], pageType: string | null, baseStyle: ElementStyle_$0): void;
        defineCounter(counterName: string, value: number): void;
        pushCounters(props: ElementStyle_$0): void;
        popCounters(): void;
        processPseudoelementProps(pseudoprops: ElementStyle_$0, element: Element): void;
        pushElement(element: Element, baseStyle: ElementStyle_$0, elementOffset: number): void;
        private applyAttrFilterInner;
        private applyAttrFilter;
        private applyActions;
        private pop;
        popRule(): void;
        popElement(element: Element): void;
    }
    const EMPTY: any[];
    const pseudoNames: string[];
    enum ParseState {
        TOP = 0,
        SELECTOR = 1,
        RULE = 2
    }
    let uaBaseCascade: Cascade;
    function setUABaseCascade(value: Cascade): void;
    class CascadeParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
        readonly condition: Exprs.Val;
        readonly regionId: string | null;
        readonly validatorSet: CssValidator.ValidatorSet;
        chain: ChainedAction[];
        specificity: number;
        elementStyle: ElementStyle_$0;
        conditionCount: number;
        pseudoelement: string | null;
        footnoteContent: boolean;
        cascade: Cascade;
        state: ParseState;
        viewConditionId: string | null;
        insideSelectorRule: ParseState;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, condition: Exprs.Val, parent: CascadeParserHandler, regionId: string | null, validatorSet: CssValidator.ValidatorSet, topLevel: boolean);
        insertNonPrimary(action: CascadeAction): void;
        processChain(action: CascadeAction): void;
        isInsideSelectorRule(mnemonics: string): boolean;
        tagSelector(ns: string | null, name: string | null): void;
        classSelector(name: string): void;
        pseudoclassSelector(name: string, params: (number | string)[]): void;
        pseudoelementSelector(name: string, params: (number | string)[]): void;
        idSelector(id: string): void;
        attributeSelector(ns: string, name: string, op: CssTokenizer.TokenType, value: string | null): void;
        descendantSelector(): void;
        childSelector(): void;
        adjacentSiblingSelector(): void;
        followingSiblingSelector(): void;
        nextSelector(): void;
        startSelectorRule(): void;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        startStylesheet(flavor: CssParser.StylesheetFlavor): void;
        startRuleBody(): void;
        endRule(): void;
        finishChain(): void;
        makeApplyRuleAction(specificity: number): ApplyRuleAction;
        special(name: string, value: Css.Val): void;
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
        finish(): Cascade;
        startFuncWithSelector(funcName: string): void;
    }
    const nthSelectorActionClasses: {
        [key: string]: typeof IsNthAction;
    };
    let conditionCount: number;
    class NotParameterParserHandler extends CascadeParserHandler {
        readonly parent: CascadeParserHandler;
        parentChain: ChainedAction[];
        constructor(parent: CascadeParserHandler);
        startFuncWithSelector(funcName: string): void;
        startRuleBody(): void;
        nextSelector(): void;
        endFuncWithSelector(): void;
        error(mnemonics: string, token: CssTokenizer.Token): void;
    }
    class DefineParserHandler extends CssParser.SlaveParserHandler {
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler);
        property(name: string, value: Css.Val, important: boolean): void;
    }
    class PropSetParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
        readonly condition: Exprs.Val;
        readonly elementStyle: ElementStyle_$0;
        readonly validatorSet: CssValidator.ValidatorSet;
        order: number;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, condition: Exprs.Val, elementStyle: ElementStyle_$0, validatorSet: CssValidator.ValidatorSet);
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    class PropertyParserHandler extends CssParser.ErrorHandler implements CssValidator.PropertyReceiver {
        readonly validatorSet: CssValidator.ValidatorSet;
        elementStyle: ElementStyle_$0;
        order: number;
        constructor(scope: Exprs.LexicalScope, validatorSet: CssValidator.ValidatorSet);
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    function forEachViewConditionalStyles(style: ElementStyle_$0, callback: (p1: ElementStyle_$0) => any): void;
    function mergeViewConditionalStyles(cascMap: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, style: ElementStyle_$0): void;
    function parseStyleAttribute_$0(scope: Exprs.LexicalScope, validatorSet: CssValidator.ValidatorSet, baseURL: string, styleAttrValue: string): ElementStyle_$0;
    function isVertical(cascaded: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, vertical: boolean): boolean;
    function isRtl(cascaded: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, rtl: boolean): boolean;
    function flattenCascadedStyle(style: ElementStyle_$0, context: Exprs.Context, regionIds: string[], isFootnote: boolean, nodeContext: Vtree_$0.NodeContext): {
        [key: string]: CascadeValue;
    };
    function forEachStylesInRegion(style: ElementStyle_$0, regionIds: string[], isFootnote: boolean, callback: (p1: string, p2: ElementStyle_$0) => any): void;
    function mergeStyle(to: {
        [key: string]: CascadeValue;
    }, from: ElementStyle_$0, context: Exprs.Context): void;
    const convertToPhysical: <T>(src: {
        [key: string]: CascadeValue;
    }, dest: {
        [key: string]: T;
    }, vertical: boolean, rtl: boolean, transform: (p1: string, p2: CascadeValue) => T) => void;
}
declare namespace CssStyler_$0 {
    class SlipRange {
        endStuckFixed: number;
        endFixed: number;
        endSlipped: number;
        constructor(endStuckFixed: any, endFixed: any, endSlipped: any);
    }
    class SlipMap {
        map: SlipRange[];
        getMaxFixed(): number;
        getMaxSlipped(): number;
        addStuckRange(endFixed: number): void;
        addSlippedRange(endFixed: number): void;
        slippedByFixed(fixed: number): number;
        fixedBySlipped(slipped: number): number;
    }
    interface FlowListener {
        encounteredFlowChunk(flowChunk: Vtree_$0.FlowChunk, flow: Vtree_$0.Flow): any;
    }
    interface AbstractStyler_$0 extends CssStyler.AbstractStyler_$0 {
    }
    class Box {
        readonly context: Exprs.Context;
        readonly style: CssCascade_$0.ElementStyle;
        readonly offset: number;
        readonly isRoot: boolean;
        readonly flowChunk: Vtree_$0.FlowChunk;
        readonly atBlockStart: boolean;
        readonly atFlowStart: boolean;
        readonly isParentBoxDisplayed: boolean;
        flowName: string;
        isBlockValue: boolean | null;
        hasBoxValue: boolean | null;
        styleValues: {
            [key: string]: Css.Val;
        };
        beforeBox: Box;
        afterBox: Box;
        breakBefore: string | null;
        constructor(context: Exprs.Context, style: CssCascade_$0.ElementStyle, offset: number, isRoot: boolean, flowChunk: Vtree_$0.FlowChunk, atBlockStart: boolean, atFlowStart: boolean, isParentBoxDisplayed: boolean);
        buildAfterPseudoElementBox(offset: number, atBlockStart: boolean, atFlowStart: boolean): void;
        styleValue(name: string, defaultValue?: Css.Val): Css.Val | null;
        displayValue(): Css.Val;
        isBlock(): boolean;
        hasBox(): boolean;
        getBreakValue(edge: string): string | null;
    }
    class BoxStack {
        readonly context: Exprs.Context;
        stack: Box[];
        atBlockStart: boolean;
        atFlowStart: boolean;
        atStartStack: {
            atBlockStart: boolean;
            atFlowStart: boolean;
        }[];
        constructor(context: Exprs.Context);
        empty(): boolean;
        lastBox(): Box | undefined;
        lastFlowName(): string | null;
        isCurrentBoxDisplayed(): boolean;
        push(style: CssCascade_$0.ElementStyle, offset: number, isRoot: boolean, newFlowChunk?: Vtree_$0.FlowChunk): Box;
        encounteredTextNode(node: Node): void;
        pop(offset: number): Box;
        nearestBlockStartOffset(box: Box): number;
    }
    class Styler implements AbstractStyler_$0 {
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly scope: Exprs.LexicalScope;
        readonly context: Exprs.Context;
        readonly primaryFlows: {
            [key: string]: boolean;
        };
        readonly validatorSet: CssValidator.ValidatorSet;
        readonly counterListener: CssCascade_$0.CounterListener;
        root: Element;
        cascadeHolder: CssCascade_$0.Cascade;
        last: Node;
        rootStyle: CssCascade_$0.ElementStyle;
        styleMap: {
            [key: string]: CssCascade_$0.ElementStyle;
        };
        flows: {
            [key: string]: Vtree_$0.Flow;
        };
        flowChunks: Vtree_$0.FlowChunk[];
        flowListener: FlowListener;
        flowToReach: string | null;
        idToReach: string | null;
        cascade: CssCascade_$0.CascadeInstance;
        offsetMap: SlipMap;
        primary: boolean;
        primaryStack: boolean[];
        rootBackgroundAssigned: boolean;
        rootLayoutAssigned: boolean;
        lastOffset: number;
        breakBeforeValues: {
            [key: number]: string;
        };
        boxStack: BoxStack;
        bodyReached: boolean;
        constructor(xmldoc: XmlDoc.XMLDocHolder, cascade: CssCascade_$0.Cascade, scope: Exprs.LexicalScope, context: Exprs.Context, primaryFlows: {
            [key: string]: boolean;
        }, validatorSet: CssValidator.ValidatorSet, counterListener: CssCascade_$0.CounterListener, counterResolver: CssCascade_$0.CounterResolver);
        hasProp(style: CssCascade_$0.ElementStyle, map: CssValidator.ValueMap, name: string): boolean;
        transferPropsToRoot(srcStyle: CssCascade_$0.ElementStyle, map: CssValidator.ValueMap): void;
        postprocessTopStyle(elemStyle: CssCascade_$0.ElementStyle, isBody: boolean): void;
        getTopContainerStyle(): CssCascade_$0.ElementStyle;
        getAttrStyle(elem: Element): CssCascade_$0.ElementStyle;
        getReachedOffset(): number;
        replayFlowElementsFromOffset(offset: number): void;
        resetFlowChunkStream(flowListener: FlowListener): void;
        styleUntilFlowIsReached(flowName: string): void;
        styleUntilIdIsReached(id: string): void;
        private encounteredFlowElement;
        registerForcedBreakOffset(breakValue: string | null, offset: number, flowName: string): void;
        styleUntil(startOffset: number, lookup: number): number;
        getStyle(element: Element, deep: boolean): CssCascade_$0.ElementStyle;
        processContent(element: Element, styles: {
            [key: string]: Css.Val;
        }): void;
    }
    const columnProps: string[];
}
declare namespace Exprs {
    type Preferences = {
        fontFamily: string;
        lineHeight: number;
        margin: number;
        hyphenate: boolean;
        columnWidth: number;
        horizontal: boolean;
        nightMode: boolean;
        spreadView: boolean;
        pageBorder: number;
        enabledMediaTypes: {
            [key: string]: boolean;
        };
        defaultPaperSize?: {
            [key: string]: number;
        };
    };
    function defaultPreferences(): Preferences;
    function clonePreferences(pref: Preferences): Preferences;
    const defaultPreferencesInstance: Preferences;
    const Special: {
        PENDING: Pending;
    };
    type Result = string | number | boolean | undefined;
    type PendingResult = Special | Result;
    function letterbox(viewW: number, viewH: number, objW: number, objH: number): string;
    function cssString(str: string): string;
    function cssIdent(name: string): string;
    function makeQualifiedName(objName: string | null, memberName: string): string;
    let nextKeyIndex: number;
    class LexicalScope {
        parent: LexicalScope;
        resolver?: (p1: string, p2: boolean) => Val;
        scopeKey: string;
        children: LexicalScope[];
        zero: Const;
        one: Const;
        _true: Const;
        _false: Const;
        values: {
            [key: string]: Val;
        };
        funcs: {
            [key: string]: Val;
        };
        builtIns: {
            [key: string]: (...p1: Result[]) => Result;
        };
        constructor(parent: LexicalScope, resolver?: (p1: string, p2: boolean) => Val);
        defineBuiltInName(name: string, fn: () => Result): void;
        defineName(qualifiedName: string, val: Val): void;
        defineFunc(qualifiedName: string, val: Val): void;
        defineBuiltIn(qualifiedName: string, fn: (...p1: Result[]) => Result): void;
    }
    function isAbsoluteLengthUnit(unit: string): boolean;
    function isViewportRelativeLengthUnit(unit: string): boolean;
    function isFontRelativeLengthUnit(unit: string): boolean;
    const defaultUnitSizes: {
        [key: string]: number;
    };
    function needUnitConversion(unit: string): boolean;
    type ScopeContext = {
        [key: string]: Result;
    };
    class Context {
        readonly rootScope: LexicalScope;
        readonly viewportWidth: number;
        readonly viewportHeight: number;
        protected actualPageWidth: number | null;
        pageWidth: () => number;
        protected actualPageHeight: number | null;
        pageHeight: () => number;
        initialFontSize: number;
        rootFontSize: number | null;
        fontSize: () => number;
        pref: Preferences;
        scopes: {
            [key: string]: ScopeContext;
        };
        pageAreaWidth: number | null;
        pageAreaHeight: number | null;
        pageVertical: boolean | null;
        pubTitle: string | null;
        docTitle: string | null;
        constructor(rootScope: LexicalScope, viewportWidth: number, viewportHeight: number, fontSize: number);
        private getScopeContext;
        clearScope(scope: LexicalScope): void;
        queryUnitSize(unit: string, isRoot: boolean): number;
        evalName(scope: LexicalScope, qualifiedName: string): Val;
        evalCall(scope: LexicalScope, qualifiedName: string, params: Val[], noBuiltInEval: boolean): Val;
        evalMediaName(name: string, not: boolean): boolean;
        evalMediaTest(feature: string, value: Val): boolean;
        queryVal(scope: LexicalScope, key: string): Result | undefined;
        storeVal(scope: LexicalScope, key: string, val: Result): void;
    }
    type DependencyCache = {
        [key: string]: boolean | Special;
    };
    class Val {
        scope: LexicalScope;
        key: string;
        constructor(scope: LexicalScope);
        toString(): string;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        expand(context: Context, params: Val[]): Val;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        dependOuter(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        depend(other: Val, context: Context): boolean;
        evaluate(context: Context): Result;
        isMediaName(): boolean;
    }
    class Prefix extends Val {
        val: Val;
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Infix extends Val {
        lhs: Val;
        rhs: Val;
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Logical extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Comparison extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Additive extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Multiplicative extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Not extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class Negate extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class And extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class AndMedia extends And {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Or extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class OrMedia extends Or {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Lt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Le extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Gt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ge extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Eq extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ne extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Add extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Subtract extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Multiply extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Divide extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Modulo extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Numeric extends Val {
        num: number;
        unit: string;
        constructor(scope: LexicalScope, num: number, unit: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class Named extends Val {
        qualifiedName: string;
        constructor(scope: LexicalScope, qualifiedName: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    }
    class MediaName extends Val {
        not: boolean;
        name: string;
        value: Val;
        constructor(scope: LexicalScope, not: boolean, name: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        isMediaName(): boolean;
    }
    class Native extends Val {
        fn: () => Result;
        str: string;
        constructor(scope: LexicalScope, fn: () => Result, str: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    function appendValArray(buf: Base.StringBuffer, arr: Val[]): void;
    function expandValArray(context: Context, arr: Val[], params: Val[]): Val[];
    function evalValArray(context: Context, arr: Val[]): Result[];
    class Call extends Val {
        qualifiedName: string;
        params: Val[];
        constructor(scope: LexicalScope, qualifiedName: string, params: Val[]);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Cond extends Val {
        cond: Val;
        ifTrue: Val;
        ifFalse: Val;
        constructor(scope: LexicalScope, cond: Val, ifTrue: Val, ifFalse: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Const extends Val {
        val: Result;
        constructor(scope: LexicalScope, val: Result);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class MediaTest extends Val {
        name: MediaName;
        value: Val;
        constructor(scope: LexicalScope, name: MediaName, value: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Param extends Val {
        index: number;
        constructor(scope: LexicalScope, index: number);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    function and(scope: LexicalScope, v1: Val, v2: Val): Val;
    function add(scope: LexicalScope, v1: Val, v2: Val): Val;
    function sub(scope: LexicalScope, v1: Val, v2: Val): Val;
    function mul(scope: LexicalScope, v1: Val, v2: Val): Val;
    function div(scope: LexicalScope, v1: Val, v2: Val): Val;
}
declare namespace Font {
    const traitProps: {
        [key: string]: Css.Val;
    };
    const bogusFontData: string;
    let bogusFontCounter: number;
    function makeFontTraitKey(properties: {
        [key: string]: Css.Val;
    }): string;
    function fillDefaults(properties: {
        [key: string]: Css.Val;
    }): void;
    function prepareProperties(properties: CssCascade_$0.ElementStyle, context: Exprs.Context): {
        [key: string]: Css.Val;
    };
    class Face {
        readonly properties: {
            [key: string]: Css.Val;
        };
        fontTraitKey: string;
        src: string | null;
        blobURLs: string[];
        blobs: Blob[];
        family: string | null;
        constructor(properties: {
            [key: string]: Css.Val;
        });
        traitsEqual(other: Face): boolean;
        makeAtRule(src: string, fontBytes: Blob): string;
    }
    class DocumentFaces {
        readonly deobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null;
        familyMap: {
            [key: string]: string;
        };
        constructor(deobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null);
        registerFamily(srcFace: Face, viewFace: Face): void;
        filterFontFamily(val: Css.Val): Css.Val;
    }
    class Mapper {
        readonly head: Element;
        readonly body: Element;
        srcURLMap: {
            [key: string]: TaskUtil.Fetcher<Face>;
        };
        familyPrefix: string;
        familyCounter: number;
        constructor(head: Element, body: Element, opt_familyPrefix?: string);
        getViewFontFamily(srcFace: Face, documentFaces: DocumentFaces): string;
        private initFont;
        loadFont(srcFace: Face, documentFaces: DocumentFaces): TaskUtil.Fetcher<Face>;
        findOrLoadFonts(srcFaces: Face[], documentFaces: DocumentFaces): Task.Result<boolean>;
    }
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
declare namespace TaskUtil {
    class Fetcher<T> {
        readonly fetch: () => Task.Result<T>;
        name: string;
        arrived: boolean;
        resource: T;
        task: Task.Task;
        piggybacks: ((p1: any) => void)[] | null;
        constructor(fetch: () => Task.Result<T>, opt_name?: string);
        start(): void;
        piggyback(fn: (p1: T) => void): void;
        get(): Task.Result<T>;
        hasArrived(): boolean;
    }
    const waitForFetchers: <T>(fetchers: Fetcher<T>[]) => Task.Result<boolean>;
    function loadElement(elem: Element, src: string): Fetcher<string>;
}
declare namespace Vtree_$0 {
    const delayedProps: {
        transform: boolean;
        "transform-origin": boolean;
    };
    const delayedPropsIfRelativePositioned: {
        top: boolean;
        bottom: boolean;
        left: boolean;
        right: boolean;
    };
    class DelayedItem {
        target: Element;
        name: string;
        value: Css.Val;
        constructor(target: Element, name: string, value: Css.Val);
    }
    type PageHyperlinkEvent = {
        type: string;
        target: any;
        currentTarget: any;
        anchorElement: Element;
        href: string;
    };
    type Trigger = {
        observer: string;
        event: string;
        action: string;
        ref: string;
    };
    const actions: {
        show: (obj: any) => void;
        hide: (obj: any) => void;
        play: (obj: any) => void;
        pause: (obj: any) => void;
        resume: (obj: any) => void;
        mute: (obj: any) => void;
        unmute: (obj: any) => void;
    };
    function makeListener(refs: Element[], action: string): EventListener | null;
    class Page extends Base.SimpleEventTarget {
        readonly container: HTMLElement;
        readonly bleedBox: HTMLElement;
        private static AUTO_PAGE_WIDTH_ATTRIBUTE;
        private static AUTO_PAGE_HEIGHT_ATTRIBUTE;
        pageAreaElement: HTMLElement | null;
        delayedItems: DelayedItem[];
        hrefHandler: (e: Event) => void;
        elementsById: {
            [key: string]: Element[];
        };
        dimensions: {
            width: number;
            height: number;
        };
        isFirstPage: boolean;
        isLastPage: boolean;
        isAutoPageWidth: boolean;
        isAutoPageHeight: boolean;
        spineIndex: number;
        position: LayoutPosition;
        offset: number;
        side: Constants.PageSide | null;
        fetchers: TaskUtil.Fetcher<{}>[];
        marginBoxes: {
            top: {
                [key: string]: Container_$0;
            };
            bottom: {
                [key: string]: Container_$0;
            };
            left: {
                [key: string]: Container_$0;
            };
            right: {
                [key: string]: Container_$0;
            };
        };
        constructor(container: HTMLElement, bleedBox: HTMLElement);
        setAutoPageWidth(isAuto: boolean): void;
        setAutoPageHeight(isAuto: boolean): void;
        registerElementWithId(element: Element, id: string): void;
        finish(triggers: Trigger[], clientLayout: ClientLayout_$0): void;
        zoom(scale: number): void;
        getPageAreaElement(): HTMLElement;
    }
    type Spread = {
        left: Page;
        right: Page;
    };
    const SPECIAL_ATTR = "data-adapt-spec";
    const Whitespace_$0: typeof Vtree.Whitespace_$0;
    type Whitespace_$0 = Vtree.Whitespace_$0;
    function whitespaceFromPropertyValue(whitespace: string): Whitespace_$0 | null;
    function canIgnore(node: Node, whitespace: Whitespace_$0): boolean;
    class Flow {
        readonly flowName: string;
        readonly parentFlowName: string | null;
        forcedBreakOffsets: number[];
        formattingContext: FormattingContext_$0 | null;
        constructor(flowName: string, parentFlowName: string | null);
    }
    class FlowChunk {
        flowName: string;
        element: Element;
        startOffset: number;
        priority: number;
        linger: number;
        exclusive: boolean;
        repeated: boolean;
        last: boolean;
        breakBefore: string | null;
        startPage: number;
        constructor(flowName: string, element: Element, startOffset: number, priority: number, linger: number, exclusive: boolean, repeated: boolean, last: boolean, breakBefore: string | null);
        isBetter(other: FlowChunk): boolean;
    }
    type ClientRect_$0 = Vtree.ClientRect_$0;
    function clientrectIncreasingTop(r1: ClientRect_$0, r2: ClientRect_$0): number;
    function clientrectDecreasingRight(r1: ClientRect_$0, r2: ClientRect_$0): number;
    type ClientLayout_$0 = Vtree.ClientLayout_$0;
    type LayoutContext_$0 = Vtree.LayoutContext_$0;
    type FormattingContext_$0 = Vtree.FormattingContext_$0;
    function eachAncestorFormattingContext(nodeContext: NodeContext_$0, callback: (p1: FormattingContext_$0) => any): void;
    type NodePositionStep_$0 = Vtree.NodePositionStep_$0;
    function isSameNodePositionStep(nps1: NodePositionStep_$0, nps2: NodePositionStep_$0): boolean;
    type NodePosition_$0 = Vtree.NodePosition_$0;
    function isSameNodePosition(np1: NodePosition_$0 | null, np2: NodePosition_$0 | null): boolean;
    function newNodePositionFromNode(node: Node): NodePosition_$0;
    function newNodePositionFromNodeContext(nodeContext: Vtree.NodeContext_$0, initialFragmentIndex: number | null): NodePosition_$0;
    function makeNodeContextFromNodePositionStep(step: NodePositionStep_$0, parent: Vtree.NodeContext_$0): NodeContext_$0;
    const ShadowType_$0: typeof Vtree.ShadowType_$0;
    type ShadowType_$0 = Vtree.ShadowType_$0;
    class ShadowContext_$0 implements Vtree.ShadowContext_$0 {
        readonly owner: Element;
        readonly root: Element;
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly parentShadow: ShadowContext_$0;
        readonly type: ShadowType_$0;
        readonly styler: object;
        subShadow: ShadowContext_$0;
        constructor(owner: Element, root: Element, xmldoc: XmlDoc.XMLDocHolder, parentShadow: ShadowContext_$0, superShadow: ShadowContext_$0, type: ShadowType_$0, styler: object);
        equals(other: ShadowContext_$0): boolean;
    }
    function isSameShadowContext(sc1: ShadowContext_$0, sc2: ShadowContext_$0): boolean;
    class FirstPseudo_$0 implements Vtree.FirstPseudo_$0 {
        readonly outer: FirstPseudo_$0;
        readonly count: number;
        constructor(outer: FirstPseudo_$0, count: number);
    }
    class NodeContext_$0 implements Vtree.NodeContext_$0 {
        sourceNode: Node;
        parent: NodeContext_$0;
        boxOffset: number;
        offsetInNode: number;
        after: boolean;
        shadowType: ShadowType_$0;
        shadowContext: ShadowContext_$0;
        nodeShadow: ShadowContext_$0;
        shadowSibling: NodeContext_$0;
        shared: boolean;
        inline: boolean;
        overflow: boolean;
        breakPenalty: number;
        display: string | null;
        floatReference: PageFloats.FloatReference;
        floatSide: string | null;
        clearSide: string | null;
        floatMinWrapBlock: Css.Numeric | null;
        columnSpan: Css.Val | null;
        verticalAlign: string;
        captionSide: string;
        inlineBorderSpacing: number;
        blockBorderSpacing: number;
        flexContainer: boolean;
        whitespace: Whitespace_$0;
        hyphenateCharacter: string | null;
        breakWord: boolean;
        establishesBFC: boolean;
        containingBlockForAbsolute: boolean;
        breakBefore: string | null;
        breakAfter: string | null;
        viewNode: Node;
        clearSpacer: Node;
        inheritedProps: {
            [key: string]: number | string | Css.Val;
        };
        vertical: boolean;
        direction: string;
        firstPseudo: FirstPseudo_$0;
        lang: string | null;
        preprocessedTextContent: Diff.Change[] | null;
        formattingContext: FormattingContext_$0;
        repeatOnBreak: string | null;
        pluginProps: {
            [key: string]: string | number | undefined | null | (number | null)[];
        };
        fragmentIndex: number;
        afterIfContinues: Selectors.AfterIfContinues;
        footnotePolicy: Css.Ident | null;
        constructor(sourceNode: Node, parent: NodeContext_$0, boxOffset: number);
        resetView(): void;
        private cloneItem;
        modify(): NodeContext_$0;
        copy(): NodeContext_$0;
        clone(): NodeContext_$0;
        toNodePositionStep(): NodePositionStep_$0;
        toNodePosition(): NodePosition_$0;
        isInsideBFC(): boolean;
        getContainingBlockForAbsolute(): NodeContext_$0;
        walkUpBlocks(callback: (p1: NodeContext_$0) => any): void;
        belongsTo(formattingContext: FormattingContext_$0): boolean;
    }
    class ChunkPosition_$0 implements Vtree.ChunkPosition_$0 {
        primary: NodePosition_$0;
        floats: NodePosition_$0[];
        constructor(primary: NodePosition_$0);
        clone(): ChunkPosition_$0;
        isSamePosition(other: ChunkPosition_$0): boolean;
    }
    class FlowChunkPosition {
        chunkPosition: ChunkPosition_$0;
        readonly flowChunk: FlowChunk;
        constructor(chunkPosition: ChunkPosition_$0, flowChunk: FlowChunk);
        clone(): FlowChunkPosition;
        isSamePosition(other: FlowChunkPosition): boolean;
    }
    class FlowPosition {
        positions: FlowChunkPosition[];
        startSide: string;
        breakAfter: string | null;
        clone(): FlowPosition;
        isSamePosition(other: FlowPosition): boolean;
        hasContent(offset: number): boolean;
    }
    class LayoutPosition {
        page: number;
        flows: {
            [key: string]: Flow;
        };
        flowPositions: {
            [key: string]: FlowPosition;
        };
        highestSeenOffset: number;
        highestSeenNode: Node;
        lookupPositionOffset: number;
        clone(): LayoutPosition;
        isSamePosition(other: LayoutPosition): boolean;
        hasContent(name: string, offset: number): boolean;
        startSideOfFlow(name: string): string;
        firstFlowChunkOfFlow(name: string): FlowChunk | null;
    }
    class Container_$0 implements Vtree.Container_$0 {
        element: Element;
        left: number;
        top: number;
        marginLeft: number;
        marginRight: number;
        marginTop: number;
        marginBottom: number;
        borderLeft: number;
        borderRight: number;
        borderTop: number;
        borderBottom: number;
        paddingLeft: number;
        paddingRight: number;
        paddingTop: number;
        paddingBottom: number;
        width: number;
        height: number;
        originX: number;
        originY: number;
        exclusions: GeometryUtil.Shape[];
        innerShape: GeometryUtil.Shape;
        computedBlockSize: number;
        snapWidth: number;
        snapHeight: number;
        snapOffsetX: number;
        snapOffsetY: number;
        vertical: boolean;
        constructor(element: Element);
        getInsetTop(): number;
        getInsetBottom(): number;
        getInsetLeft(): number;
        getInsetRight(): number;
        getInsetBefore(): number;
        getInsetAfter(): number;
        getInsetStart(): number;
        getInsetEnd(): number;
        getBeforeEdge(box: ClientRect_$0): number;
        getAfterEdge(box: ClientRect_$0): number;
        getStartEdge(box: ClientRect_$0): number;
        getEndEdge(box: ClientRect_$0): number;
        getInlineSize(box: ClientRect_$0): number;
        getBoxSize(box: ClientRect_$0): number;
        getBoxDir(): number;
        getInlineDir(): number;
        copyFrom(other: Container_$0): void;
        setVerticalPosition(top: number, height: number): void;
        setHorizontalPosition(left: number, width: number): void;
        setBlockPosition(start: number, extent: number): void;
        setInlinePosition(start: number, extent: number): void;
        clear(): void;
        getInnerShape(): GeometryUtil.Shape;
        getInnerRect(): GeometryUtil.Rect;
        getPaddingRect(): GeometryUtil.Rect;
        getOuterShape(outerShapeProp: Css.Val, context: Exprs.Context): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
    }
    type ExprContentListener_$0 = Vtree.ExprContentListener_$0;
    class ContentPropertyHandler extends Css.Visitor {
        readonly elem: Element;
        readonly context: Exprs.Context;
        readonly rootContentValue: Css.Val;
        readonly exprContentListener: ExprContentListener_$0;
        constructor(elem: Element, context: Exprs.Context, rootContentValue: Css.Val, exprContentListener: ExprContentListener_$0);
        private visitStrInner;
        visitStr(str: Css.Str): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function nonTrivialContent(val: Css.Val): boolean;
}
declare namespace Net_$0 {
    enum XMLHttpRequestResponseType {
        DEFAULT = "",
        ARRAYBUFFER = "arraybuffer",
        BLOB = "blob",
        DOCUMENT = "document",
        JSON = "json",
        TEXT = "text"
    }
    type Response_$0 = Net.Response_$0;
    function ajax(url: string, opt_type?: XMLHttpRequestResponseType, opt_method?: string, opt_data?: string, opt_contentType?: string): Task.Result<Response_$0>;
    function makeBlob(parts: (string | Blob | ArrayBuffer | ArrayBufferView)[], opt_type?: string): any;
    function readBlob(blob: Blob): any;
    function revokeObjectURL(url: string): void;
    function createObjectURL(blob: Blob): string;
    class ResourceStore_$0<Resource> implements Net.ResourceStore_$0<Resource> {
        readonly parser: (p1: Response_$0, p2: ResourceStore_$0<Resource>) => Task.Result<Resource>;
        readonly type: XMLHttpRequestResponseType;
        resources: {
            [key: string]: Resource;
        };
        fetchers: {
            [key: string]: TaskUtil.Fetcher<Resource>;
        };
        constructor(parser: (p1: Response_$0, p2: ResourceStore_$0<Resource>) => Task.Result<Resource>, type: XMLHttpRequestResponseType);
        load(url: string, opt_required?: boolean, opt_message?: string): Task.Result<Resource>;
        private fetchInner;
        fetch(url: string, opt_required?: boolean, opt_message?: string): TaskUtil.Fetcher<Resource>;
        get(url: string): XmlDoc.XMLDocHolder;
        delete(url: string): void;
    }
    type JSONStore = ResourceStore_$0<Base.JSON>;
    function parseJSONResource(response: Response_$0, store: JSONStore): Task.Result<Base.JSON>;
    function newJSONStore(): JSONStore;
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
declare namespace Base {
    let emptyObj: {};
    type JSON = any;
    function jsonToString(json: JSON): string;
    function stringToJSON(str: string): JSON;
    function stripFragment(url: string): string;
    function stripFragmentAndQuery(url: string): string;
    let baseURL: string;
    function setBaseURL(value: string): void;
    let resourceBaseURL: string;
    function setResourceBaseURL(value: string): void;
    function resolveURL(relURL: string, baseURL: string): string;
    function convertSpecialURL(url: string): string;
    interface DocumentURLTransformer {
        transformFragment(fragment: string, baseURL: string): string;
        transformURL(url: string, baseURL: string): string;
        restoreURL(encoded: string): string[];
    }
    enum NS {
        FB2 = "http://www.gribuser.ru/xml/fictionbook/2.0",
        epub = "http://www.idpf.org/2007/ops",
        EV = "http://www.w3.org/2001/xml-events",
        MATHML = "http://www.w3.org/1998/Math/MathML",
        XML = "http://www.w3.org/XML/1998/namespace",
        XHTML = "http://www.w3.org/1999/xhtml",
        XLINK = "http://www.w3.org/1999/xlink",
        SHADOW = "http://www.pyroxy.com/ns/shadow",
        SVG = "http://www.w3.org/2000/svg",
        DC = "http://purl.org/dc/elements/1.1/",
        NCX = "http://www.daisy.org/z3986/2005/ncx/",
        SSE = "http://example.com/sse"
    }
    function getURLParam(name: string, opt_url?: string): string | null;
    function setURLParam(url: string, name: string, value: string): string;
    function asString(v: any): any;
    interface Comparable {
        compare(other: Comparable): number;
    }
    class PriorityQueue {
        queue: Comparable[];
        length(): number;
        add(item: Comparable): void;
        peek(): Comparable;
        remove(): Comparable;
    }
    function cssToJSProp(prefix: string, cssPropName: string): string;
    const knownPrefixes: string[];
    const propNameMap: {};
    function checkIfPropertySupported(prefix: string, prop: string): boolean;
    function getPrefixedPropertyNames(prop: string): string[] | null;
    function setCSSProperty(elem: Element, prop: string, value: string): void;
    function getCSSProperty(elem: Element, prop: string, opt_value?: string): string;
    function getLangAttribute(element: Element): string;
    class StringBuffer {
        list: string[];
        append(str: string): StringBuffer;
        clear(): void;
        toString(): string;
    }
    function escapeChar(str: string): string;
    function escapeCSSIdent(name: string): string;
    function escapeCSSStr(str: string): string;
    function lightURLEncode(str: string): string;
    function isLetter(ch: string): boolean;
    function escapeCharToHex(str: string, prefix?: string): string;
    function escapeNameStrToHex(str: string, prefix?: string): string;
    function escapeRegExp(str: string): string;
    function unescapeCharFromHex(str: string, prefix?: string): string;
    function unescapeStrFromHex(str: string, prefix?: string): string;
    function binarySearch(high: number, good: (p1: number) => boolean): number;
    function numberCompare(a: number, b: number): number;
    const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    function appendBase64(sb: StringBuffer, data: string): void;
    function indexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T;
    };
    function arrayToSet(arr: string[]): {
        [key: string]: boolean;
    };
    function multiIndexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T[];
    };
    function mapObj<P, R>(obj: {
        [key: string]: P;
    }, fn: (p1: P, p2: string) => R): {
        [key: string]: R;
    };
    function mapSize(obj: object): number;
    type Event = {
        type: string;
        target?: any;
        currentTarget?: any;
        preventDefault?: any;
        newPage?: any;
        anchorElement?: any;
        href?: any;
        content?: any;
    };
    type EventListener = (p1: Event) => void;
    class SimpleEventTarget {
        listeners: {
            [key: string]: EventListener[];
        };
        dispatchEvent(evt: Event): void;
        addEventListener(type: string, listener: EventListener, capture?: boolean): void;
        removeEventListener(type: string, listener: EventListener, capture?: boolean): void;
    }
    type EventTarget = SimpleEventTarget;
    let hasLShapeFloatBug: boolean | null;
    function checkLShapeFloatBug(body: HTMLElement): boolean;
    let hasVerticalBBoxBug: boolean | null;
    function checkVerticalBBoxBug(body: HTMLElement): boolean;
    let hasInlineBlockJustificationBug: boolean | null;
    function checkInlineBlockJustificationBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityAfterHyphenBug: boolean | null;
    function checkSoftWrapOpportunityAfterHyphenBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityByWbrBug: boolean | null;
    function checkSoftWrapOpportunityByWbrBug(body: HTMLElement): boolean;
}
declare namespace Constants {
    let isDebug: boolean;
    function setDebug(value: boolean): void;
    enum PageProgression {
        LTR = "ltr",
        RTL = "rtl"
    }
    function pageProgressionOf(str: string): PageProgression;
    enum PageSide {
        LEFT = "left",
        RIGHT = "right"
    }
    enum ReadyState {
        LOADING = "loading",
        INTERACTIVE = "interactive",
        COMPLETE = "complete"
    }
    const constants: {
        PageProgression: typeof PageProgression;
        PageSide: typeof PageSide;
        ReadyState: typeof ReadyState;
    };
}
declare namespace Counters {
    class TargetCounterReference {
        readonly targetId: string;
        resolved: boolean;
        pageCounters: CssCascade_$0.CounterValues;
        spineIndex: number;
        pageIndex: number;
        constructor(targetId: string, resolved: boolean);
        equals(other: TargetCounterReference): boolean;
        isResolved(): boolean;
        resolve(): void;
        unresolve(): void;
    }
    class CounterStore {
        readonly documentURLTransformer: Base.DocumentURLTransformer;
        countersById: {
            [key: string]: CssCascade_$0.CounterValues;
        };
        pageCountersById: {
            [key: string]: CssCascade_$0.CounterValues;
        };
        currentPageCounters: CssCascade_$0.CounterValues;
        previousPageCounters: CssCascade_$0.CounterValues;
        currentPageCountersStack: CssCascade_$0.CounterValues[];
        pageIndicesById: {
            [key: string]: {
                spineIndex: number;
                pageIndex: number;
            };
        };
        currentPage: Vtree_$0.Page;
        newReferencesOfCurrentPage: TargetCounterReference[];
        referencesToSolve: TargetCounterReference[];
        referencesToSolveStack: TargetCounterReference[][];
        unresolvedReferences: {
            [key: string]: TargetCounterReference[];
        };
        resolvedReferences: {
            [key: string]: TargetCounterReference[];
        };
        private pagesCounterExprs;
        constructor(documentURLTransformer: Base.DocumentURLTransformer);
        createCounterListener(baseURL: string): CssCascade_$0.CounterListener;
        createCounterResolver(baseURL: string, rootScope: Exprs.LexicalScope, pageScope: Exprs.LexicalScope): CssCascade_$0.CounterResolver;
        setCurrentPage(page: Vtree_$0.Page): void;
        private definePageCounter;
        forceSetPageCounter(pageNumber: number): void;
        updatePageCounters(cascadedPageStyle: CssCascade_$0.ElementStyle, context: Exprs.Context): void;
        pushPageCounters(counters: CssCascade_$0.CounterValues): void;
        popPageCounters(): void;
        resolveReference(id: string): void;
        saveReferenceOfCurrentPage(id: string, resolved: boolean): void;
        finishPage(spineIndex: number, pageIndex: number): void;
        getUnresolvedRefsToPage(page: Vtree_$0.Page): {
            spineIndex: number;
            pageIndex: number;
            pageCounters: CssCascade_$0.CounterValues;
            refs: TargetCounterReference[];
        }[];
        pushReferencesToSolve(refs: TargetCounterReference[]): void;
        popReferencesToSolve(): void;
        registerPageCounterExpr(name: string, format: (p1: number[]) => string, expr: Exprs.Val): void;
        getExprContentListener(): Vtree_$0.ExprContentListener;
        private exprContentListener;
        finishLastPage(viewport: Vgen.Viewport): void;
        createLayoutConstraint(pageIndex: number): Layout.LayoutConstraint;
    }
    const PAGES_COUNTER_ATTR = "data-vivliostyle-pages-counter";
}
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace CssCascade {
    interface ElementStyle_$0 extends CssCascade.ElementStyle_$0 {
    }
    const inheritedProps: {
        azimuth: boolean;
        "border-collapse": boolean;
        "border-spacing": boolean;
        "caption-side": boolean;
        "clip-rule": boolean;
        color: boolean;
        "color-interpolation": boolean;
        "color-rendering": boolean;
        cursor: boolean;
        direction: boolean;
        elevation: boolean;
        "empty-cells": boolean;
        fill: boolean;
        "fill-opacity": boolean;
        "fill-rule": boolean;
        "font-kerning": boolean;
        "font-size": boolean;
        "font-size-adjust": boolean;
        "font-family": boolean;
        "font-feature-settings": boolean;
        "font-style": boolean;
        "font-stretch": boolean;
        "font-variant": boolean;
        "font-weight": boolean;
        "glyph-orientation-vertical": boolean;
        hyphens: boolean;
        "hyphenate-character": boolean;
        "hyphenate-limit-chars": boolean;
        "hyphenate-limit-last": boolean;
        "image-rendering": boolean;
        "image-resolution": boolean;
        "letter-spacing": boolean;
        "line-break": boolean;
        "line-height": boolean;
        "list-style-image": boolean;
        "list-style-position": boolean;
        "list-style-type": boolean;
        marker: boolean;
        "marker-end": boolean;
        "marker-mid": boolean;
        "marker-start": boolean;
        orphans: boolean;
        "overflow-wrap": boolean;
        "paint-order": boolean;
        "pointer-events": boolean;
        "pitch-range": boolean;
        quotes: boolean;
        richness: boolean;
        "ruby-align": boolean;
        "ruby-position": boolean;
        "speak-header": boolean;
        "speak-numeral": boolean;
        "speak-punctuation": boolean;
        "speech-rate": boolean;
        "shape-rendering": boolean;
        stress: boolean;
        stroke: boolean;
        "stroke-dasharray": boolean;
        "stroke-dashoffset": boolean;
        "stroke-linecap": boolean;
        "stroke-linejoin": boolean;
        "stroke-miterlimit": boolean;
        "stroke-opacity": boolean;
        "stroke-width": boolean;
        "tab-size": boolean;
        "text-align": boolean;
        "text-align-last": boolean;
        "text-anchor": boolean;
        "text-decoration-skip": boolean;
        "text-emphasis-color": boolean;
        "text-emphasis-position": boolean;
        "text-emphasis-style": boolean;
        "text-combine-upright": boolean;
        "text-indent": boolean;
        "text-justify": boolean;
        "text-rendering": boolean;
        "text-size-adjust": boolean;
        "text-transform": boolean;
        "text-underline-position": boolean;
        visibility: boolean;
        "voice-family": boolean;
        volume: boolean;
        "white-space": boolean;
        widows: boolean;
        "word-break": boolean;
        "word-spacing": boolean;
        "word-wrap": boolean;
        "writing-mode": boolean;
    };
    const polyfilledInheritedProps: string[];
    function getPolyfilledInheritedProps(): string[];
    const supportedNamespaces: {
        "http://www.idpf.org/2007/ops": boolean;
        "http://www.w3.org/1999/xhtml": boolean;
        "http://www.w3.org/2000/svg": boolean;
    };
    const coupledPatterns: string[];
    const coupledExtentPatterns: string[];
    const geomNames: {
        [key: string]: boolean;
    };
    function buildCouplingMap(sideMap: {
        [key: string]: string;
    }, extentMap: {
        [key: string]: string;
    }): {
        [key: string]: string;
    };
    const couplingMapVert: {
        [key: string]: string;
    };
    const couplingMapHor: {
        [key: string]: string;
    };
    const couplingMapVertRtl: {
        [key: string]: string;
    };
    const couplingMapHorRtl: {
        [key: string]: string;
    };
    class CascadeValue {
        readonly value: Css.Val;
        readonly priority: number;
        constructor(value: Css.Val, priority: number);
        getBaseValue(): CascadeValue;
        filterValue(visitor: Css.Visitor): CascadeValue;
        increaseSpecificity(specificity: number): CascadeValue;
        evaluate(context: Exprs.Context, propName: string): Css.Val;
        isEnabled(context: Exprs.Context): boolean;
    }
    class ConditionalCascadeValue extends CascadeValue {
        readonly condition: Exprs.Val;
        constructor(value: Css.Val, priority: number, condition: Exprs.Val);
        getBaseValue(): CascadeValue;
        filterValue(visitor: Css.Visitor): CascadeValue;
        increaseSpecificity(specificity: number): CascadeValue;
        isEnabled(context: Exprs.Context): boolean;
    }
    function cascadeValues(context: Exprs.Context, tv: CascadeValue, av: CascadeValue): CascadeValue;
    type ElementStyleMap = {
        [key: string]: ElementStyle_$0;
    };
    const SPECIALS: {
        "region-id": boolean;
        "fragment-selector-id": boolean;
    };
    function isSpecialName(name: string): boolean;
    function isMapName(name: string): boolean;
    function isPropName(name: string): boolean;
    function isInherited(name: string): boolean;
    function getProp(style: ElementStyle_$0, name: string): CascadeValue;
    function setProp(style: ElementStyle_$0, name: string, value: CascadeValue): any;
    function getStyleMap(style: ElementStyle_$0, name: string): ElementStyleMap;
    function getMutableStyleMap(style: ElementStyle_$0, name: string): ElementStyleMap;
    const getViewConditionalStyleMap: (style: ElementStyle_$0) => {
        matcher: Matchers.Matcher;
        styles: ElementStyleMap;
    }[];
    function getSpecial(style: ElementStyle_$0, name: string): CascadeValue[];
    function getMutableSpecial(style: ElementStyle_$0, name: string): CascadeValue[];
    function mergeIn(context: Exprs.Context, target: ElementStyle_$0, style: ElementStyle_$0, specificity: number, pseudoelement: string | null, regionId: string | null, viewConditionMatcher: Matchers.Matcher | null): void;
    function mergeAll(context: Exprs.Context, styles: ElementStyle_$0[]): ElementStyle_$0;
    function chainActions(chain: ChainedAction[], action: CascadeAction): CascadeAction;
    class InheritanceVisitor extends Css.FilterVisitor {
        readonly props: ElementStyle_$0;
        readonly context: Exprs.Context;
        propName: string;
        constructor(props: ElementStyle_$0, context: Exprs.Context);
        setPropName(name: string): void;
        private getFontSize;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function convertFontRelativeLengthToPx(numeric: Css.Numeric, baseFontSize: number, context: Exprs.Context): Css.Numeric;
    function convertFontSizeToPx(numeric: Css.Numeric, parentFontSize: number, context: Exprs.Context): Css.Numeric;
    type ActionTable = {
        [key: string]: CascadeAction;
    };
    class CascadeAction {
        apply(cascadeInstance: CascadeInstance): void;
        mergeWith(other: CascadeAction): CascadeAction;
        clone(): CascadeAction;
    }
    class ConditionItemAction extends CascadeAction {
        readonly conditionItem: ConditionItem;
        constructor(conditionItem: ConditionItem);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CompoundAction extends CascadeAction {
        readonly list: CascadeAction[];
        constructor(list: CascadeAction[]);
        apply(cascadeInstance: CascadeInstance): void;
        mergeWith(other: CascadeAction): CascadeAction;
        clone(): CascadeAction;
    }
    class ApplyRuleAction extends CascadeAction {
        readonly style: ElementStyle_$0;
        readonly specificity: number;
        readonly pseudoelement: string | null;
        readonly regionId: string | null;
        readonly viewConditionId: string | null;
        constructor(style: ElementStyle_$0, specificity: number, pseudoelement: string | null, regionId: string | null, viewConditionId: string | null);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class ChainedAction extends CascadeAction {
        chained: CascadeAction;
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckClassAction extends ChainedAction {
        readonly className: string;
        constructor(className: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckIdAction extends ChainedAction {
        readonly id: string;
        constructor(id: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckLocalNameAction extends ChainedAction {
        readonly localName: string;
        constructor(localName: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckNSTagAction extends ChainedAction {
        readonly ns: string;
        readonly localName: string;
        constructor(ns: string, localName: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckTargetEpubTypeAction extends ChainedAction {
        readonly epubTypePatt: RegExp;
        constructor(epubTypePatt: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckNamespaceAction extends ChainedAction {
        readonly ns: string;
        constructor(ns: string);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckAttributePresentAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        constructor(ns: string, name: string);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckAttributeEqAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        readonly value: string;
        constructor(ns: string, name: string, value: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckNamespaceSupportedAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        constructor(ns: string, name: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: Cascade): boolean;
    }
    class CheckAttributeRegExpAction extends ChainedAction {
        readonly ns: string;
        readonly name: string;
        readonly regexp: RegExp;
        constructor(ns: string, name: string, regexp: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class CheckLangAction extends ChainedAction {
        readonly langRegExp: RegExp;
        constructor(langRegExp: RegExp);
        apply(cascadeInstance: CascadeInstance): void;
    }
    class IsFirstAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsRootAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthAction extends ChainedAction {
        readonly a: number;
        readonly b: number;
        constructor(a: number, b: number);
        matchANPlusB(order: number): boolean;
    }
    class IsNthSiblingAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthSiblingOfTypeAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthLastSiblingAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsNthLastSiblingOfTypeAction extends IsNthAction {
        constructor(a: number, b: number);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsEmptyAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsEnabledAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsDisabledAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class IsCheckedAction extends ChainedAction {
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class CheckConditionAction extends ChainedAction {
        readonly condition: string;
        constructor(condition: string);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    class CheckAppliedAction extends CascadeAction {
        applied: boolean;
        constructor();
        apply(cascadeInstance: CascadeInstance): void;
        clone(): CascadeAction;
    }
    class NegateActionsSet extends ChainedAction {
        checkAppliedAction: CheckAppliedAction;
        firstAction: CascadeAction;
        constructor(list: ChainedAction[]);
        apply(cascadeInstance: CascadeInstance): void;
        getPriority(): number;
    }
    interface ConditionItem {
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AbstractConditionItem {
        readonly condition: string;
        readonly viewConditionId: string | null;
        readonly viewCondition: Matchers.Matcher;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        increment(cascadeInstance: CascadeInstance): void;
        decrement(cascadeInstance: CascadeInstance): void;
        buildViewConditionMatcher(cascadeInstance: CascadeInstance): Matchers.Matcher;
    }
    class DescendantConditionItem extends AbstractConditionItem implements ConditionItem {
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class ChildConditionItem extends AbstractConditionItem implements ConditionItem {
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AdjacentSiblingConditionItem extends AbstractConditionItem implements ConditionItem {
        fired: boolean;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class FollowingSiblingConditionItem extends AbstractConditionItem implements ConditionItem {
        fired: boolean;
        constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class AfterPseudoelementItem implements ConditionItem {
        readonly afterprop: ElementStyle_$0;
        readonly element: Element;
        constructor(afterprop: ElementStyle_$0, element: Element);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class RestoreLangItem implements ConditionItem {
        readonly lang: string;
        constructor(lang: string);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    class QuotesScopeItem implements ConditionItem {
        readonly oldQuotes: Css.Str[];
        constructor(oldQuotes: Css.Str[]);
        fresh(cascadeInstance: CascadeInstance): ConditionItem;
        push(cascadeInstance: CascadeInstance, depth: number): boolean;
        pop(cascadeInstance: CascadeInstance, depth: number): boolean;
    }
    type CounterValues = {
        [key: string]: number[];
    };
    interface CounterListener {
        countersOfId(id: string, counters: CounterValues): any;
        getExprContentListener(): Vtree_$0.ExprContentListener;
    }
    interface CounterResolver {
        getPageCounterVal(name: string, format: (p1: number | null) => string): Exprs.Val;
        getPageCountersVal(name: string, format: (p1: number[]) => string): Exprs.Val;
        getTargetCounterVal(url: string, name: string, format: (p1: number | null) => string): Exprs.Val;
        getTargetCountersVal(url: string, name: string, format: (p1: number[]) => string): Exprs.Val;
        setStyler(styler: any): any;
    }
    class AttrValueFilterVisitor extends Css.FilterVisitor {
        element: Element;
        constructor(element: Element);
        private createValueFromString;
        visitFunc(func: Css.Func): Css.Val;
    }
    class ContentPropVisitor extends Css.FilterVisitor {
        cascade: CascadeInstance;
        element: Element;
        readonly counterResolver: CounterResolver;
        constructor(cascade: CascadeInstance, element: Element, counterResolver: CounterResolver);
        visitIdent(ident: Css.Ident): Css.Val;
        private format;
        visitFuncCounter(values: Css.Val[]): Css.Val;
        visitFuncCounters(values: Css.Val[]): Css.Val;
        visitFuncTargetCounter(values: Css.Val[]): Css.Val;
        visitFuncTargetCounters(values: Css.Val[]): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
    }
    function roman(num: number): string;
    const additiveNumbering: {
        roman: (string | number)[];
        armenian: (string | number)[];
        georgian: (string | number)[];
        hebrew: (string | number)[];
    };
    const alphabeticNumbering: {
        latin: string;
        alpha: string;
        greek: string;
        russian: string;
    };
    const fixed: {
        square: string;
        disc: string;
        circle: string;
        none: string;
    };
    function additiveFormat(entries: any[], num: number): string;
    function expandAlphabet(str: string): string[] | null;
    function alphabeticFormat(alphabetStr: string, num: number): string;
    type ChineseNumbering = {
        digits: string;
        markers: string;
        negative: string;
        formal: boolean;
    };
    const chineseTradInformal: ChineseNumbering;
    function chineseCounter(num: number, numbering: ChineseNumbering): string;
    const ORDER_INCREMENT: number;
    function copyTable(src: ActionTable, dst: ActionTable): void;
    class Cascade {
        nsCount: number;
        nsPrefix: {
            [key: string]: string;
        };
        tags: ActionTable;
        nstags: ActionTable;
        epubtypes: ActionTable;
        classes: ActionTable;
        ids: ActionTable;
        pagetypes: ActionTable;
        order: number;
        clone(): Cascade;
        insertInTable(table: ActionTable, key: string, action: CascadeAction): void;
        createInstance(context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: any): CascadeInstance;
        nextOrder(): number;
    }
    class CascadeInstance {
        readonly context: Exprs.Context;
        readonly counterListener: CounterListener;
        readonly counterResolver: CounterResolver;
        code: Cascade;
        stack: ConditionItem[][];
        conditions: {
            [key: string]: number;
        };
        currentElement: Element | null;
        currentElementOffset: number | null;
        currentStyle: ElementStyle_$0 | null;
        currentClassNames: string[] | null;
        currentLocalName: string;
        currentNamespace: string;
        currentId: string;
        currentXmlId: string;
        currentNSTag: string;
        currentEpubTypes: string[] | null;
        currentPageType: string | null;
        isFirst: boolean;
        isRoot: boolean;
        counters: {
            [key: string]: number[];
        };
        counterScoping: {
            [key: string]: boolean;
        }[];
        quotes: Css.Str[];
        quoteDepth: number;
        lang: string;
        siblingOrderStack: number[];
        currentSiblingOrder: number;
        siblingTypeCountsStack: {
            [key: string]: {
                [key: string]: number;
            };
        }[];
        currentSiblingTypeCounts: {
            [key: string]: {
                [key: string]: number;
            };
        };
        currentFollowingSiblingOrder: number | null;
        followingSiblingOrderStack: (number | null)[];
        followingSiblingTypeCountsStack: {
            [key: string]: {
                [key: string]: number;
            };
        }[];
        currentFollowingSiblingTypeCounts: {
            [key: string]: {
                [key: string]: number;
            };
        };
        viewConditions: {
            [key: string]: Matchers.Matcher[];
        };
        dependentConditions: string[];
        elementStack: Element[];
        currentDoc?: Document | null;
        constructor(cascade: Cascade, context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: string);
        pushConditionItem(item: ConditionItem): void;
        increment(condition: string, viewCondition: Matchers.Matcher): void;
        decrement(condition: string, viewCondition: Matchers.Matcher): void;
        buildViewConditionMatcher(viewConditionId: string | null): Matchers.Matcher;
        applyAction(table: ActionTable, key: string): void;
        pushRule(classes: string[], pageType: string | null, baseStyle: ElementStyle_$0): void;
        defineCounter(counterName: string, value: number): void;
        pushCounters(props: ElementStyle_$0): void;
        popCounters(): void;
        processPseudoelementProps(pseudoprops: ElementStyle_$0, element: Element): void;
        pushElement(element: Element, baseStyle: ElementStyle_$0, elementOffset: number): void;
        private applyAttrFilterInner;
        private applyAttrFilter;
        private applyActions;
        private pop;
        popRule(): void;
        popElement(element: Element): void;
    }
    const EMPTY: any[];
    const pseudoNames: string[];
    enum ParseState {
        TOP = 0,
        SELECTOR = 1,
        RULE = 2
    }
    let uaBaseCascade: Cascade;
    function setUABaseCascade(value: Cascade): void;
    class CascadeParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
        readonly condition: Exprs.Val;
        readonly regionId: string | null;
        readonly validatorSet: CssValidator.ValidatorSet;
        chain: ChainedAction[];
        specificity: number;
        elementStyle: ElementStyle_$0;
        conditionCount: number;
        pseudoelement: string | null;
        footnoteContent: boolean;
        cascade: Cascade;
        state: ParseState;
        viewConditionId: string | null;
        insideSelectorRule: ParseState;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, condition: Exprs.Val, parent: CascadeParserHandler, regionId: string | null, validatorSet: CssValidator.ValidatorSet, topLevel: boolean);
        insertNonPrimary(action: CascadeAction): void;
        processChain(action: CascadeAction): void;
        isInsideSelectorRule(mnemonics: string): boolean;
        tagSelector(ns: string | null, name: string | null): void;
        classSelector(name: string): void;
        pseudoclassSelector(name: string, params: (number | string)[]): void;
        pseudoelementSelector(name: string, params: (number | string)[]): void;
        idSelector(id: string): void;
        attributeSelector(ns: string, name: string, op: CssTokenizer.TokenType, value: string | null): void;
        descendantSelector(): void;
        childSelector(): void;
        adjacentSiblingSelector(): void;
        followingSiblingSelector(): void;
        nextSelector(): void;
        startSelectorRule(): void;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        startStylesheet(flavor: CssParser.StylesheetFlavor): void;
        startRuleBody(): void;
        endRule(): void;
        finishChain(): void;
        makeApplyRuleAction(specificity: number): ApplyRuleAction;
        special(name: string, value: Css.Val): void;
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
        finish(): Cascade;
        startFuncWithSelector(funcName: string): void;
    }
    const nthSelectorActionClasses: {
        [key: string]: typeof IsNthAction;
    };
    let conditionCount: number;
    class NotParameterParserHandler extends CascadeParserHandler {
        readonly parent: CascadeParserHandler;
        parentChain: ChainedAction[];
        constructor(parent: CascadeParserHandler);
        startFuncWithSelector(funcName: string): void;
        startRuleBody(): void;
        nextSelector(): void;
        endFuncWithSelector(): void;
        error(mnemonics: string, token: CssTokenizer.Token): void;
    }
    class DefineParserHandler extends CssParser.SlaveParserHandler {
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler);
        property(name: string, value: Css.Val, important: boolean): void;
    }
    class PropSetParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
        readonly condition: Exprs.Val;
        readonly elementStyle: ElementStyle_$0;
        readonly validatorSet: CssValidator.ValidatorSet;
        order: number;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, condition: Exprs.Val, elementStyle: ElementStyle_$0, validatorSet: CssValidator.ValidatorSet);
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    class PropertyParserHandler extends CssParser.ErrorHandler implements CssValidator.PropertyReceiver {
        readonly validatorSet: CssValidator.ValidatorSet;
        elementStyle: ElementStyle_$0;
        order: number;
        constructor(scope: Exprs.LexicalScope, validatorSet: CssValidator.ValidatorSet);
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    function forEachViewConditionalStyles(style: ElementStyle_$0, callback: (p1: ElementStyle_$0) => any): void;
    function mergeViewConditionalStyles(cascMap: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, style: ElementStyle_$0): void;
    function parseStyleAttribute_$0(scope: Exprs.LexicalScope, validatorSet: CssValidator.ValidatorSet, baseURL: string, styleAttrValue: string): ElementStyle_$0;
    function isVertical(cascaded: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, vertical: boolean): boolean;
    function isRtl(cascaded: {
        [key: string]: CascadeValue;
    }, context: Exprs.Context, rtl: boolean): boolean;
    function flattenCascadedStyle(style: ElementStyle_$0, context: Exprs.Context, regionIds: string[], isFootnote: boolean, nodeContext: Vtree_$0.NodeContext): {
        [key: string]: CascadeValue;
    };
    function forEachStylesInRegion(style: ElementStyle_$0, regionIds: string[], isFootnote: boolean, callback: (p1: string, p2: ElementStyle_$0) => any): void;
    function mergeStyle(to: {
        [key: string]: CascadeValue;
    }, from: ElementStyle_$0, context: Exprs.Context): void;
    const convertToPhysical: <T>(src: {
        [key: string]: CascadeValue;
    }, dest: {
        [key: string]: T;
    }, vertical: boolean, rtl: boolean, transform: (p1: string, p2: CascadeValue) => T) => void;
}
declare namespace CssParser {
    const SPECIFICITY_USER_AGENT: number;
    const SPECIFICITY_USER: number;
    const SPECIFICITY_AUTHOR: number;
    const SPECIFICITY_STYLE: number;
    const SPECIFICITY_STYLE_IMPORTANT: number;
    const SPECIFICITY_AUTHOR_IMPORTANT: number;
    const SPECIFICITY_USER_IMPORTANT: number;
    enum StylesheetFlavor {
        USER_AGENT = "UA",
        USER = "User",
        AUTHOR = "Author"
    }
    function colorFromHash(text: string): Css.Color;
    class ParserHandler implements CssTokenizer.TokenizerHandler {
        scope: Exprs.LexicalScope;
        flavor: StylesheetFlavor;
        constructor(scope: Exprs.LexicalScope);
        getCurrentToken(): CssTokenizer.Token;
        getScope(): Exprs.LexicalScope;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        startStylesheet(flavor: StylesheetFlavor): void;
        tagSelector(ns: string | null, name: string | null): void;
        classSelector(name: string): void;
        pseudoclassSelector(name: string, params: (number | string)[]): void;
        pseudoelementSelector(name: string, params: (number | string)[]): void;
        idSelector(id: string): void;
        attributeSelector(ns: string, name: string, op: CssTokenizer.TokenType, value: string | null): void;
        descendantSelector(): void;
        childSelector(): void;
        adjacentSiblingSelector(): void;
        followingSiblingSelector(): void;
        nextSelector(): void;
        startSelectorRule(): void;
        startFontFaceRule(): void;
        startFootnoteRule(pseudoelem: string | null): void;
        startViewportRule(): void;
        startDefineRule(): void;
        startRegionRule(): void;
        startPageRule(): void;
        startPageMarginBoxRule(name: string): void;
        startWhenRule(expr: Css.Expr): void;
        startMediaRule(expr: Css.Expr): void;
        startFlowRule(flowName: string): void;
        startPageTemplateRule(): void;
        startPageMasterRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionGroupRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startRuleBody(): void;
        property(name: string, value: Css.Val, important: boolean): void;
        endRule(): void;
        startFuncWithSelector(funcName: string): void;
        endFuncWithSelector(): void;
        getImportantSpecificity(): number;
        getBaseSpecificity(): number;
    }
    class DispatchParserHandler extends ParserHandler {
        stack: ParserHandler[];
        tokenizer: CssTokenizer.Tokenizer;
        slave: ParserHandler;
        constructor();
        pushHandler(slave: ParserHandler): void;
        popHandler(): void;
        getCurrentToken(): CssTokenizer.Token;
        getScope(): Exprs.LexicalScope;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        errorMsg(mnemonics: string, token: CssTokenizer.Token): void;
        startStylesheet(flavor: StylesheetFlavor): void;
        tagSelector(ns: string | null, name: string | null): void;
        classSelector(name: string): void;
        pseudoclassSelector(name: string, params: (number | string)[]): void;
        pseudoelementSelector(name: string, params: (number | string)[]): void;
        idSelector(id: string): void;
        attributeSelector(ns: string, name: string, op: CssTokenizer.TokenType, value: string | null): void;
        descendantSelector(): void;
        childSelector(): void;
        adjacentSiblingSelector(): void;
        followingSiblingSelector(): void;
        nextSelector(): void;
        startSelectorRule(): void;
        startFontFaceRule(): void;
        startFootnoteRule(pseudoelem: string | null): void;
        startViewportRule(): void;
        startDefineRule(): void;
        startRegionRule(): void;
        startPageRule(): void;
        startPageMarginBoxRule(name: string): void;
        startWhenRule(expr: Css.Expr): void;
        startFlowRule(flowName: string): void;
        startPageTemplateRule(): void;
        startPageMasterRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionGroupRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startRuleBody(): void;
        property(name: string, value: Css.Val, important: boolean): void;
        endRule(): void;
        startFuncWithSelector(funcName: string): void;
        endFuncWithSelector(): void;
    }
    class SkippingParserHandler extends ParserHandler {
        owner: DispatchParserHandler;
        readonly topLevel: any;
        depth: number;
        flavor: StylesheetFlavor;
        constructor(scope: Exprs.LexicalScope, owner: DispatchParserHandler, topLevel: any);
        getCurrentToken(): CssTokenizer.Token;
        error(mnemonics: string, token: CssTokenizer.Token): void;
        startRuleBody(): void;
        endRule(): void;
    }
    class SlaveParserHandler extends SkippingParserHandler {
        constructor(scope: Exprs.LexicalScope, owner: DispatchParserHandler, topLevel: boolean);
        report(message: string): void;
        reportAndSkip(message: string): void;
        startSelectorRule(): void;
        startFontFaceRule(): void;
        startFootnoteRule(pseudoelem: string | null): void;
        startViewportRule(): void;
        startDefineRule(): void;
        startRegionRule(): void;
        startPageRule(): void;
        startWhenRule(expr: Css.Expr): void;
        startFlowRule(flowName: string): void;
        startPageTemplateRule(): void;
        startPageMasterRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionGroupRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startFuncWithSelector(funcName: string): void;
        endFuncWithSelector(): void;
        property(name: string, value: Css.Val, important: boolean): void;
    }
    const actionsBase: Action_$0[];
    const actionsStyleAttribute: Action_$0[];
    const actionsSelector: Action_$0[];
    const actionsSelectorInFunc: Action_$0[];
    const actionsSelectorCont: Action_$0[];
    const actionsSelectorStart: Action_$0[];
    const actionsPropVal: Action_$0[];
    const actionsExprVal: Action_$0[];
    const actionsExprOp: Action_$0[];
    const actionsError: Action_$0[];
    const actionsErrorDecl: Action_$0[];
    const actionsErrorSelector: Action_$0[];
    const priority: number[];
    enum Action_$0 {
        SELECTOR_NAME_1 = 1,
        SELECTOR_NAME = 2,
        SELECTOR_ANY_1 = 3,
        SELECTOR_ANY = 4,
        SELECTOR_ID_1 = 5,
        SELECTOR_ID = 6,
        SELECTOR_CLASS_1 = 7,
        SELECTOR_CLASS = 8,
        SELECTOR_ATTR_1 = 9,
        SELECTOR_ATTR = 10,
        SELECTOR_CHILD = 11,
        SELECTOR_SIBLING = 12,
        SELECTOR_BODY = 13,
        SELECTOR_PSEUDOCLASS = 14,
        VAL_IDENT = 15,
        VAL_HASH = 16,
        VAL_NUM = 17,
        VAL_INT = 18,
        VAL_NUMERIC = 19,
        VAL_STR = 20,
        VAL_URL = 21,
        VAL_COMMA = 22,
        VAL_SLASH = 23,
        VAL_FUNC = 24,
        VAL_C_PAR = 25,
        VAL_END = 26,
        RULE_END = 27,
        IDENT = 28,
        SELECTOR_START = 29,
        AT = 30,
        EXPR_IDENT = 31,
        EXPR_NUM = 32,
        EXPR_NUMERIC = 33,
        EXPR_STR = 34,
        EXPR_PARAM = 35,
        EXPR_PREFIX = 36,
        EXPR_INFIX = 37,
        EXPR_FUNC = 38,
        EXPR_C_PAR = 39,
        EXPR_O_PAR = 40,
        SELECTOR_NEXT = 41,
        SELECTOR_PSEUDOELEM = 42,
        EXPR_O_BRC = 43,
        VAL_FINISH = 44,
        EXPR_INFIX_NAME = 45,
        PROP = 46,
        VAL_BANG = 47,
        VAL_BRC = 48,
        EXPR_SEMICOL = 49,
        ERROR_PUSH = 50,
        ERROR_POP = 51,
        ERROR_POP_DECL = 52,
        ERROR_SEMICOL = 53,
        VAL_PLUS = 54,
        SELECTOR_PSEUDOCLASS_1 = 55,
        SELECTOR_FOLLOWING_SIBLING = 56,
        DONE = 200
    }
    const OP_MEDIA_AND: number;
    enum ExprContext {
        PROP = 0,
        WHEN = 1,
        MEDIA = 2,
        IMPORT = 3
    }
    class Parser {
        actions: Action_$0[];
        tokenizer: CssTokenizer.Tokenizer;
        readonly handler: ParserHandler;
        baseURL: string;
        valStack: any[];
        namespacePrefixToURI: {
            [key: string]: string;
        };
        defaultNamespaceURI: string | null;
        propName: string | null;
        propImportant: boolean;
        exprContext: ExprContext;
        result: Css.Val;
        importReady: boolean;
        importURL: string | null;
        importCondition: Css.Expr;
        errorBrackets: number[];
        ruleStack: string[];
        regionRule: boolean;
        pageRule: boolean;
        constructor(actions: Action_$0[], tokenizer: CssTokenizer.Tokenizer, handler: ParserHandler, baseURL: string);
        extractVals(sep: string, index: number): Css.Val[];
        valStackReduce(sep: string, token: CssTokenizer.Token): Css.Val;
        exprError(mnemonics: string, token: CssTokenizer.Token): void;
        exprStackReduce(op: number, token: CssTokenizer.Token): boolean;
        readPseudoParams(): (number | string)[];
        private readNthPseudoParams;
        makeCondition(classes: string | null, condition: Exprs.Val): Css.Expr;
        isInsidePropertyOnlyRule(): boolean;
        runParser(count: number, parsingValue: any, parsingStyleAttr: boolean, parsingMediaQuery: any, parsingFunctionParam: any): boolean;
    }
    class ErrorHandler extends ParserHandler {
        readonly scope: Exprs.LexicalScope;
        constructor(scope: Exprs.LexicalScope);
        error(mnemonics: string, token: CssTokenizer.Token): void;
        getScope(): Exprs.LexicalScope;
    }
    function parseStylesheet(tokenizer: CssTokenizer.Tokenizer, handler: ParserHandler, baseURL: string, classes: string | null, media: string | null): Task.Result<boolean>;
    function parseStylesheetFromText(text: string, handler: ParserHandler, baseURL: string, classes: string | null, media: string | null): Task.Result<boolean>;
    function parseStylesheetFromURL(url: string, handler: ParserHandler, classes: string | null, media: string | null): Task.Result<boolean>;
    function parseValue(scope: Exprs.LexicalScope, tokenizer: CssTokenizer.Tokenizer, baseURL: string): Css.Val;
    function parseStyleAttribute(tokenizer: CssTokenizer.Tokenizer, handler: ParserHandler, baseURL: string): void;
    function parseMediaQuery(tokenizer: CssTokenizer.Tokenizer, handler: ParserHandler, baseURL: string): Css.Expr;
    const numProp: {
        [key: string]: boolean;
    };
    function takesOnlyNum(propName: string): boolean;
    function evaluateExprToCSS(context: Exprs.Context, val: Exprs.Val, propName: string): Css.Val;
    function evaluateCSSToCSS(context: Exprs.Context, val: Css.Val, propName: string): Css.Val;
}
declare namespace CssStyler_$0 {
    class SlipRange {
        endStuckFixed: number;
        endFixed: number;
        endSlipped: number;
        constructor(endStuckFixed: any, endFixed: any, endSlipped: any);
    }
    class SlipMap {
        map: SlipRange[];
        getMaxFixed(): number;
        getMaxSlipped(): number;
        addStuckRange(endFixed: number): void;
        addSlippedRange(endFixed: number): void;
        slippedByFixed(fixed: number): number;
        fixedBySlipped(slipped: number): number;
    }
    interface FlowListener {
        encounteredFlowChunk(flowChunk: Vtree_$0.FlowChunk, flow: Vtree_$0.Flow): any;
    }
    interface AbstractStyler_$0 extends CssStyler.AbstractStyler_$0 {
    }
    class Box {
        readonly context: Exprs.Context;
        readonly style: CssCascade_$0.ElementStyle;
        readonly offset: number;
        readonly isRoot: boolean;
        readonly flowChunk: Vtree_$0.FlowChunk;
        readonly atBlockStart: boolean;
        readonly atFlowStart: boolean;
        readonly isParentBoxDisplayed: boolean;
        flowName: string;
        isBlockValue: boolean | null;
        hasBoxValue: boolean | null;
        styleValues: {
            [key: string]: Css.Val;
        };
        beforeBox: Box;
        afterBox: Box;
        breakBefore: string | null;
        constructor(context: Exprs.Context, style: CssCascade_$0.ElementStyle, offset: number, isRoot: boolean, flowChunk: Vtree_$0.FlowChunk, atBlockStart: boolean, atFlowStart: boolean, isParentBoxDisplayed: boolean);
        buildAfterPseudoElementBox(offset: number, atBlockStart: boolean, atFlowStart: boolean): void;
        styleValue(name: string, defaultValue?: Css.Val): Css.Val | null;
        displayValue(): Css.Val;
        isBlock(): boolean;
        hasBox(): boolean;
        getBreakValue(edge: string): string | null;
    }
    class BoxStack {
        readonly context: Exprs.Context;
        stack: Box[];
        atBlockStart: boolean;
        atFlowStart: boolean;
        atStartStack: {
            atBlockStart: boolean;
            atFlowStart: boolean;
        }[];
        constructor(context: Exprs.Context);
        empty(): boolean;
        lastBox(): Box | undefined;
        lastFlowName(): string | null;
        isCurrentBoxDisplayed(): boolean;
        push(style: CssCascade_$0.ElementStyle, offset: number, isRoot: boolean, newFlowChunk?: Vtree_$0.FlowChunk): Box;
        encounteredTextNode(node: Node): void;
        pop(offset: number): Box;
        nearestBlockStartOffset(box: Box): number;
    }
    class Styler implements AbstractStyler_$0 {
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly scope: Exprs.LexicalScope;
        readonly context: Exprs.Context;
        readonly primaryFlows: {
            [key: string]: boolean;
        };
        readonly validatorSet: CssValidator.ValidatorSet;
        readonly counterListener: CssCascade_$0.CounterListener;
        root: Element;
        cascadeHolder: CssCascade_$0.Cascade;
        last: Node;
        rootStyle: CssCascade_$0.ElementStyle;
        styleMap: {
            [key: string]: CssCascade_$0.ElementStyle;
        };
        flows: {
            [key: string]: Vtree_$0.Flow;
        };
        flowChunks: Vtree_$0.FlowChunk[];
        flowListener: FlowListener;
        flowToReach: string | null;
        idToReach: string | null;
        cascade: CssCascade_$0.CascadeInstance;
        offsetMap: SlipMap;
        primary: boolean;
        primaryStack: boolean[];
        rootBackgroundAssigned: boolean;
        rootLayoutAssigned: boolean;
        lastOffset: number;
        breakBeforeValues: {
            [key: number]: string;
        };
        boxStack: BoxStack;
        bodyReached: boolean;
        constructor(xmldoc: XmlDoc.XMLDocHolder, cascade: CssCascade_$0.Cascade, scope: Exprs.LexicalScope, context: Exprs.Context, primaryFlows: {
            [key: string]: boolean;
        }, validatorSet: CssValidator.ValidatorSet, counterListener: CssCascade_$0.CounterListener, counterResolver: CssCascade_$0.CounterResolver);
        hasProp(style: CssCascade_$0.ElementStyle, map: CssValidator.ValueMap, name: string): boolean;
        transferPropsToRoot(srcStyle: CssCascade_$0.ElementStyle, map: CssValidator.ValueMap): void;
        postprocessTopStyle(elemStyle: CssCascade_$0.ElementStyle, isBody: boolean): void;
        getTopContainerStyle(): CssCascade_$0.ElementStyle;
        getAttrStyle(elem: Element): CssCascade_$0.ElementStyle;
        getReachedOffset(): number;
        replayFlowElementsFromOffset(offset: number): void;
        resetFlowChunkStream(flowListener: FlowListener): void;
        styleUntilFlowIsReached(flowName: string): void;
        styleUntilIdIsReached(id: string): void;
        private encounteredFlowElement;
        registerForcedBreakOffset(breakValue: string | null, offset: number, flowName: string): void;
        styleUntil(startOffset: number, lookup: number): number;
        getStyle(element: Element, deep: boolean): CssCascade_$0.ElementStyle;
        processContent(element: Element, styles: {
            [key: string]: Css.Val;
        }): void;
    }
    const columnProps: string[];
}
declare namespace CssTokenizer {
    interface TokenizerHandler {
        error(mnemonics: string, token: Token): void;
    }
    function escapeParseSingle(str: string): string;
    function escapeParse(str: string): string;
    enum TokenType {
        EOF = 0,
        IDENT = 1,
        STR = 2,
        NUMERIC = 3,
        NUM = 4,
        INT = 5,
        FUNC = 6,
        HASH = 7,
        URL = 8,
        CLASS = 9,
        O_PAR = 10,
        C_PAR = 11,
        O_BRC = 12,
        C_BRC = 13,
        O_BRK = 14,
        C_BRK = 15,
        COMMA = 16,
        SEMICOL = 17,
        COLON = 18,
        SLASH = 19,
        AT = 20,
        PERCENT = 21,
        QMARK = 22,
        PLUS = 23,
        MINUS = 24,
        BAR_BAR = 25,
        AMP_AMP = 26,
        BANG = 31,
        DOLLAR = 32,
        HAT = 33,
        BAR = 34,
        TILDE = 35,
        STAR = 36,
        GT = 37,
        LT = 38,
        EQ = 39,
        BANG_EQ = 41,
        DOLLAR_EQ = 42,
        HAT_EQ = 43,
        BAR_EQ = 44,
        TILDE_EQ = 45,
        STAR_EQ = 46,
        GT_EQ = 47,
        LT_EQ = 48,
        EQ_EQ = 49,
        COL_COL = 50,
        INVALID = 51,
        LAST = 51
    }
    class Token {
        type: TokenType;
        precededBySpace: boolean;
        num: number;
        text: string;
        position: number;
        constructor();
    }
    enum Action {
        SPACE = 1,
        INT = 2,
        IDENT = 3,
        BANG = 4,
        HASH = 6,
        DOLLAR = 7,
        PERCENT = 8,
        AMP = 9,
        O_PAR = 10,
        C_PAR = 11,
        STAR = 12,
        PLUS = 13,
        COMMA = 14,
        MINUS = 15,
        DOT = 16,
        SLASH = 17,
        COLON = 18,
        SEMICOL = 19,
        LT = 20,
        EQ = 21,
        GT = 22,
        QMARK = 23,
        AT = 24,
        O_BRK = 25,
        C_BRK = 26,
        O_BRC = 27,
        C_BRC = 28,
        BSLASH = 29,
        HAT = 30,
        BAR = 31,
        TILDE = 32,
        STR1 = 33,
        STR2 = 34,
        END = 35,
        EQTAIL = 36,
        ENDINT = 37,
        ENDNUM = 38,
        CONT = 39,
        UNIT = 40,
        PCUNIT = 41,
        NUMBER = 42,
        ENDIDNT = 43,
        IDNTESC = 44,
        ENDIDES = 45,
        ENDSTR = 46,
        ENDESTR = 47,
        STR1ESC = 48,
        STR2ESC = 49,
        BAR_BAR = 50,
        AMP_AMP = 51,
        FUNC = 52,
        FUNCES = 53,
        COMMENT = 54,
        COMMST = 55,
        ENDNOTK = 56,
        MINMIN = 57,
        TOINT = 58,
        TONUM = 59,
        TOIDENT = 60,
        TOIDES = 61,
        KILL1 = 62,
        KILL2 = 63,
        URL = 64,
        URL1 = 65,
        URL2 = 66,
        ENDURL = 67,
        TERMURL = 68,
        FINURL = 69,
        LT_BG = 70,
        LT_BG_M = 71,
        INVALID = 72,
        CHKPOSS = 73,
        CHKPOSN = 74,
        URLESC = 75,
        IDESCH = 76,
        COL_COL = 77,
        TOCLASS = 78,
        CHKSP = 79,
        EOF = 80
    }
    function makeActions(def: Action, spec: Action[]): Action[];
    const actionsNormal: Action[];
    const actionsIdent: Action[];
    const actionsNumOrClass: Action[];
    const actionsMinus: Action[];
    const actionsIdentEsc: Action[];
    const actionsInt: Action[];
    const actionsNumber: Action[];
    const actionsCheckEq: Action[];
    const actionsColon: Action[];
    const actionsBar: Action[];
    const actionsAmp: Action[];
    const actionsSlash: Action[];
    const actionsComment: Action[];
    const actionsCommentStar: Action[];
    const actionsMinusMinus: Action[];
    const actionsLt: Action[];
    const actionsLtBang: Action[];
    const actionsLtBangMinus: Action[];
    const actionsIdentEscChr: Action[];
    const actionsStr1: Action[];
    const actionsStr2: Action[];
    const actionsStr1Esc: Action[];
    const actionsStr2Esc: Action[];
    const actionsURL: Action[];
    const actionsURLInside: Action[];
    const actionsURLInside1: Action[];
    const actionsURLInside2: Action[];
    const actionsURLTail: Action[];
    const INITIAL_INDEX_MASK = 15;
    class Tokenizer {
        input: string;
        readonly handler: TokenizerHandler;
        indexMask: number;
        buffer: Token[];
        head: number;
        tail: number;
        curr: number;
        position: number;
        constructor(input: string, handler: TokenizerHandler);
        token(): Token;
        nthToken(n: number): Token;
        consume(): void;
        mark(): void;
        reset(): void;
        unmark(): void;
        hasMark(): boolean;
        private reallocate;
        private error;
        private fillBuffer;
    }
}
declare namespace CssValidator {
    interface PropertyReceiver {
        unknownProperty(name: string, value: Css.Val): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    class Node {
        validator: PropertyValidator;
        success: Node;
        failure: Node;
        code: number;
        constructor(validator: PropertyValidator);
        isSpecial(): boolean;
        markAsStartGroup(): void;
        isStartGroup(): boolean;
        markAsEndGroup(): void;
        isEndGroup(): boolean;
        markAsStartAlternate(index: number): void;
        isStartAlternate(): boolean;
        markAsEndAlternate(index: number): void;
        isEndAlternate(): boolean;
        getAlternate(): number;
    }
    class Connection {
        where: number;
        success: boolean;
        what: number;
        constructor(where: number, success: boolean);
    }
    enum Add_$0 {
        FOLLOW = 1,
        OPTIONAL = 2,
        REPEATED = 3,
        ALTERNATE = 4
    }
    class ValidatingGroup {
        nodes: Node[];
        connections: Connection[];
        match: number[];
        nomatch: number[];
        error: number[];
        emptyHead: boolean;
        connect(arr: number[], nodeIndex: number): void;
        clone(): ValidatingGroup;
        private addSpecialToArr;
        endSpecialGroup(): void;
        startSpecialGroup(): void;
        endClause(clause: number): void;
        startClause(clause: number): void;
        addPrimitive(validator: PropertyValidator): void;
        isSimple(): boolean;
        isPrimitive(): boolean;
        addGroup(group: ValidatingGroup, how: Add_$0): void;
        finish(successTerminal: Node, failTerminal: Node): Node;
    }
    const ALLOW_EMPTY = 1;
    const ALLOW_STR = 2;
    const ALLOW_IDENT = 4;
    const ALLOW_POS_NUMERIC = 8;
    const ALLOW_POS_NUM = 16;
    const ALLOW_POS_INT = 32;
    const ALLOW_COLOR = 64;
    const ALLOW_URL = 128;
    const ALLOW_NEGATIVE = 256;
    const ALLOW_ZERO = 512;
    const ALLOW_ZERO_PERCENT = 1024;
    const ALLOW_SLASH = 2048;
    type ValueMap = {
        [key: string]: Css.Val;
    };
    class PropertyValidator extends Css.Visitor {
        constructor();
        validateForShorthand(values: Css.Val[], index: number): Css.Val[];
    }
    class PrimitiveValidator extends PropertyValidator {
        readonly allowed: number;
        readonly idents: ValueMap;
        readonly units: ValueMap;
        constructor(allowed: number, idents: ValueMap, units: ValueMap);
        visitEmpty(empty: Css.Val): Css.Val;
        visitSlash(slash: Css.Val): Css.Val;
        visitStr(str: Css.Str): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitNum(num: Css.Num): Css.Val;
        visitInt(num: Css.Int): Css.Val;
        visitColor(color: Css.Color): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
        combine(other: PrimitiveValidator): PrimitiveValidator;
    }
    const ALWAYS_FAIL: PrimitiveValidator;
    class ListValidator extends PropertyValidator {
        successTerminal: Node;
        failureTerminal: Node;
        first: Node;
        constructor(group: ValidatingGroup);
        validateList(arr: Css.Val[], slice: boolean, startIndex: number): Css.Val[];
        validateSingle(inval: Css.Val): Css.Val;
        visitEmpty(empty: Css.Val): Css.Val;
        visitSlash(slash: Css.Val): Css.Val;
        visitStr(str: Css.Str): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitNum(num: Css.Num): Css.Val;
        visitInt(num: Css.Int): Css.Val;
        visitColor(color: Css.Color): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    class SpaceListValidator extends ListValidator {
        constructor(group: ValidatingGroup);
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        validateForShorthand(values: Css.Val[], index: number): Css.Val[];
    }
    class CommaListValidator extends ListValidator {
        constructor(group: ValidatingGroup);
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        validateForShorthand(values: Css.Val[], index: number): Css.Val[];
    }
    class FuncValidator extends ListValidator {
        readonly name: string;
        constructor(name: string, group: ValidatingGroup);
        validateSingle(inval: Css.Val): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
    }
    class ShorthandSyntaxNode {
        tryParse(values: Css.Val[], index: number, shorthandValidator: ShorthandValidator): number;
        success(rval: Css.Val, shorthandValidator: ShorthandValidator): void;
    }
    class ShorthandSyntaxProperty extends ShorthandSyntaxNode {
        readonly name: string;
        validator: PropertyValidator;
        constructor(validatorSet: ValidatorSet, name: string);
        tryParse(values: Css.Val[], index: number, shorthandValidator: ShorthandValidator): number;
        success(rval: Css.Val, shorthandValidator: ShorthandValidator): void;
    }
    class ShorthandSyntaxPropertyN extends ShorthandSyntaxProperty {
        readonly names: string[];
        constructor(validatorSet: ValidatorSet, names: string[]);
        success(rval: Css.Val, shorthandValidator: ShorthandValidator): void;
    }
    class ShorthandSyntaxCompound extends ShorthandSyntaxNode {
        readonly nodes: ShorthandSyntaxNode[];
        readonly slash: boolean;
        constructor(nodes: ShorthandSyntaxNode[], slash: boolean);
        tryParse(values: Css.Val[], index: number, shorthandValidator: ShorthandValidator): number;
    }
    class ShorthandValidator extends Css.Visitor {
        syntax: ShorthandSyntaxNode[];
        propList: string[];
        error: boolean;
        values: ValueMap;
        validatorSet: ValidatorSet;
        setOwner(validatorSet: ValidatorSet): void;
        syntaxNodeForProperty(name: string): ShorthandSyntaxNode;
        clone(): this;
        init(syntax: ShorthandSyntaxNode[], propList: string[]): void;
        finish(important: boolean, receiver: PropertyReceiver): boolean;
        propagateInherit(important: boolean, receiver: PropertyReceiver): void;
        validateList(list: Css.Val[]): number;
        validateSingle(val: Css.Val): Css.Val;
        visitEmpty(empty: Css.Val): Css.Val;
        visitStr(str: Css.Str): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
        visitNumeric(numeric: Css.Numeric): Css.Val;
        visitNum(num: Css.Num): Css.Val;
        visitInt(num: Css.Int): Css.Val;
        visitColor(color: Css.Color): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitFunc(func: Css.Func): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    class SimpleShorthandValidator extends ShorthandValidator {
        constructor();
        validateList(list: Css.Val[]): number;
    }
    class InsetsShorthandValidator extends ShorthandValidator {
        constructor();
        validateList(list: Css.Val[]): number;
        createSyntaxNode(): ShorthandSyntaxPropertyN;
    }
    class InsetsSlashShorthandValidator extends ShorthandValidator {
        constructor();
        validateList(list: Css.Val[]): number;
    }
    class CommaShorthandValidator extends SimpleShorthandValidator {
        constructor();
        mergeIn(acc: {
            [key: string]: Css.Val[];
        }, values: ValueMap): void;
        visitCommaList(list: Css.CommaList): Css.Val;
    }
    class FontShorthandValidator extends SimpleShorthandValidator {
        constructor();
        init(syntax: ShorthandSyntaxNode[], propList: string[]): void;
        validateList(list: Css.Val[]): number;
        visitCommaList(list: Css.CommaList): Css.Val;
        visitIdent(ident: Css.Ident): Css.Val;
    }
    const shorthandValidators: {
        [key: string]: typeof ShorthandValidator;
    };
    class ValidatorSet {
        validators: {
            [key: string]: PropertyValidator;
        };
        prefixes: {
            [key: string]: {
                [key: string]: boolean;
            };
        };
        defaultValues: ValueMap;
        namedValidators: {
            [key: string]: ValidatingGroup;
        };
        systemFonts: {
            [key: string]: ValueMap;
        };
        shorthands: {
            [key: string]: ShorthandValidator;
        };
        layoutProps: ValueMap;
        backgroundProps: ValueMap;
        private addReplacement;
        private newGroup;
        private addCounts;
        private primitive;
        private newFunc;
        initBuiltInValidators(): void;
        private isBuiltIn;
        private readNameAndPrefixes;
        private parseValidators;
        private parseDefaults;
        private parseShorthands;
        parse(text: string): void;
        makePropSet(propList: string[]): ValueMap;
        validatePropertyAndHandleShorthand(name: string, value: Css.Val, important: boolean, receiver: PropertyReceiver): void;
    }
    function baseValidatorSet(): ValidatorSet;
}
declare namespace Exprs {
    type Preferences = {
        fontFamily: string;
        lineHeight: number;
        margin: number;
        hyphenate: boolean;
        columnWidth: number;
        horizontal: boolean;
        nightMode: boolean;
        spreadView: boolean;
        pageBorder: number;
        enabledMediaTypes: {
            [key: string]: boolean;
        };
        defaultPaperSize?: {
            [key: string]: number;
        };
    };
    function defaultPreferences(): Preferences;
    function clonePreferences(pref: Preferences): Preferences;
    const defaultPreferencesInstance: Preferences;
    const Special: {
        PENDING: Pending;
    };
    type Result = string | number | boolean | undefined;
    type PendingResult = Special | Result;
    function letterbox(viewW: number, viewH: number, objW: number, objH: number): string;
    function cssString(str: string): string;
    function cssIdent(name: string): string;
    function makeQualifiedName(objName: string | null, memberName: string): string;
    let nextKeyIndex: number;
    class LexicalScope {
        parent: LexicalScope;
        resolver?: (p1: string, p2: boolean) => Val;
        scopeKey: string;
        children: LexicalScope[];
        zero: Const;
        one: Const;
        _true: Const;
        _false: Const;
        values: {
            [key: string]: Val;
        };
        funcs: {
            [key: string]: Val;
        };
        builtIns: {
            [key: string]: (...p1: Result[]) => Result;
        };
        constructor(parent: LexicalScope, resolver?: (p1: string, p2: boolean) => Val);
        defineBuiltInName(name: string, fn: () => Result): void;
        defineName(qualifiedName: string, val: Val): void;
        defineFunc(qualifiedName: string, val: Val): void;
        defineBuiltIn(qualifiedName: string, fn: (...p1: Result[]) => Result): void;
    }
    function isAbsoluteLengthUnit(unit: string): boolean;
    function isViewportRelativeLengthUnit(unit: string): boolean;
    function isFontRelativeLengthUnit(unit: string): boolean;
    const defaultUnitSizes: {
        [key: string]: number;
    };
    function needUnitConversion(unit: string): boolean;
    type ScopeContext = {
        [key: string]: Result;
    };
    class Context {
        readonly rootScope: LexicalScope;
        readonly viewportWidth: number;
        readonly viewportHeight: number;
        protected actualPageWidth: number | null;
        pageWidth: () => number;
        protected actualPageHeight: number | null;
        pageHeight: () => number;
        initialFontSize: number;
        rootFontSize: number | null;
        fontSize: () => number;
        pref: Preferences;
        scopes: {
            [key: string]: ScopeContext;
        };
        pageAreaWidth: number | null;
        pageAreaHeight: number | null;
        pageVertical: boolean | null;
        pubTitle: string | null;
        docTitle: string | null;
        constructor(rootScope: LexicalScope, viewportWidth: number, viewportHeight: number, fontSize: number);
        private getScopeContext;
        clearScope(scope: LexicalScope): void;
        queryUnitSize(unit: string, isRoot: boolean): number;
        evalName(scope: LexicalScope, qualifiedName: string): Val;
        evalCall(scope: LexicalScope, qualifiedName: string, params: Val[], noBuiltInEval: boolean): Val;
        evalMediaName(name: string, not: boolean): boolean;
        evalMediaTest(feature: string, value: Val): boolean;
        queryVal(scope: LexicalScope, key: string): Result | undefined;
        storeVal(scope: LexicalScope, key: string, val: Result): void;
    }
    type DependencyCache = {
        [key: string]: boolean | Special;
    };
    class Val {
        scope: LexicalScope;
        key: string;
        constructor(scope: LexicalScope);
        toString(): string;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        expand(context: Context, params: Val[]): Val;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        dependOuter(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        depend(other: Val, context: Context): boolean;
        evaluate(context: Context): Result;
        isMediaName(): boolean;
    }
    class Prefix extends Val {
        val: Val;
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Infix extends Val {
        lhs: Val;
        rhs: Val;
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Logical extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Comparison extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Additive extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Multiplicative extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Not extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class Negate extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class And extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class AndMedia extends And {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Or extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class OrMedia extends Or {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Lt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Le extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Gt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ge extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Eq extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ne extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Add extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Subtract extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Multiply extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Divide extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Modulo extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Numeric extends Val {
        num: number;
        unit: string;
        constructor(scope: LexicalScope, num: number, unit: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class Named extends Val {
        qualifiedName: string;
        constructor(scope: LexicalScope, qualifiedName: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    }
    class MediaName extends Val {
        not: boolean;
        name: string;
        value: Val;
        constructor(scope: LexicalScope, not: boolean, name: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        isMediaName(): boolean;
    }
    class Native extends Val {
        fn: () => Result;
        str: string;
        constructor(scope: LexicalScope, fn: () => Result, str: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    function appendValArray(buf: Base.StringBuffer, arr: Val[]): void;
    function expandValArray(context: Context, arr: Val[], params: Val[]): Val[];
    function evalValArray(context: Context, arr: Val[]): Result[];
    class Call extends Val {
        qualifiedName: string;
        params: Val[];
        constructor(scope: LexicalScope, qualifiedName: string, params: Val[]);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Cond extends Val {
        cond: Val;
        ifTrue: Val;
        ifFalse: Val;
        constructor(scope: LexicalScope, cond: Val, ifTrue: Val, ifFalse: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Const extends Val {
        val: Result;
        constructor(scope: LexicalScope, val: Result);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class MediaTest extends Val {
        name: MediaName;
        value: Val;
        constructor(scope: LexicalScope, name: MediaName, value: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Param extends Val {
        index: number;
        constructor(scope: LexicalScope, index: number);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    function and(scope: LexicalScope, v1: Val, v2: Val): Val;
    function add(scope: LexicalScope, v1: Val, v2: Val): Val;
    function sub(scope: LexicalScope, v1: Val, v2: Val): Val;
    function mul(scope: LexicalScope, v1: Val, v2: Val): Val;
    function div(scope: LexicalScope, v1: Val, v2: Val): Val;
}
declare namespace Font {
    const traitProps: {
        [key: string]: Css.Val;
    };
    const bogusFontData: string;
    let bogusFontCounter: number;
    function makeFontTraitKey(properties: {
        [key: string]: Css.Val;
    }): string;
    function fillDefaults(properties: {
        [key: string]: Css.Val;
    }): void;
    function prepareProperties(properties: CssCascade_$0.ElementStyle, context: Exprs.Context): {
        [key: string]: Css.Val;
    };
    class Face {
        readonly properties: {
            [key: string]: Css.Val;
        };
        fontTraitKey: string;
        src: string | null;
        blobURLs: string[];
        blobs: Blob[];
        family: string | null;
        constructor(properties: {
            [key: string]: Css.Val;
        });
        traitsEqual(other: Face): boolean;
        makeAtRule(src: string, fontBytes: Blob): string;
    }
    class DocumentFaces {
        readonly deobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null;
        familyMap: {
            [key: string]: string;
        };
        constructor(deobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null);
        registerFamily(srcFace: Face, viewFace: Face): void;
        filterFontFamily(val: Css.Val): Css.Val;
    }
    class Mapper {
        readonly head: Element;
        readonly body: Element;
        srcURLMap: {
            [key: string]: TaskUtil.Fetcher<Face>;
        };
        familyPrefix: string;
        familyCounter: number;
        constructor(head: Element, body: Element, opt_familyPrefix?: string);
        getViewFontFamily(srcFace: Face, documentFaces: DocumentFaces): string;
        private initFont;
        loadFont(srcFace: Face, documentFaces: DocumentFaces): TaskUtil.Fetcher<Face>;
        findOrLoadFonts(srcFaces: Face[], documentFaces: DocumentFaces): Task.Result<boolean>;
    }
}
declare namespace GeometryUtil {
    class Rect {
        x1: number;
        y1: number;
        x2: number;
        y2: number;
        constructor(x1: number, y1: number, x2: number, y2: number);
    }
    class Point {
        x: number;
        y: number;
        constructor(x: number, y: number);
    }
    class Insets {
        left: number;
        top: number;
        right: number;
        bottom: number;
        constructor(left: number, top: number, right: number, bottom: number);
    }
    class Segment {
        low: Point;
        high: Point;
        winding: number;
        shapeId: number;
        constructor(low: Point, high: Point, winding: number, shapeId: number);
    }
    class Band {
        y1: number;
        y2: number;
        x1: number;
        x2: number;
        left: Element | null;
        right: Element | null;
        constructor(y1: number, y2: number, x1: number, x2: number);
    }
    function segmentCompare(s1: Segment, s2: Segment): number;
    class Shape {
        points: Point[];
        constructor(points: Point[]);
        addSegments(arr: Segment[], id: number): void;
        withOffset(offsetX: number, offsetY: number): Shape;
    }
    function shapeForEllipse(cx: number, cy: number, rx: number, ry: number): Shape;
    function shapeForRect(x1: number, y1: number, x2: number, y2: number): Shape;
    function shapeForRectObj(r: Rect): Shape;
    class BandIntersection {
        x: number;
        winding: number;
        shapeId: number;
        lowOrHigh: number;
        constructor(x: number, winding: number, shapeId: number, lowOrHigh: number);
    }
    function intersectY(s: Segment, y: number): number;
    function addBandIntersections(intersections: BandIntersection[], s: Segment, y1: number, y2: number): void;
    function mergeIntersections(intersections: BandIntersection[], includeCount: number, excludeCount: number): number[];
    function ceil(v: number, unit: number): number;
    function floor(v: number, unit: number): number;
    function rotatePoint(point: Point): Point;
    function rotateBox(box: Rect): Rect;
    function unrotateBox(box: Rect): Rect;
    function rotateShape(shape: Shape): Shape;
    function shapesToBands(box: Rect, include: Shape[], exclude: Shape[], granularity: number, snapHeight: number, vertical: boolean): Band[];
    function normalize(box: Rect, bands: Band[]): void;
    function findBand(bands: Band[], y: number): number;
    function findUppermostFullyOpenRect(bands: Band[], rect: Rect): Rect | null;
    function findBottommostFullyOpenRect(bands: Band[], rect: Rect): Rect | null;
    function positionFloat(box: Rect, bands: Band[], floatBox: Rect, side: string): boolean;
    function addFloatToBands(box: Rect, bands: Band[], floatBox: Rect, floatBands: Band[], side: string): void;
}
declare namespace Net_$0 {
    enum XMLHttpRequestResponseType {
        DEFAULT = "",
        ARRAYBUFFER = "arraybuffer",
        BLOB = "blob",
        DOCUMENT = "document",
        JSON = "json",
        TEXT = "text"
    }
    type Response_$0 = Net.Response_$0;
    function ajax(url: string, opt_type?: XMLHttpRequestResponseType, opt_method?: string, opt_data?: string, opt_contentType?: string): Task.Result<Response_$0>;
    function makeBlob(parts: (string | Blob | ArrayBuffer | ArrayBufferView)[], opt_type?: string): any;
    function readBlob(blob: Blob): any;
    function revokeObjectURL(url: string): void;
    function createObjectURL(blob: Blob): string;
    class ResourceStore_$0<Resource> implements Net.ResourceStore_$0<Resource> {
        readonly parser: (p1: Response_$0, p2: ResourceStore_$0<Resource>) => Task.Result<Resource>;
        readonly type: XMLHttpRequestResponseType;
        resources: {
            [key: string]: Resource;
        };
        fetchers: {
            [key: string]: TaskUtil.Fetcher<Resource>;
        };
        constructor(parser: (p1: Response_$0, p2: ResourceStore_$0<Resource>) => Task.Result<Resource>, type: XMLHttpRequestResponseType);
        load(url: string, opt_required?: boolean, opt_message?: string): Task.Result<Resource>;
        private fetchInner;
        fetch(url: string, opt_required?: boolean, opt_message?: string): TaskUtil.Fetcher<Resource>;
        get(url: string): XmlDoc.XMLDocHolder;
        delete(url: string): void;
    }
    type JSONStore = ResourceStore_$0<Base.JSON>;
    function parseJSONResource(response: Response_$0, store: JSONStore): Task.Result<Base.JSON>;
    function newJSONStore(): JSONStore;
}
declare namespace PageFloats_$0 {
    const FloatReference_$0: typeof PageFloats.FloatReference_$0;
    type FloatReference_$0 = PageFloats.FloatReference_$0;
    function floatReferenceOf(str: string): FloatReference_$0;
    function isPageFloat(floatReference: FloatReference_$0): boolean;
    function resolveInlineFloatDirection(floatSide: string, vertical: boolean, direction: string): string;
    class PageFloat_$0 implements PageFloats.PageFloat_$0 {
        readonly nodePosition: Vtree.NodePosition;
        readonly floatReference: FloatReference_$0;
        readonly floatSide: string;
        readonly clearSide: string | null;
        readonly flowName: string;
        readonly floatMinWrapBlock: Css.Numeric | null;
        order: number | null;
        id: PageFloatID_$0 | null;
        constructor(nodePosition: Vtree.NodePosition, floatReference: FloatReference_$0, floatSide: string, clearSide: string | null, flowName: string, floatMinWrapBlock: Css.Numeric | null);
        getOrder(): number;
        getId(): PageFloatID_$0;
        isAllowedOnContext(pageFloatLayoutContext: PageFloatLayoutContext_$0): boolean;
        isAllowedToPrecede(other: PageFloat_$0): boolean;
    }
    class PageFloatStore {
        private floats;
        private nextPageFloatIndex;
        private nextOrder;
        private createPageFloatId;
        addPageFloat(float: PageFloat_$0): void;
        findPageFloatByNodePosition(nodePosition: Vtree.NodePosition): PageFloat_$0 | null;
        findPageFloatById(id: PageFloatID_$0): PageFloat_$0;
    }
    class PageFloatFragment_$0 implements PageFloats.PageFloatFragment_$0 {
        readonly floatReference: FloatReference_$0;
        readonly floatSide: string;
        readonly continuations: PageFloatContinuation_$0[];
        readonly area: Vtree.Container;
        readonly continues: boolean;
        constructor(floatReference: FloatReference_$0, floatSide: string, continuations: PageFloatContinuation_$0[], area: Vtree.Container, continues: boolean);
        hasFloat(float: PageFloat_$0): boolean;
        findNotAllowedFloat(context: PageFloatLayoutContext_$0): PageFloat_$0 | null;
        getOuterShape(): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
        getOrder(): number;
        shouldBeStashedBefore(float: PageFloat_$0): boolean;
        addContinuations(continuations: PageFloatContinuation_$0[]): void;
        getFlowName(): string;
    }
    class PageFloatContinuation_$0 implements PageFloats.PageFloatContinuation_$0 {
        readonly float: PageFloat_$0;
        readonly nodePosition: Vtree.NodePosition;
        constructor(float: PageFloat_$0, nodePosition: Vtree.NodePosition);
        equals(other: PageFloatContinuation_$0 | null): boolean;
    }
    type PageFloatPlacementCondition_$0 = PageFloats.PageFloatPlacementCondition_$0;
    class PageFloatLayoutContext_$0 implements PageFloats.PageFloatLayoutContext_$0 {
        readonly parent: PageFloatLayoutContext_$0;
        private readonly floatReference;
        private container;
        readonly flowName: string | null;
        readonly generatingNodePosition: Vtree.NodePosition | null;
        private children;
        writingMode: Css.Val;
        direction: Css.Val;
        private invalidated;
        private floatStore;
        private forbiddenFloats;
        floatFragments: PageFloatFragment_$0[];
        private stashedFloatFragments;
        private floatAnchors;
        private floatsDeferredToNext;
        private floatsDeferredFromPrevious;
        private layoutConstraints;
        private locked;
        constructor(parent: PageFloatLayoutContext_$0, floatReference: FloatReference_$0 | null, container: Vtree.Container, flowName: string | null, generatingNodePosition: Vtree.NodePosition | null, writingMode: Css.Val | null, direction: Css.Val | null);
        private getParent;
        private getPreviousSiblingOf;
        private getPreviousSibling;
        getContainer(floatReference?: FloatReference_$0): Vtree.Container;
        setContainer(container: Vtree.Container): void;
        addPageFloat(float: PageFloat_$0): void;
        getPageFloatLayoutContext(floatReference: FloatReference_$0): PageFloatLayoutContext_$0;
        findPageFloatByNodePosition(nodePosition: Vtree.NodePosition): PageFloat_$0 | null;
        private forbid;
        isForbidden(float: PageFloat_$0): boolean;
        addPageFloatFragment(floatFragment: PageFloatFragment_$0, dontInvalidate?: boolean): void;
        removePageFloatFragment(floatFragment: PageFloatFragment_$0, dontInvalidate?: boolean): void;
        findPageFloatFragment(float: PageFloat_$0): PageFloatFragment_$0 | null;
        hasFloatFragments(condition?: (p1: PageFloatFragment_$0) => boolean): boolean;
        hasContinuingFloatFragmentsInFlow(flowName: string): boolean;
        registerPageFloatAnchor(float: PageFloat_$0, anchorViewNode: Node): void;
        collectPageFloatAnchors(): any;
        isAnchorAlreadyAppeared(floatId: PageFloatID_$0): boolean;
        deferPageFloat(continuation: PageFloatContinuation_$0): void;
        hasPrecedingFloatsDeferredToNext(float: PageFloat_$0, ignoreReference?: boolean): boolean;
        getLastFollowingFloatInFragments(float: PageFloat_$0): PageFloat_$0 | null;
        getDeferredPageFloatContinuations(flowName?: string | null): PageFloatContinuation_$0[];
        getPageFloatContinuationsDeferredToNext(flowName?: string | null): PageFloatContinuation_$0[];
        getFloatsDeferredToNextInChildContexts(): PageFloat_$0[];
        checkAndForbidNotAllowedFloat(): boolean;
        checkAndForbidFloatFollowingDeferredFloat(): boolean;
        finish(): void;
        hasSameContainerAs(other: PageFloatLayoutContext_$0): boolean;
        invalidate(): void;
        detachChildren(): PageFloatLayoutContext_$0[];
        attachChildren(children: PageFloatLayoutContext_$0[]): void;
        isInvalidated(): any;
        validate(): void;
        private toLogical;
        private toPhysical;
        removeEndFloatFragments(floatSide: string): void;
        stashEndFloatFragments(float: PageFloat_$0): void;
        restoreStashedFragments(floatReference: FloatReference_$0): void;
        discardStashedFragments(floatReference: FloatReference_$0): void;
        getStashedFloatFragments(floatReference: FloatReference_$0): PageFloatFragment_$0[];
        private getLimitValue;
        private getLimitValueInner;
        private getLimitValuesInner;
        setFloatAreaDimensions(area: LayoutType.PageFloatArea, floatReference: FloatReference_$0, floatSide: string, anchorEdge: number | null, init: boolean, force: boolean, condition: PageFloatPlacementCondition_$0): string | null;
        getFloatFragmentExclusions(): GeometryUtil.Shape[];
        private reattachFloatFragments;
        getMaxReachedAfterEdge(): number;
        getBlockStartEdgeOfBlockEndFloats(): number;
        getPageFloatClearEdge(clear: string, column: LayoutType.Column): number;
        getPageFloatPlacementCondition(float: PageFloat_$0, floatSide: string, clearSide: string | null): PageFloatPlacementCondition_$0;
        getLayoutConstraints(): LayoutType.LayoutConstraint[];
        addLayoutConstraint(layoutConstraint: LayoutType.LayoutConstraint, floatReference: FloatReference_$0): void;
        isColumnFullWithPageFloats(column: LayoutType.Column): boolean;
        getMaxBlockSizeOfPageFloats(): number;
        lock(): void;
        unlock(): void;
        isLocked(): boolean;
    }
    interface PageFloatLayoutStrategy_$0 extends PageFloats.PageFloatLayoutStrategy_$0 {
    }
    class PageFloatLayoutStrategyResolver {
        register(strategy: PageFloatLayoutStrategy_$0): void;
        findByNodeContext(nodeContext: Vtree.NodeContext): PageFloatLayoutStrategy_$0;
        findByFloat(float: PageFloat_$0): PageFloatLayoutStrategy_$0;
    }
    class NormalPageFloatLayoutStrategy implements PageFloatLayoutStrategy_$0 {
        appliesToNodeContext(nodeContext: Vtree.NodeContext): boolean;
        appliesToFloat(float: PageFloat_$0): boolean;
        createPageFloat(nodeContext: Vtree.NodeContext, pageFloatLayoutContext: PageFloatLayoutContext_$0, column: LayoutType.Column): Task.Result<PageFloat_$0>;
        createPageFloatFragment(continuations: PageFloatContinuation_$0[], floatSide: string, floatArea: LayoutType.PageFloatArea, continues: boolean): PageFloatFragment_$0;
        findPageFloatFragment(float: PageFloat_$0, pageFloatLayoutContext: PageFloatLayoutContext_$0): PageFloatFragment_$0 | null;
        adjustPageFloatArea(floatArea: LayoutType.PageFloatArea, floatContainer: Vtree.Container, column: LayoutType.Column): void;
        forbid(float: PageFloat_$0, pageFloatLayoutContext: PageFloatLayoutContext_$0): void;
    }
}
declare namespace CssPage {
    function resolvePageProgression(style: CssCascade.ElementStyle): Constants.PageProgression;
    type PageSize = {
        width: Css.Numeric;
        height: Css.Numeric;
    };
    const pageSizes: {
        [key: string]: PageSize;
    };
    const defaultPrinterMarkLineWidth: Css.Numeric;
    const defaultPrinterMarkOffset: Css.Numeric;
    const defaultPrinterMarkLineLength: Css.Numeric;
    const defaultBleedOffset: Css.Numeric;
    type PageSizeAndBleed = {
        width: Css.Numeric;
        height: Css.Numeric;
        bleed: Css.Numeric;
        bleedOffset: Css.Numeric;
    };
    function resolvePageSizeAndBleed(style: {
        [key: string]: CssCascade.CascadeValue;
    }): PageSizeAndBleed;
    type EvaluatedPageSizeAndBleed = {
        pageWidth: number;
        pageHeight: number;
        bleed: number;
        bleedOffset: number;
        cropOffset: number;
    };
    function evaluatePageSizeAndBleed(pageSizeAndBleed: PageSizeAndBleed, context: Exprs.Context): EvaluatedPageSizeAndBleed;
    function createPrinterMarkSvg(doc: Document, width: number, height: number): Element;
    function createPrinterMarkElement(doc: Document, lineWidth: number, elementType?: string): Element;
    enum CornerMarkPosition {
        TOP_LEFT = "top left",
        TOP_RIGHT = "top right",
        BOTTOM_LEFT = "bottom left",
        BOTTOM_RIGHT = "bottom right"
    }
    function createCornerMark(doc: Document, position: CornerMarkPosition, lineWidth: number, cropMarkLineLength: number, bleed: number, offset: number): Element;
    enum CrossMarkPosition {
        TOP = "top",
        BOTTOM = "bottom",
        LEFT = "left",
        RIGHT = "right"
    }
    function createCrossMark(doc: Document, position: CrossMarkPosition, lineWidth: number, lineLength: number, offset: number): Element;
    function addPrinterMarks(cascadedPageStyle: CssCascade.ElementStyle, evaluatedPageSizeAndBleed: EvaluatedPageSizeAndBleed, page: Vtree_$0.Page, context: Exprs.Context): void;
    const propertiesAppliedToPartition: {
        width: boolean;
        height: boolean;
        "block-size": boolean;
        "inline-size": boolean;
        margin: boolean;
        padding: boolean;
        border: boolean;
        outline: boolean;
        "outline-width": boolean;
        "outline-style": boolean;
        "outline-color": boolean;
    };
    enum MarginBoxPositionAlongVariableDimension {
        START = "start",
        CENTER = "center",
        END = "end"
    }
    type PageMarginBoxInformation = {
        order: number;
        isInTopRow: boolean;
        isInBottomRow: boolean;
        isInLeftColumn: boolean;
        isInRightColumn: boolean;
        positionAlongVariableDimension: MarginBoxPositionAlongVariableDimension;
    };
    const pageMarginBoxes: {
        [key: string]: PageMarginBoxInformation;
    };
    const pageMarginBoxNames: string[];
    const pageRuleMasterPseudoName = "vivliostyle-page-rule-master";
    const marginBoxesKey: string;
    class PageRuleMaster extends PageMaster.PageMaster<PageRuleMasterInstance> {
        private bodyPartitionKey;
        private pageMarginBoxes;
        constructor(scope: Exprs.LexicalScope, parent: PageMaster.RootPageBox, style: CssCascade.ElementStyle);
        createPageMarginBoxes(style: CssCascade.ElementStyle): void;
        private applySpecified;
        createInstance(parentInstance: any): PageRuleMasterInstance;
    }
    class PageRulePartition extends PageMaster.Partition<PageRulePartitionInstance> {
        readonly pageSize: PageSize;
        constructor(scope: Exprs.LexicalScope, parent: PageRuleMaster, style: CssCascade.ElementStyle, pageSize: PageSize);
        private applySpecified;
        createInstance(parentInstance: any): PageMaster.PageBoxInstance;
    }
    class PageMarginBoxPartition extends PageMaster.Partition<PageMarginBoxPartitionInstance> {
        readonly marginBoxName: string;
        constructor(scope: Exprs.LexicalScope, parent: PageRuleMaster, marginBoxName: string, style: CssCascade.ElementStyle);
        applySpecified(style: CssCascade.ElementStyle): void;
        createInstance(parentInstance: any): PageMaster.PageBoxInstance;
    }
    type PageAreaDimension = {
        borderBoxWidth: Exprs.Val;
        borderBoxHeight: Exprs.Val;
        marginTop: Exprs.Val;
        marginBottom: Exprs.Val;
        marginLeft: Exprs.Val;
        marginRight: Exprs.Val;
    };
    class PageRuleMasterInstance extends PageMaster.PageMasterInstance<PageRuleMaster> {
        pageAreaDimension: PageAreaDimension | null;
        pageMarginBoxInstances: {
            [key: string]: PageMarginBoxPartitionInstance;
        };
        constructor(parentInstance: PageMaster.PageBoxInstance, pageRuleMaster: PageRuleMaster);
        applyCascadeAndInit(cascade: CssCascade.CascadeInstance, docElementStyle: CssCascade.ElementStyle): void;
        initHorizontal(): void;
        initVertical(): void;
        setPageAreaDimension(dim: PageAreaDimension): void;
        adjustPageLayout(context: Exprs.Context, page: Vtree_$0.Page, clientLayout: Vtree_$0.ClientLayout): void;
        private sizeMarginBoxesAlongVariableDimension;
        private getSizesOfMarginBoxesAlongVariableDimension;
        private distributeAutoMarginBoxSizes;
        prepareContainer(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, docFaces: Font.DocumentFaces, clientLayout: Vtree_$0.ClientLayout): void;
    }
    class PageRulePartitionInstance extends PageMaster.PartitionInstance<PageRulePartition> {
        borderBoxWidth: Exprs.Val;
        borderBoxHeight: Exprs.Val;
        marginTop: Exprs.Val;
        marginRight: Exprs.Val;
        marginBottom: Exprs.Val;
        marginLeft: Exprs.Val;
        constructor(parentInstance: PageMaster.PageBoxInstance, pageRulePartition: PageRulePartition);
        applyCascadeAndInit(cascade: CssCascade.CascadeInstance, docElementStyle: CssCascade.ElementStyle): void;
        initHorizontal(): void;
        initVertical(): void;
        private resolvePageBoxDimensions;
        prepareContainer(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, docFaces: Font.DocumentFaces, clientLayout: Vtree_$0.ClientLayout): void;
    }
    class PageMarginBoxPartitionInstance extends PageMaster.PartitionInstance<PageMarginBoxPartition> {
        boxInfo: PageMarginBoxInformation;
        suppressEmptyBoxGeneration: boolean;
        constructor(parentInstance: PageMaster.PageBoxInstance, pageMarginBoxPartition: PageMarginBoxPartition);
        prepareContainer(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, docFaces: Font.DocumentFaces, clientLayout: Vtree_$0.ClientLayout): void;
        private applyVerticalAlign;
        private positionAlongVariableDimension;
        private positionAndSizeAlongFixedDimension;
        initHorizontal(): void;
        initVertical(): void;
        finishContainer(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, column: Vtree_$0.Container, columnCount: number, clientLayout: Vtree_$0.ClientLayout, docFaces: Font.DocumentFaces): void;
    }
    class PageManager {
        private readonly cascadeInstance;
        private readonly pageScope;
        private readonly rootPageBoxInstance;
        private readonly context;
        private readonly docElementStyle;
        private pageMasterCache;
        constructor(cascadeInstance: CssCascade.CascadeInstance, pageScope: Exprs.LexicalScope, rootPageBoxInstance: PageMaster.RootPageBoxInstance, context: Exprs.Context, docElementStyle: CssCascade.ElementStyle);
        private definePageProgression;
        getCascadedPageStyle(): CssCascade.ElementStyle;
        getPageRulePageMaster(pageMasterInstance: PageMaster.PageMasterInstance, cascadedPageStyle: CssCascade.ElementStyle): PageMaster.PageMasterInstance;
        private makeCacheKey;
        private makeCascadeValueObjectKey;
        private generatePageRuleMaster;
        private generateCascadedPageMaster;
    }
    class CheckPageTypeAction extends CssCascade.ChainedAction {
        readonly pageType: string;
        constructor(pageType: string);
        apply(cascadeInstance: CssCascade.CascadeInstance): void;
        getPriority(): number;
        makePrimary(cascade: CssCascade.Cascade): boolean;
    }
    class IsFirstPageAction extends CssCascade.ChainedAction {
        readonly scope: Exprs.LexicalScope;
        constructor(scope: Exprs.LexicalScope);
        apply(cascadeInstance: CssCascade.CascadeInstance): void;
        getPriority(): number;
    }
    class IsLeftPageAction extends CssCascade.ChainedAction {
        readonly scope: Exprs.LexicalScope;
        constructor(scope: Exprs.LexicalScope);
        apply(cascadeInstance: CssCascade.CascadeInstance): void;
        getPriority(): number;
    }
    class IsRightPageAction extends CssCascade.ChainedAction {
        readonly scope: Exprs.LexicalScope;
        constructor(scope: Exprs.LexicalScope);
        apply(cascadeInstance: CssCascade.CascadeInstance): void;
        getPriority(): number;
    }
    class IsRectoPageAction extends CssCascade.ChainedAction {
        readonly scope: Exprs.LexicalScope;
        constructor(scope: Exprs.LexicalScope);
        apply(cascadeInstance: CssCascade.CascadeInstance): void;
        getPriority(): number;
    }
    class IsVersoPageAction extends CssCascade.ChainedAction {
        readonly scope: Exprs.LexicalScope;
        constructor(scope: Exprs.LexicalScope);
        apply(cascadeInstance: CssCascade.CascadeInstance): void;
        getPriority(): number;
    }
    class ApplyPageRuleAction extends CssCascade.ApplyRuleAction {
        constructor(style: CssCascade.ElementStyle, specificity: number);
        apply(cascadeInstance: CssCascade.CascadeInstance): void;
    }
    function mergeInPageRule(context: Exprs.Context, target: CssCascade.ElementStyle, style: CssCascade.ElementStyle, specificity: number, cascadeInstance: CssCascade.CascadeInstance): void;
    class PageParserHandler extends CssCascade.CascadeParserHandler implements CssValidator.PropertyReceiver {
        private readonly pageProps;
        private currentPageSelectors;
        private currentNamedPageSelector;
        private currentPseudoPageClassSelectors;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, parent: CssCascade.CascadeParserHandler, validatorSet: CssValidator.ValidatorSet, pageProps: {
            [key: string]: CssCascade.ElementStyle;
        });
        startPageRule(): void;
        tagSelector(ns: string | null, name: string | null): void;
        pseudoclassSelector(name: string, params: (number | string)[]): void;
        private finishSelector;
        nextSelector(): void;
        startRuleBody(): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
        insertNonPrimary(action: CssCascade.CascadeAction): void;
        makeApplyRuleAction(specificity: number): CssCascade.ApplyRuleAction;
        startPageMarginBoxRule(name: string): void;
    }
    class PageMarginBoxParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
        readonly validatorSet: CssValidator.ValidatorSet;
        readonly boxStyle: CssCascade.ElementStyle;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, validatorSet: CssValidator.ValidatorSet, boxStyle: CssCascade.ElementStyle);
        property(name: string, value: Css.Val, important: boolean): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        unknownProperty(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
}
declare namespace PageMaster {
    let keyCount: number;
    abstract class PageBox<I extends PageBoxInstance = PageBoxInstance<any>> {
        readonly name: string | null;
        readonly pseudoName: string | null;
        readonly classes: string[];
        readonly parent: PageBox;
        specified: CssCascade.ElementStyle;
        children: PageBox[];
        pageMaster: PageMaster;
        index: number;
        key: string;
        protected _scope: Exprs.LexicalScope;
        get scope(): Exprs.LexicalScope;
        constructor(scope: Exprs.LexicalScope, name: string | null, pseudoName: string | null, classes: string[], parent: PageBox);
        createInstance(parentInstance: PageBoxInstance): PageBoxInstance;
        clone(param: {
            parent?: PageBox;
            pseudoName?: string;
        }): PageBox<I>;
        copySpecified(dest: PageBox): void;
        cloneChildren(parent: PageBox): void;
    }
    class RootPageBox extends PageBox<RootPageBoxInstance> {
        constructor(scope: Exprs.LexicalScope);
    }
    class PageMasterScope extends Exprs.LexicalScope {
        pageMaster: PageMaster;
        constructor(scope: Exprs.LexicalScope, pageMaster: PageMaster);
    }
    class PageMaster<I extends PageMasterInstance = PageMasterInstance<any>> extends PageBox<I> {
        readonly condition: Exprs.Val;
        readonly specificity: number;
        pageMaster: PageMaster;
        keyMap: {
            [key: string]: string;
        };
        constructor(scope: Exprs.LexicalScope, name: string | null, pseudoName: string | null, classes: string[], parent: RootPageBox, condition: Exprs.Val, specificity: number);
        createInstance(parentInstance: any): PageBoxInstance;
        clone(param: any): PageMaster;
        resetScope(): void;
    }
    class PartitionGroup extends PageBox<PartitionGroupInstance> {
        pageMaster: PageMaster;
        constructor(scope: Exprs.LexicalScope, name: string | null, pseudoName: string | null, classes: string[], parent: PageBox);
        createInstance(parentInstance: PageBoxInstance): PageBoxInstance;
        clone(param: any): PartitionGroup;
    }
    class Partition<I extends PartitionInstance = PartitionInstance> extends PageBox<I> {
        pageMaster: PageMaster;
        constructor(scope: Exprs.LexicalScope, name: string | null, pseudoName: string | null, classes: string[], parent: PageBox);
        createInstance(parentInstance: any): PageBoxInstance;
        clone(param: any): Partition;
    }
    function toExprIdent(scope: Exprs.LexicalScope, val: Css.Val, def: string): Exprs.Val;
    function toExprAuto(scope: Exprs.LexicalScope, val: Css.Val, ref: Exprs.Val): Exprs.Val;
    function toExprNormal(scope: Exprs.LexicalScope, val: Css.Val, ref: Exprs.Val): Exprs.Val;
    function toExprZero(scope: Exprs.LexicalScope, val: Css.Val, ref: Exprs.Val): Exprs.Val;
    function toExprZeroAuto(scope: Exprs.LexicalScope, val: Css.Val, ref: Exprs.Val): Exprs.Val;
    function toExprZeroBorder(scope: Exprs.LexicalScope, val: Css.Val, styleVal: Css.Val, ref: Exprs.Val): Exprs.Val;
    function toExprBool(scope: Exprs.LexicalScope, val: Css.Val, def: Exprs.Val): Exprs.Val;
    interface InstanceHolder extends Exprs.Context {
        registerInstance(key: string, instance: PageBoxInstance): void;
        lookupInstance(key: string): PageBoxInstance;
    }
    class PageBoxInstance<P extends PageBox = PageBox<any>> {
        readonly parentInstance: PageBoxInstance;
        readonly pageBox: P;
        protected cascaded: CssCascade.ElementStyle;
        style: {
            [key: string]: Css.Val;
        };
        private autoWidth;
        private autoHeight;
        children: PageBoxInstance[];
        isAutoWidth: boolean;
        isAutoHeight: boolean;
        isTopDependentOnAutoHeight: boolean;
        isRightDependentOnAutoWidth: boolean;
        private calculatedWidth;
        private calculatedHeight;
        pageMasterInstance: PageMasterInstance;
        namedValues: {
            [key: string]: Exprs.Val;
        };
        namedFuncs: {
            [key: string]: Exprs.Val;
        };
        vertical: boolean;
        rtl: boolean;
        suppressEmptyBoxGeneration: boolean;
        constructor(parentInstance: PageBoxInstance, pageBox: P);
        reset(): void;
        private addNamedValues;
        resolveName(name: string): Exprs.Val;
        resolveFunc(name: any): Exprs.Val;
        private initEnabled;
        boxSpecificEnabled(enabled: Exprs.Val): Exprs.Val;
        initHorizontal(): void;
        initVertical(): void;
        private initColumns;
        private depends;
        private init;
        getProp(context: Exprs.Context, name: string): Css.Val;
        getPropAsNumber(context: Exprs.Context, name: string): number;
        getSpecial(context: Exprs.Context, name: string): Css.Val[];
        getActiveRegions(context: Exprs.Context): string[];
        propagateProperty(context: Exprs.Context, container: Vtree_$0.Container, name: string, docFaces: Font.DocumentFaces): void;
        propagatePropertyToElement(context: Exprs.Context, element: Element, name: string, docFaces: Font.DocumentFaces): void;
        propagateDelayedProperty(context: Exprs.Context, container: Vtree_$0.Container, name: string, delayedItems: Vtree_$0.DelayedItem[]): void;
        assignLeftPosition(context: Exprs.Context, container: Vtree_$0.Container): void;
        assignRightPosition(context: Exprs.Context, container: Vtree_$0.Container): void;
        assignTopPosition(context: Exprs.Context, container: Vtree_$0.Container): void;
        assignBottomPosition(context: Exprs.Context, container: Vtree_$0.Container): void;
        assignBeforePosition(context: Exprs.Context, container: Vtree_$0.Container): void;
        assignAfterPosition(context: Exprs.Context, container: Vtree_$0.Container): void;
        assignStartEndPosition(context: Exprs.Context, container: Vtree_$0.Container): void;
        sizeWithMaxHeight(context: Exprs.Context, container: Vtree_$0.Container): void;
        sizeWithMaxWidth(context: Exprs.Context, container: Vtree_$0.Container): void;
        prepareContainer(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, docFaces: Font.DocumentFaces, clientLayout: Vtree_$0.ClientLayout): void;
        transferContentProps(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, docFaces: Font.DocumentFaces): void;
        transferSinglUriContentProps(context: Exprs.Context, element: Element, docFaces: Font.DocumentFaces): void;
        finishContainer(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, column: Vtree_$0.Container, columnCount: number, clientLayout: Vtree_$0.ClientLayout, docFaces: Font.DocumentFaces): void;
        applyCascadeAndInit(cascade: CssCascade.CascadeInstance, docElementStyle: CssCascade.ElementStyle): void;
        resolveAutoSizing(context: Exprs.Context): void;
    }
    const passPreProperties: string[];
    const passPostProperties: string[];
    const passContentProperties: string[];
    const passSingleUriContentProperties: string[];
    const delayedProperties: string[];
    const userAgentPageMasterPseudo = "background-host";
    class RootPageBoxInstance extends PageBoxInstance<RootPageBox> {
        constructor(pageBox: RootPageBox);
        applyCascadeAndInit(cascade: CssCascade.CascadeInstance, docElementStyle: CssCascade.ElementStyle): void;
    }
    class PageMasterInstance<P extends PageMaster = PageMaster<PageMasterInstance<any>>> extends PageBoxInstance<P> {
        pageMasterInstance: PageMasterInstance;
        constructor(parentInstance: PageBoxInstance, pageBox: P);
        boxSpecificEnabled(enabled: Exprs.Val): Exprs.Val;
        adjustPageLayout(context: Exprs.Context, page: Vtree_$0.Page, clientLayout: Vtree_$0.ClientLayout): void;
    }
    class PartitionGroupInstance extends PageBoxInstance<PartitionGroup> {
        pageMasterInstance: PageMasterInstance;
        constructor(parentInstance: PageBoxInstance, pageBox: PageBox);
    }
    class PartitionInstance<P extends Partition = Partition<PartitionInstance<any>>> extends PageBoxInstance<P> {
        pageMasterInstance: PageMasterInstance;
        constructor(parentInstance: PageBoxInstance, pageBox: P);
        processPartitionList(enabled: Exprs.Val, listVal: Css.Val, conflicting: boolean): Exprs.Val;
        boxSpecificEnabled(enabled: Exprs.Val): Exprs.Val;
        prepareContainer(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, docFaces: Font.DocumentFaces, clientLayout: Vtree_$0.ClientLayout): void;
    }
    class PageBoxParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
        readonly target: PageBox;
        readonly validatorSet: CssValidator.ValidatorSet;
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, target: PageBox, validatorSet: CssValidator.ValidatorSet);
        property(name: string, value: Css.Val, important: boolean): void;
        unknownProperty(name: string, value: Css.Val): void;
        invalidPropertyValue(name: string, value: Css.Val): void;
        simpleProperty(name: string, value: Css.Val, important: any): void;
    }
    class PartitionParserHandler extends PageBoxParserHandler {
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, target: Partition, validatorSet: CssValidator.ValidatorSet);
    }
    class PartitionGroupParserHandler extends PageBoxParserHandler {
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, target: PartitionGroup, validatorSet: CssValidator.ValidatorSet);
        startPartitionRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionGroupRule(name: string | null, pseudoName: string | null, classes: string[]): void;
    }
    class PageMasterParserHandler extends PageBoxParserHandler {
        constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, target: PageMaster, validatorSet: CssValidator.ValidatorSet);
        startPartitionRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startPartitionGroupRule(name: string | null, pseudoName: string | null, classes: string[]): void;
    }
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
declare namespace TaskUtil {
    class Fetcher<T> {
        readonly fetch: () => Task.Result<T>;
        name: string;
        arrived: boolean;
        resource: T;
        task: Task.Task;
        piggybacks: ((p1: any) => void)[] | null;
        constructor(fetch: () => Task.Result<T>, opt_name?: string);
        start(): void;
        piggyback(fn: (p1: T) => void): void;
        get(): Task.Result<T>;
        hasArrived(): boolean;
    }
    const waitForFetchers: <T>(fetchers: Fetcher<T>[]) => Task.Result<boolean>;
    function loadElement(elem: Element, src: string): Fetcher<string>;
}
declare namespace Vgen {
    const frontEdgeBlackListHor: {
        [key: string]: string;
    };
    const frontEdgeBlackListVert: {
        [key: string]: string;
    };
    const frontEdgeUnforcedBreakBlackListHor: {
        [key: string]: string;
    };
    const frontEdgeUnforcedBreakBlackListVert: {
        [key: string]: string;
    };
    type CustomRenderer = (p1: Element, p2: Element, p3: {
        [key: string]: Css.Val;
    }) => Task.Result<Element>;
    interface CustomRendererFactory {
        makeCustomRenderer(xmldoc: XmlDoc.XMLDocHolder): CustomRenderer;
    }
    function initIFrame(iframe: HTMLIFrameElement): void;
    interface StylerProducer {
        getStylerForDoc(xmldoc: XmlDoc.XMLDocHolder): CssStyler_$0.AbstractStyler;
    }
    class ViewFactory extends Base.SimpleEventTarget implements Vtree_$0.LayoutContext {
        readonly flowName: string;
        readonly context: Exprs.Context;
        readonly viewport: Viewport;
        readonly styler: CssStyler_$0.Styler;
        readonly regionIds: string[];
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly docFaces: Font.DocumentFaces;
        readonly footnoteStyle: CssCascade_$0.ElementStyle;
        readonly stylerProducer: StylerProducer;
        readonly page: Vtree_$0.Page;
        readonly customRenderer: CustomRenderer;
        readonly fallbackMap: {
            [key: string]: string;
        };
        readonly documentURLTransformer: Base.DocumentURLTransformer;
        private static SVG_URL_ATTRIBUTES;
        document: Document;
        exprContentListener: Vtree_$0.ExprContentListener;
        nodeContext: Vtree_$0.NodeContext | null;
        viewRoot: Element | null;
        isFootnote: boolean;
        sourceNode: Node | null;
        offsetInNode: number;
        viewNode: Node | null;
        constructor(flowName: string, context: Exprs.Context, viewport: Viewport, styler: CssStyler_$0.Styler, regionIds: string[], xmldoc: XmlDoc.XMLDocHolder, docFaces: Font.DocumentFaces, footnoteStyle: CssCascade_$0.ElementStyle, stylerProducer: StylerProducer, page: Vtree_$0.Page, customRenderer: CustomRenderer, fallbackMap: {
            [key: string]: string;
        }, documentURLTransformer: Base.DocumentURLTransformer);
        clone(): Vtree_$0.LayoutContext;
        createPseudoelementShadow(element: Element, isRoot: boolean, cascStyle: CssCascade_$0.ElementStyle, computedStyle: {
            [key: string]: Css.Val;
        }, styler: CssStyler_$0.AbstractStyler, context: Exprs.Context, parentShadow: Vtree_$0.ShadowContext, subShadow: Vtree_$0.ShadowContext): Vtree_$0.ShadowContext;
        getPseudoMap(cascStyle: CssCascade_$0.ElementStyle, regionIds: string[], isFootnote: boolean, nodeContext: Vtree_$0.NodeContext, context: Exprs.Context): {};
        createRefShadow(href: string, type: Vtree_$0.ShadowType, element: Element, parentShadow: Vtree_$0.ShadowContext, subShadow: Vtree_$0.ShadowContext): Task.Result<Vtree_$0.ShadowContext>;
        createShadows(element: Element, isRoot: any, cascStyle: CssCascade_$0.ElementStyle, computedStyle: {
            [key: string]: Css.Val;
        }, styler: CssStyler_$0.AbstractStyler, context: Exprs.Context, shadowContext: Vtree_$0.ShadowContext): Task.Result<Vtree_$0.ShadowContext>;
        setViewRoot(viewRoot: Element, isFootnote: boolean): void;
        computeStyle(vertical: boolean, rtl: boolean, style: CssCascade_$0.ElementStyle, computedStyle: {
            [key: string]: Css.Val;
        }): boolean;
        private inheritFromSourceParent;
        resolveURL(url: string): string;
        inheritLangAttribute(): void;
        transferPolyfilledInheritedProps(computedStyle: {
            [key: string]: Css.Val;
        }): void;
        resolveFormattingContext(nodeContext: Vtree_$0.NodeContext, firstTime: boolean, display: Css.Ident, position: Css.Ident, float: Css.Ident, isRoot: boolean): void;
        private createElementView;
        private processAfterIfcontinues;
        isSVGUrlAttribute(attributeName: string): boolean;
        modifyElemDimensionWithImageResolution(images: {
            image: HTMLElement;
            element: HTMLElement;
            fetcher: TaskUtil.Fetcher<string>;
        }[], imageResolution: number, computedStyle: {
            [key: string]: Css.Val;
        }, isVertical: boolean): void;
        private preprocessElementStyle;
        private findAndProcessRepeatingElements;
        private processRepeatOnBreak;
        private createTextNodeView;
        private preprocessTextContent;
        createNodeView(firstTime: boolean, atUnforcedBreak: boolean): Task.Result<boolean>;
        setCurrent(nodeContext: Vtree_$0.NodeContext, firstTime: boolean, atUnforcedBreak?: boolean): Task.Result<boolean>;
        processShadowContent(pos: Vtree_$0.NodeContext): Vtree_$0.NodeContext;
        private nextPositionInTree;
        isTransclusion(element: Element, elementStyle: CssCascade_$0.ElementStyle, transclusionType: string | null): boolean;
        nextInTree(position: Vtree_$0.NodeContext, atUnforcedBreak?: boolean): Task.Result<Vtree_$0.NodeContext>;
        addImageFetchers(bg: Css.Val): void;
        applyComputedStyles(target: Element, computedStyle: {
            [key: string]: Css.Val;
        }): void;
        applyPseudoelementStyle(nodeContext: Vtree_$0.NodeContext, pseudoName: string, target: Element): void;
        peelOff(nodeContext: Vtree_$0.NodeContext, nodeOffset: number): Task.Result<Vtree_$0.NodeContext>;
        createElement(ns: string, tag: string): Element;
        applyFootnoteStyle(vertical: boolean, rtl: boolean, target: Element): boolean;
        processFragmentedBlockEdge(nodeContext: Vtree_$0.NodeContext): void;
        convertLengthToPx(numeric: Css.Numeric, viewNode: Node, clientLayout: Vtree_$0.ClientLayout): number | Css.Numeric;
        isSameNodePositionStep(step1: Vtree_$0.NodePositionStep, step2: Vtree_$0.NodePositionStep): boolean;
        isSameNodePosition(nodePosition1: Vtree_$0.NodePosition, nodePosition2: Vtree_$0.NodePosition): boolean;
        isPseudoelement(elem: any): boolean;
    }
    const fb2Remap: {
        a: string;
        sub: string;
        sup: string;
        table: string;
        tr: string;
        td: string;
        th: string;
        code: string;
        body: string;
        p: string;
        v: string;
        date: string;
        emphasis: string;
        strong: string;
        style: string;
        strikethrough: string;
    };
    const propertiesNotPassedToDOM: {
        "box-decoration-break": boolean;
        "float-min-wrap-block": boolean;
        "float-reference": boolean;
        "flow-into": boolean;
        "flow-linger": boolean;
        "flow-options": boolean;
        "flow-priority": boolean;
        "footnote-policy": boolean;
        page: boolean;
    };
    class DefaultClientLayout implements Vtree_$0.ClientLayout {
        layoutBox: Element;
        window: Window;
        constructor(viewport: Viewport);
        private subtractOffsets;
        getRangeClientRects(range: Range): ClientRect[];
        getElementClientRect(element: Element): ClientRect;
        getElementComputedStyle(element: Element): CSSStyleDeclaration;
    }
    class Viewport {
        readonly window: Window;
        readonly fontSize: number;
        document: Document;
        root: HTMLElement;
        private outerZoomBox;
        contentContainer: HTMLElement;
        layoutBox: Element;
        width: number;
        height: number;
        constructor(window: Window, fontSize: number, opt_root?: HTMLElement, opt_width?: number, opt_height?: number);
        resetZoom(): void;
        zoom(width: number, height: number, scale: number): void;
        clear(): void;
    }
}
declare namespace Vtree_$0 {
    const delayedProps: {
        transform: boolean;
        "transform-origin": boolean;
    };
    const delayedPropsIfRelativePositioned: {
        top: boolean;
        bottom: boolean;
        left: boolean;
        right: boolean;
    };
    class DelayedItem {
        target: Element;
        name: string;
        value: Css.Val;
        constructor(target: Element, name: string, value: Css.Val);
    }
    type PageHyperlinkEvent = {
        type: string;
        target: any;
        currentTarget: any;
        anchorElement: Element;
        href: string;
    };
    type Trigger = {
        observer: string;
        event: string;
        action: string;
        ref: string;
    };
    const actions: {
        show: (obj: any) => void;
        hide: (obj: any) => void;
        play: (obj: any) => void;
        pause: (obj: any) => void;
        resume: (obj: any) => void;
        mute: (obj: any) => void;
        unmute: (obj: any) => void;
    };
    function makeListener(refs: Element[], action: string): EventListener | null;
    class Page extends Base.SimpleEventTarget {
        readonly container: HTMLElement;
        readonly bleedBox: HTMLElement;
        private static AUTO_PAGE_WIDTH_ATTRIBUTE;
        private static AUTO_PAGE_HEIGHT_ATTRIBUTE;
        pageAreaElement: HTMLElement | null;
        delayedItems: DelayedItem[];
        hrefHandler: (e: Event) => void;
        elementsById: {
            [key: string]: Element[];
        };
        dimensions: {
            width: number;
            height: number;
        };
        isFirstPage: boolean;
        isLastPage: boolean;
        isAutoPageWidth: boolean;
        isAutoPageHeight: boolean;
        spineIndex: number;
        position: LayoutPosition;
        offset: number;
        side: Constants.PageSide | null;
        fetchers: TaskUtil.Fetcher<{}>[];
        marginBoxes: {
            top: {
                [key: string]: Container_$0;
            };
            bottom: {
                [key: string]: Container_$0;
            };
            left: {
                [key: string]: Container_$0;
            };
            right: {
                [key: string]: Container_$0;
            };
        };
        constructor(container: HTMLElement, bleedBox: HTMLElement);
        setAutoPageWidth(isAuto: boolean): void;
        setAutoPageHeight(isAuto: boolean): void;
        registerElementWithId(element: Element, id: string): void;
        finish(triggers: Trigger[], clientLayout: ClientLayout_$0): void;
        zoom(scale: number): void;
        getPageAreaElement(): HTMLElement;
    }
    type Spread = {
        left: Page;
        right: Page;
    };
    const SPECIAL_ATTR = "data-adapt-spec";
    const Whitespace_$0: typeof Vtree.Whitespace_$0;
    type Whitespace_$0 = Vtree.Whitespace_$0;
    function whitespaceFromPropertyValue(whitespace: string): Whitespace_$0 | null;
    function canIgnore(node: Node, whitespace: Whitespace_$0): boolean;
    class Flow {
        readonly flowName: string;
        readonly parentFlowName: string | null;
        forcedBreakOffsets: number[];
        formattingContext: FormattingContext_$0 | null;
        constructor(flowName: string, parentFlowName: string | null);
    }
    class FlowChunk {
        flowName: string;
        element: Element;
        startOffset: number;
        priority: number;
        linger: number;
        exclusive: boolean;
        repeated: boolean;
        last: boolean;
        breakBefore: string | null;
        startPage: number;
        constructor(flowName: string, element: Element, startOffset: number, priority: number, linger: number, exclusive: boolean, repeated: boolean, last: boolean, breakBefore: string | null);
        isBetter(other: FlowChunk): boolean;
    }
    type ClientRect_$0 = Vtree.ClientRect_$0;
    function clientrectIncreasingTop(r1: ClientRect_$0, r2: ClientRect_$0): number;
    function clientrectDecreasingRight(r1: ClientRect_$0, r2: ClientRect_$0): number;
    type ClientLayout_$0 = Vtree.ClientLayout_$0;
    type LayoutContext_$0 = Vtree.LayoutContext_$0;
    type FormattingContext_$0 = Vtree.FormattingContext_$0;
    function eachAncestorFormattingContext(nodeContext: NodeContext_$0, callback: (p1: FormattingContext_$0) => any): void;
    type NodePositionStep_$0 = Vtree.NodePositionStep_$0;
    function isSameNodePositionStep(nps1: NodePositionStep_$0, nps2: NodePositionStep_$0): boolean;
    type NodePosition_$0 = Vtree.NodePosition_$0;
    function isSameNodePosition(np1: NodePosition_$0 | null, np2: NodePosition_$0 | null): boolean;
    function newNodePositionFromNode(node: Node): NodePosition_$0;
    function newNodePositionFromNodeContext(nodeContext: Vtree.NodeContext_$0, initialFragmentIndex: number | null): NodePosition_$0;
    function makeNodeContextFromNodePositionStep(step: NodePositionStep_$0, parent: Vtree.NodeContext_$0): NodeContext_$0;
    const ShadowType_$0: typeof Vtree.ShadowType_$0;
    type ShadowType_$0 = Vtree.ShadowType_$0;
    class ShadowContext_$0 implements Vtree.ShadowContext_$0 {
        readonly owner: Element;
        readonly root: Element;
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly parentShadow: ShadowContext_$0;
        readonly type: ShadowType_$0;
        readonly styler: object;
        subShadow: ShadowContext_$0;
        constructor(owner: Element, root: Element, xmldoc: XmlDoc.XMLDocHolder, parentShadow: ShadowContext_$0, superShadow: ShadowContext_$0, type: ShadowType_$0, styler: object);
        equals(other: ShadowContext_$0): boolean;
    }
    function isSameShadowContext(sc1: ShadowContext_$0, sc2: ShadowContext_$0): boolean;
    class FirstPseudo_$0 implements Vtree.FirstPseudo_$0 {
        readonly outer: FirstPseudo_$0;
        readonly count: number;
        constructor(outer: FirstPseudo_$0, count: number);
    }
    class NodeContext_$0 implements Vtree.NodeContext_$0 {
        sourceNode: Node;
        parent: NodeContext_$0;
        boxOffset: number;
        offsetInNode: number;
        after: boolean;
        shadowType: ShadowType_$0;
        shadowContext: ShadowContext_$0;
        nodeShadow: ShadowContext_$0;
        shadowSibling: NodeContext_$0;
        shared: boolean;
        inline: boolean;
        overflow: boolean;
        breakPenalty: number;
        display: string | null;
        floatReference: PageFloats.FloatReference;
        floatSide: string | null;
        clearSide: string | null;
        floatMinWrapBlock: Css.Numeric | null;
        columnSpan: Css.Val | null;
        verticalAlign: string;
        captionSide: string;
        inlineBorderSpacing: number;
        blockBorderSpacing: number;
        flexContainer: boolean;
        whitespace: Whitespace_$0;
        hyphenateCharacter: string | null;
        breakWord: boolean;
        establishesBFC: boolean;
        containingBlockForAbsolute: boolean;
        breakBefore: string | null;
        breakAfter: string | null;
        viewNode: Node;
        clearSpacer: Node;
        inheritedProps: {
            [key: string]: number | string | Css.Val;
        };
        vertical: boolean;
        direction: string;
        firstPseudo: FirstPseudo_$0;
        lang: string | null;
        preprocessedTextContent: Diff.Change[] | null;
        formattingContext: FormattingContext_$0;
        repeatOnBreak: string | null;
        pluginProps: {
            [key: string]: string | number | undefined | null | (number | null)[];
        };
        fragmentIndex: number;
        afterIfContinues: Selectors.AfterIfContinues;
        footnotePolicy: Css.Ident | null;
        constructor(sourceNode: Node, parent: NodeContext_$0, boxOffset: number);
        resetView(): void;
        private cloneItem;
        modify(): NodeContext_$0;
        copy(): NodeContext_$0;
        clone(): NodeContext_$0;
        toNodePositionStep(): NodePositionStep_$0;
        toNodePosition(): NodePosition_$0;
        isInsideBFC(): boolean;
        getContainingBlockForAbsolute(): NodeContext_$0;
        walkUpBlocks(callback: (p1: NodeContext_$0) => any): void;
        belongsTo(formattingContext: FormattingContext_$0): boolean;
    }
    class ChunkPosition_$0 implements Vtree.ChunkPosition_$0 {
        primary: NodePosition_$0;
        floats: NodePosition_$0[];
        constructor(primary: NodePosition_$0);
        clone(): ChunkPosition_$0;
        isSamePosition(other: ChunkPosition_$0): boolean;
    }
    class FlowChunkPosition {
        chunkPosition: ChunkPosition_$0;
        readonly flowChunk: FlowChunk;
        constructor(chunkPosition: ChunkPosition_$0, flowChunk: FlowChunk);
        clone(): FlowChunkPosition;
        isSamePosition(other: FlowChunkPosition): boolean;
    }
    class FlowPosition {
        positions: FlowChunkPosition[];
        startSide: string;
        breakAfter: string | null;
        clone(): FlowPosition;
        isSamePosition(other: FlowPosition): boolean;
        hasContent(offset: number): boolean;
    }
    class LayoutPosition {
        page: number;
        flows: {
            [key: string]: Flow;
        };
        flowPositions: {
            [key: string]: FlowPosition;
        };
        highestSeenOffset: number;
        highestSeenNode: Node;
        lookupPositionOffset: number;
        clone(): LayoutPosition;
        isSamePosition(other: LayoutPosition): boolean;
        hasContent(name: string, offset: number): boolean;
        startSideOfFlow(name: string): string;
        firstFlowChunkOfFlow(name: string): FlowChunk | null;
    }
    class Container_$0 implements Vtree.Container_$0 {
        element: Element;
        left: number;
        top: number;
        marginLeft: number;
        marginRight: number;
        marginTop: number;
        marginBottom: number;
        borderLeft: number;
        borderRight: number;
        borderTop: number;
        borderBottom: number;
        paddingLeft: number;
        paddingRight: number;
        paddingTop: number;
        paddingBottom: number;
        width: number;
        height: number;
        originX: number;
        originY: number;
        exclusions: GeometryUtil.Shape[];
        innerShape: GeometryUtil.Shape;
        computedBlockSize: number;
        snapWidth: number;
        snapHeight: number;
        snapOffsetX: number;
        snapOffsetY: number;
        vertical: boolean;
        constructor(element: Element);
        getInsetTop(): number;
        getInsetBottom(): number;
        getInsetLeft(): number;
        getInsetRight(): number;
        getInsetBefore(): number;
        getInsetAfter(): number;
        getInsetStart(): number;
        getInsetEnd(): number;
        getBeforeEdge(box: ClientRect_$0): number;
        getAfterEdge(box: ClientRect_$0): number;
        getStartEdge(box: ClientRect_$0): number;
        getEndEdge(box: ClientRect_$0): number;
        getInlineSize(box: ClientRect_$0): number;
        getBoxSize(box: ClientRect_$0): number;
        getBoxDir(): number;
        getInlineDir(): number;
        copyFrom(other: Container_$0): void;
        setVerticalPosition(top: number, height: number): void;
        setHorizontalPosition(left: number, width: number): void;
        setBlockPosition(start: number, extent: number): void;
        setInlinePosition(start: number, extent: number): void;
        clear(): void;
        getInnerShape(): GeometryUtil.Shape;
        getInnerRect(): GeometryUtil.Rect;
        getPaddingRect(): GeometryUtil.Rect;
        getOuterShape(outerShapeProp: Css.Val, context: Exprs.Context): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
    }
    type ExprContentListener_$0 = Vtree.ExprContentListener_$0;
    class ContentPropertyHandler extends Css.Visitor {
        readonly elem: Element;
        readonly context: Exprs.Context;
        readonly rootContentValue: Css.Val;
        readonly exprContentListener: ExprContentListener_$0;
        constructor(elem: Element, context: Exprs.Context, rootContentValue: Css.Val, exprContentListener: ExprContentListener_$0);
        private visitStrInner;
        visitStr(str: Css.Str): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function nonTrivialContent(val: Css.Val): boolean;
}
declare namespace XmlDoc_$0 {
    type XMLDocStore_$0 = XmlDoc.XMLDocStore_$0;
    const ELEMENT_OFFSET_ATTR = "data-adapt-eloff";
    class XMLDocHolder_$0 implements XmlDoc.XMLDocHolder_$0 {
        readonly store: XMLDocStore_$0;
        readonly url: string;
        readonly document: Document;
        lang: string | null;
        totalOffset: number;
        root: Element;
        body: Element;
        head: Element;
        last: Element;
        lastOffset: number;
        idMap: {
            [key: string]: Element;
        };
        constructor(store: XMLDocStore_$0, url: string, document: Document);
        doc(): XmlDoc.NodeList_$0;
        getElementOffset(element: Element): number;
        getNodeOffset(srcNode: Node, offsetInNode: number, after: boolean): number;
        getTotalOffset(): number;
        getNodeByOffset(offset: number): Node;
        private buildIdMap;
        getElement(url: string): Element | null;
    }
    enum DOMParserSupportedType {
        TEXT_HTML = "text/html",
        TEXT_XML = "text/xml",
        APPLICATION_XML = "application/xml",
        APPLICATION_XHTML_XML = "application/xhtml_xml",
        IMAGE_SVG_XML = "image/svg+xml"
    }
    function parseAndReturnNullIfError(str: string, type: string, opt_parser?: DOMParser): Document | null;
    function resolveContentType(response: Net_$0.Response): string | null;
    function parseXMLResource(response: Net_$0.Response, store: XMLDocStore_$0): Task.Result<XmlDoc.XMLDocHolder_$0>;
    function newXMLDocStore(): XMLDocStore_$0;
    class Predicate_$0 implements XmlDoc.Predicate_$0 {
        readonly fn: (p1: Node) => boolean;
        constructor(fn: (p1: Node) => boolean);
        check(node: Node): boolean;
        withAttribute(name: string, value: string): Predicate_$0;
        withChild(name: string, opt_childPredicate?: Predicate_$0): Predicate_$0;
    }
    const predicate: Predicate_$0;
    class NodeList_$0 implements XmlDoc.NodeList_$0 {
        readonly nodes: Node[];
        constructor(nodes: Node[]);
        asArray(): Node[];
        size(): number;
        predicate(pr: Predicate_$0): NodeList_$0;
        forEachNode(fn: (p1: Node, p2: (p1: Node) => void) => void): NodeList_$0;
        forEach<T>(fn: (p1: Node) => T): T[];
        forEachNonNull<T>(fn: (p1: Node) => T): T[];
        child(tag: string): NodeList_$0;
        childElements(): NodeList_$0;
        attribute(name: string): (string | null)[];
        textContent(): (string | null)[];
    }
}
type LayoutType = Layout;
declare namespace Base {
    let emptyObj: {};
    type JSON = any;
    function jsonToString(json: JSON): string;
    function stringToJSON(str: string): JSON;
    function stripFragment(url: string): string;
    function stripFragmentAndQuery(url: string): string;
    let baseURL: string;
    function setBaseURL(value: string): void;
    let resourceBaseURL: string;
    function setResourceBaseURL(value: string): void;
    function resolveURL(relURL: string, baseURL: string): string;
    function convertSpecialURL(url: string): string;
    interface DocumentURLTransformer {
        transformFragment(fragment: string, baseURL: string): string;
        transformURL(url: string, baseURL: string): string;
        restoreURL(encoded: string): string[];
    }
    enum NS {
        FB2 = "http://www.gribuser.ru/xml/fictionbook/2.0",
        epub = "http://www.idpf.org/2007/ops",
        EV = "http://www.w3.org/2001/xml-events",
        MATHML = "http://www.w3.org/1998/Math/MathML",
        XML = "http://www.w3.org/XML/1998/namespace",
        XHTML = "http://www.w3.org/1999/xhtml",
        XLINK = "http://www.w3.org/1999/xlink",
        SHADOW = "http://www.pyroxy.com/ns/shadow",
        SVG = "http://www.w3.org/2000/svg",
        DC = "http://purl.org/dc/elements/1.1/",
        NCX = "http://www.daisy.org/z3986/2005/ncx/",
        SSE = "http://example.com/sse"
    }
    function getURLParam(name: string, opt_url?: string): string | null;
    function setURLParam(url: string, name: string, value: string): string;
    function asString(v: any): any;
    interface Comparable {
        compare(other: Comparable): number;
    }
    class PriorityQueue {
        queue: Comparable[];
        length(): number;
        add(item: Comparable): void;
        peek(): Comparable;
        remove(): Comparable;
    }
    function cssToJSProp(prefix: string, cssPropName: string): string;
    const knownPrefixes: string[];
    const propNameMap: {};
    function checkIfPropertySupported(prefix: string, prop: string): boolean;
    function getPrefixedPropertyNames(prop: string): string[] | null;
    function setCSSProperty(elem: Element, prop: string, value: string): void;
    function getCSSProperty(elem: Element, prop: string, opt_value?: string): string;
    function getLangAttribute(element: Element): string;
    class StringBuffer {
        list: string[];
        append(str: string): StringBuffer;
        clear(): void;
        toString(): string;
    }
    function escapeChar(str: string): string;
    function escapeCSSIdent(name: string): string;
    function escapeCSSStr(str: string): string;
    function lightURLEncode(str: string): string;
    function isLetter(ch: string): boolean;
    function escapeCharToHex(str: string, prefix?: string): string;
    function escapeNameStrToHex(str: string, prefix?: string): string;
    function escapeRegExp(str: string): string;
    function unescapeCharFromHex(str: string, prefix?: string): string;
    function unescapeStrFromHex(str: string, prefix?: string): string;
    function binarySearch(high: number, good: (p1: number) => boolean): number;
    function numberCompare(a: number, b: number): number;
    const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    function appendBase64(sb: StringBuffer, data: string): void;
    function indexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T;
    };
    function arrayToSet(arr: string[]): {
        [key: string]: boolean;
    };
    function multiIndexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T[];
    };
    function mapObj<P, R>(obj: {
        [key: string]: P;
    }, fn: (p1: P, p2: string) => R): {
        [key: string]: R;
    };
    function mapSize(obj: object): number;
    type Event = {
        type: string;
        target?: any;
        currentTarget?: any;
        preventDefault?: any;
        newPage?: any;
        anchorElement?: any;
        href?: any;
        content?: any;
    };
    type EventListener = (p1: Event) => void;
    class SimpleEventTarget {
        listeners: {
            [key: string]: EventListener[];
        };
        dispatchEvent(evt: Event): void;
        addEventListener(type: string, listener: EventListener, capture?: boolean): void;
        removeEventListener(type: string, listener: EventListener, capture?: boolean): void;
    }
    type EventTarget = SimpleEventTarget;
    let hasLShapeFloatBug: boolean | null;
    function checkLShapeFloatBug(body: HTMLElement): boolean;
    let hasVerticalBBoxBug: boolean | null;
    function checkVerticalBBoxBug(body: HTMLElement): boolean;
    let hasInlineBlockJustificationBug: boolean | null;
    function checkInlineBlockJustificationBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityAfterHyphenBug: boolean | null;
    function checkSoftWrapOpportunityAfterHyphenBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityByWbrBug: boolean | null;
    function checkSoftWrapOpportunityByWbrBug(body: HTMLElement): boolean;
}
declare namespace Counters {
    class TargetCounterReference {
        readonly targetId: string;
        resolved: boolean;
        pageCounters: CssCascade_$0.CounterValues;
        spineIndex: number;
        pageIndex: number;
        constructor(targetId: string, resolved: boolean);
        equals(other: TargetCounterReference): boolean;
        isResolved(): boolean;
        resolve(): void;
        unresolve(): void;
    }
    class CounterStore {
        readonly documentURLTransformer: Base.DocumentURLTransformer;
        countersById: {
            [key: string]: CssCascade_$0.CounterValues;
        };
        pageCountersById: {
            [key: string]: CssCascade_$0.CounterValues;
        };
        currentPageCounters: CssCascade_$0.CounterValues;
        previousPageCounters: CssCascade_$0.CounterValues;
        currentPageCountersStack: CssCascade_$0.CounterValues[];
        pageIndicesById: {
            [key: string]: {
                spineIndex: number;
                pageIndex: number;
            };
        };
        currentPage: Vtree_$0.Page;
        newReferencesOfCurrentPage: TargetCounterReference[];
        referencesToSolve: TargetCounterReference[];
        referencesToSolveStack: TargetCounterReference[][];
        unresolvedReferences: {
            [key: string]: TargetCounterReference[];
        };
        resolvedReferences: {
            [key: string]: TargetCounterReference[];
        };
        private pagesCounterExprs;
        constructor(documentURLTransformer: Base.DocumentURLTransformer);
        createCounterListener(baseURL: string): CssCascade_$0.CounterListener;
        createCounterResolver(baseURL: string, rootScope: Exprs.LexicalScope, pageScope: Exprs.LexicalScope): CssCascade_$0.CounterResolver;
        setCurrentPage(page: Vtree_$0.Page): void;
        private definePageCounter;
        forceSetPageCounter(pageNumber: number): void;
        updatePageCounters(cascadedPageStyle: CssCascade_$0.ElementStyle, context: Exprs.Context): void;
        pushPageCounters(counters: CssCascade_$0.CounterValues): void;
        popPageCounters(): void;
        resolveReference(id: string): void;
        saveReferenceOfCurrentPage(id: string, resolved: boolean): void;
        finishPage(spineIndex: number, pageIndex: number): void;
        getUnresolvedRefsToPage(page: Vtree_$0.Page): {
            spineIndex: number;
            pageIndex: number;
            pageCounters: CssCascade_$0.CounterValues;
            refs: TargetCounterReference[];
        }[];
        pushReferencesToSolve(refs: TargetCounterReference[]): void;
        popReferencesToSolve(): void;
        registerPageCounterExpr(name: string, format: (p1: number[]) => string, expr: Exprs.Val): void;
        getExprContentListener(): Vtree_$0.ExprContentListener;
        private exprContentListener;
        finishLastPage(viewport: Vgen.Viewport): void;
        createLayoutConstraint(pageIndex: number): Layout.LayoutConstraint;
    }
    const PAGES_COUNTER_ATTR = "data-vivliostyle-pages-counter";
}
declare namespace Exprs {
    type Preferences = {
        fontFamily: string;
        lineHeight: number;
        margin: number;
        hyphenate: boolean;
        columnWidth: number;
        horizontal: boolean;
        nightMode: boolean;
        spreadView: boolean;
        pageBorder: number;
        enabledMediaTypes: {
            [key: string]: boolean;
        };
        defaultPaperSize?: {
            [key: string]: number;
        };
    };
    function defaultPreferences(): Preferences;
    function clonePreferences(pref: Preferences): Preferences;
    const defaultPreferencesInstance: Preferences;
    const Special: {
        PENDING: Pending;
    };
    type Result = string | number | boolean | undefined;
    type PendingResult = Special | Result;
    function letterbox(viewW: number, viewH: number, objW: number, objH: number): string;
    function cssString(str: string): string;
    function cssIdent(name: string): string;
    function makeQualifiedName(objName: string | null, memberName: string): string;
    let nextKeyIndex: number;
    class LexicalScope {
        parent: LexicalScope;
        resolver?: (p1: string, p2: boolean) => Val;
        scopeKey: string;
        children: LexicalScope[];
        zero: Const;
        one: Const;
        _true: Const;
        _false: Const;
        values: {
            [key: string]: Val;
        };
        funcs: {
            [key: string]: Val;
        };
        builtIns: {
            [key: string]: (...p1: Result[]) => Result;
        };
        constructor(parent: LexicalScope, resolver?: (p1: string, p2: boolean) => Val);
        defineBuiltInName(name: string, fn: () => Result): void;
        defineName(qualifiedName: string, val: Val): void;
        defineFunc(qualifiedName: string, val: Val): void;
        defineBuiltIn(qualifiedName: string, fn: (...p1: Result[]) => Result): void;
    }
    function isAbsoluteLengthUnit(unit: string): boolean;
    function isViewportRelativeLengthUnit(unit: string): boolean;
    function isFontRelativeLengthUnit(unit: string): boolean;
    const defaultUnitSizes: {
        [key: string]: number;
    };
    function needUnitConversion(unit: string): boolean;
    type ScopeContext = {
        [key: string]: Result;
    };
    class Context {
        readonly rootScope: LexicalScope;
        readonly viewportWidth: number;
        readonly viewportHeight: number;
        protected actualPageWidth: number | null;
        pageWidth: () => number;
        protected actualPageHeight: number | null;
        pageHeight: () => number;
        initialFontSize: number;
        rootFontSize: number | null;
        fontSize: () => number;
        pref: Preferences;
        scopes: {
            [key: string]: ScopeContext;
        };
        pageAreaWidth: number | null;
        pageAreaHeight: number | null;
        pageVertical: boolean | null;
        pubTitle: string | null;
        docTitle: string | null;
        constructor(rootScope: LexicalScope, viewportWidth: number, viewportHeight: number, fontSize: number);
        private getScopeContext;
        clearScope(scope: LexicalScope): void;
        queryUnitSize(unit: string, isRoot: boolean): number;
        evalName(scope: LexicalScope, qualifiedName: string): Val;
        evalCall(scope: LexicalScope, qualifiedName: string, params: Val[], noBuiltInEval: boolean): Val;
        evalMediaName(name: string, not: boolean): boolean;
        evalMediaTest(feature: string, value: Val): boolean;
        queryVal(scope: LexicalScope, key: string): Result | undefined;
        storeVal(scope: LexicalScope, key: string, val: Result): void;
    }
    type DependencyCache = {
        [key: string]: boolean | Special;
    };
    class Val {
        scope: LexicalScope;
        key: string;
        constructor(scope: LexicalScope);
        toString(): string;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        expand(context: Context, params: Val[]): Val;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        dependOuter(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        depend(other: Val, context: Context): boolean;
        evaluate(context: Context): Result;
        isMediaName(): boolean;
    }
    class Prefix extends Val {
        val: Val;
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Infix extends Val {
        lhs: Val;
        rhs: Val;
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Logical extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Comparison extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Additive extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Multiplicative extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Not extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class Negate extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class And extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class AndMedia extends And {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Or extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class OrMedia extends Or {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Lt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Le extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Gt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ge extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Eq extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ne extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Add extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Subtract extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Multiply extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Divide extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Modulo extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Numeric extends Val {
        num: number;
        unit: string;
        constructor(scope: LexicalScope, num: number, unit: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class Named extends Val {
        qualifiedName: string;
        constructor(scope: LexicalScope, qualifiedName: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    }
    class MediaName extends Val {
        not: boolean;
        name: string;
        value: Val;
        constructor(scope: LexicalScope, not: boolean, name: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        isMediaName(): boolean;
    }
    class Native extends Val {
        fn: () => Result;
        str: string;
        constructor(scope: LexicalScope, fn: () => Result, str: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    function appendValArray(buf: Base.StringBuffer, arr: Val[]): void;
    function expandValArray(context: Context, arr: Val[], params: Val[]): Val[];
    function evalValArray(context: Context, arr: Val[]): Result[];
    class Call extends Val {
        qualifiedName: string;
        params: Val[];
        constructor(scope: LexicalScope, qualifiedName: string, params: Val[]);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Cond extends Val {
        cond: Val;
        ifTrue: Val;
        ifFalse: Val;
        constructor(scope: LexicalScope, cond: Val, ifTrue: Val, ifFalse: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Const extends Val {
        val: Result;
        constructor(scope: LexicalScope, val: Result);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class MediaTest extends Val {
        name: MediaName;
        value: Val;
        constructor(scope: LexicalScope, name: MediaName, value: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Param extends Val {
        index: number;
        constructor(scope: LexicalScope, index: number);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    function and(scope: LexicalScope, v1: Val, v2: Val): Val;
    function add(scope: LexicalScope, v1: Val, v2: Val): Val;
    function sub(scope: LexicalScope, v1: Val, v2: Val): Val;
    function mul(scope: LexicalScope, v1: Val, v2: Val): Val;
    function div(scope: LexicalScope, v1: Val, v2: Val): Val;
}
declare namespace Font {
    const traitProps: {
        [key: string]: Css.Val;
    };
    const bogusFontData: string;
    let bogusFontCounter: number;
    function makeFontTraitKey(properties: {
        [key: string]: Css.Val;
    }): string;
    function fillDefaults(properties: {
        [key: string]: Css.Val;
    }): void;
    function prepareProperties(properties: CssCascade_$0.ElementStyle, context: Exprs.Context): {
        [key: string]: Css.Val;
    };
    class Face {
        readonly properties: {
            [key: string]: Css.Val;
        };
        fontTraitKey: string;
        src: string | null;
        blobURLs: string[];
        blobs: Blob[];
        family: string | null;
        constructor(properties: {
            [key: string]: Css.Val;
        });
        traitsEqual(other: Face): boolean;
        makeAtRule(src: string, fontBytes: Blob): string;
    }
    class DocumentFaces {
        readonly deobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null;
        familyMap: {
            [key: string]: string;
        };
        constructor(deobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null);
        registerFamily(srcFace: Face, viewFace: Face): void;
        filterFontFamily(val: Css.Val): Css.Val;
    }
    class Mapper {
        readonly head: Element;
        readonly body: Element;
        srcURLMap: {
            [key: string]: TaskUtil.Fetcher<Face>;
        };
        familyPrefix: string;
        familyCounter: number;
        constructor(head: Element, body: Element, opt_familyPrefix?: string);
        getViewFontFamily(srcFace: Face, documentFaces: DocumentFaces): string;
        private initFont;
        loadFont(srcFace: Face, documentFaces: DocumentFaces): TaskUtil.Fetcher<Face>;
        findOrLoadFonts(srcFaces: Face[], documentFaces: DocumentFaces): Task.Result<boolean>;
    }
}
declare namespace OPS {
    const uaStylesheetBaseFetcher: TaskUtil.Fetcher<boolean>;
    function loadUABase(): Task.Result<boolean>;
    type FontFace = {
        properties: CssCascade.ElementStyle;
        condition: Exprs.Val;
    };
    class Style {
        readonly store: OPSDocStore;
        readonly rootScope: Exprs.LexicalScope;
        readonly pageScope: Exprs.LexicalScope;
        readonly cascade: CssCascade.Cascade;
        readonly rootBox: PageMaster.RootPageBox;
        readonly fontFaces: FontFace[];
        readonly footnoteProps: CssCascade.ElementStyle;
        readonly flowProps: {
            [key: string]: CssCascade.ElementStyle;
        };
        readonly viewportProps: CssCascade.ElementStyle[];
        readonly pageProps: {
            [key: string]: CssCascade.ElementStyle;
        };
        fontDeobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null;
        validatorSet: CssValidator.ValidatorSet;
        constructor(store: OPSDocStore, rootScope: Exprs.LexicalScope, pageScope: Exprs.LexicalScope, cascade: CssCascade.Cascade, rootBox: PageMaster.RootPageBox, fontFaces: FontFace[], footnoteProps: CssCascade.ElementStyle, flowProps: {
            [key: string]: CssCascade.ElementStyle;
        }, viewportProps: CssCascade.ElementStyle[], pageProps: {
            [key: string]: CssCascade.ElementStyle;
        });
        sizeViewport(viewportWidth: number, viewportHeight: number, fontSize: number, pref?: Exprs.Preferences): {
            width: number;
            height: number;
            fontSize: number;
        };
    }
    class StyleInstance extends Exprs.Context implements CssStyler_$0.FlowListener, PageMaster.InstanceHolder, Vgen.StylerProducer {
        readonly style: Style;
        readonly xmldoc: XmlDoc_$0.XMLDocHolder;
        readonly viewport: Vgen.Viewport;
        readonly clientLayout: Vtree_$0.ClientLayout;
        readonly fontMapper: Font.Mapper;
        readonly customRenderer: Vgen.CustomRenderer;
        readonly fallbackMap: {
            [key: string]: string;
        };
        readonly pageNumberOffset: number;
        readonly documentURLTransformer: Base.DocumentURLTransformer;
        readonly counterStore: Counters.CounterStore;
        lang: string | null;
        primaryFlows: {
            [key: string]: boolean;
        };
        rootPageBoxInstance: PageMaster.RootPageBoxInstance;
        styler: CssStyler_$0.Styler;
        stylerMap: {
            [key: string]: CssStyler_$0.Styler;
        };
        currentLayoutPosition: Vtree_$0.LayoutPosition;
        layoutPositionAtPageStart: Vtree_$0.LayoutPosition;
        lookupOffset: number;
        faces: Font.DocumentFaces;
        pageBoxInstances: {
            [key: string]: PageMaster.PageBoxInstance;
        };
        pageManager: CssPage.PageManager;
        private rootPageFloatLayoutContext;
        pageBreaks: {
            [key: string]: boolean;
        };
        pageProgression: Constants.PageProgression | null;
        pageSheetSize: {
            [key: string]: {
                width: number;
                height: number;
            };
        };
        pageSheetHeight: number;
        pageSheetWidth: number;
        actualPageWidth: number;
        actualPageHeight: number;
        constructor(style: Style, xmldoc: XmlDoc_$0.XMLDocHolder, defaultLang: string | null, viewport: Vgen.Viewport, clientLayout: Vtree_$0.ClientLayout, fontMapper: Font.Mapper, customRenderer: Vgen.CustomRenderer, fallbackMap: {
            [key: string]: string;
        }, pageNumberOffset: number, documentURLTransformer: Base.DocumentURLTransformer, counterStore: Counters.CounterStore, pageProgression?: Constants.PageProgression);
        init(): Task.Result<boolean>;
        getStylerForDoc(xmldoc: XmlDoc_$0.XMLDocHolder): CssStyler_$0.AbstractStyler;
        registerInstance(key: string, instance: PageMaster.PageBoxInstance): void;
        lookupInstance(key: string): PageMaster.PageBoxInstance;
        encounteredFlowChunk(flowChunk: Vtree_$0.FlowChunk, flow: Vtree_$0.Flow): any;
        getConsumedOffset(flowPosition: Vtree_$0.FlowPosition): number;
        getPosition(layoutPosition?: Vtree_$0.LayoutPosition, noLookAhead?: boolean): number;
        dumpLocation(position: any): void;
        matchPageSide(side: string): boolean;
        updateStartSide(layoutPosition: Vtree_$0.LayoutPosition): void;
        selectPageMaster(cascadedPageStyle: CssCascade.ElementStyle): PageMaster.PageMasterInstance;
        flowChunkIsAfterParentFlowForcedBreak(flowChunk: Vtree_$0.FlowChunk): boolean;
        setFormattingContextToColumn(column: LayoutType.Column, flowName: string): void;
        layoutDeferredPageFloats(column: LayoutType.Column): Task.Result<boolean>;
        getLastAfterPositionIfDeferredFloatsExists(column: LayoutType.Column, newPosition: Vtree_$0.ChunkPosition | null): Vtree_$0.ChunkPosition | null;
        layoutColumn(column: LayoutType.Column, flowName: string): Task.Result<boolean>;
        createLayoutConstraint(pageFloatLayoutContext: PageFloats_$0.PageFloatLayoutContext): LayoutType.LayoutConstraint;
        private createAndLayoutColumn;
        setPagePageFloatLayoutContextContainer(pagePageFloatLayoutContext: PageFloats_$0.PageFloatLayoutContext, boxInstance: PageMaster.PageBoxInstance, layoutContainer: Vtree_$0.Container): void;
        getRegionPageFloatLayoutContext(pagePageFloatLayoutContext: PageFloats_$0.PageFloatLayoutContext, boxInstance: PageMaster.PageBoxInstance, layoutContainer: Vtree_$0.Container, flowName: string): PageFloats_$0.PageFloatLayoutContext;
        layoutFlowColumnsWithBalancing(page: Vtree_$0.Page, boxInstance: PageMaster.PageBoxInstance, offsetX: number, offsetY: number, exclusions: GeometryUtil.Shape[], pagePageFloatLayoutContext: PageFloats_$0.PageFloatLayoutContext, layoutContainer: Vtree_$0.Container, flowNameStr: string, columnCount: number): Task.Result<LayoutType.Column[]>;
        layoutFlowColumns(page: Vtree_$0.Page, boxInstance: PageMaster.PageBoxInstance, offsetX: number, offsetY: number, exclusions: GeometryUtil.Shape[], pagePageFloatLayoutContext: PageFloats_$0.PageFloatLayoutContext, regionPageFloatLayoutContext: PageFloats_$0.PageFloatLayoutContext, layoutContainer: Vtree_$0.Container, flowNameStr: string, columnCount: number, forceNonFitting: boolean): Task.Result<LayoutType.Column[] | null>;
        layoutContainer(page: Vtree_$0.Page, boxInstance: PageMaster.PageBoxInstance, parentContainer: HTMLElement, offsetX: number, offsetY: number, exclusions: GeometryUtil.Shape[], pagePageFloatLayoutContext: PageFloats_$0.PageFloatLayoutContext): Task.Result<boolean>;
        processLinger(): void;
        initLingering(): void;
        noMorePrimaryFlows(cp: Vtree_$0.LayoutPosition): boolean;
        layoutNextPage(page: Vtree_$0.Page, cp?: Vtree_$0.LayoutPosition): Task.Result<Vtree_$0.LayoutPosition>;
        private setPageSizeAndBleed;
    }
    class BaseParserHandler extends CssCascade.CascadeParserHandler {
        masterHandler: StyleParserHandler;
        insideRegion: boolean;
        constructor(masterHandler: StyleParserHandler, condition: Exprs.Val, parent: BaseParserHandler, regionId: string | null);
        startPageTemplateRule(): void;
        startPageMasterRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startWhenRule(expr: Css.Expr): void;
        startDefineRule(): void;
        startFontFaceRule(): void;
        startFlowRule(flowName: string): void;
        startViewportRule(): void;
        startFootnoteRule(pseudoelem: string | null): void;
        startRegionRule(): void;
        startPageRule(): void;
        startRuleBody(): void;
    }
    function processViewportMeta(meta: Element): string;
    class StyleParserHandler extends CssParser.DispatchParserHandler {
        readonly validatorSet: CssValidator.ValidatorSet;
        rootScope: Exprs.LexicalScope;
        pageScope: Exprs.LexicalScope;
        rootBox: PageMaster.RootPageBox;
        cascadeParserHandler: BaseParserHandler;
        regionCount: number;
        fontFaces: FontFace[];
        footnoteProps: CssCascade.ElementStyle;
        flowProps: {
            [key: string]: CssCascade.ElementStyle;
        };
        viewportProps: CssCascade.ElementStyle[];
        pageProps: {
            [key: string]: CssCascade.ElementStyle;
        };
        slave: BaseParserHandler;
        constructor(validatorSet: CssValidator.ValidatorSet);
        error(mnemonics: string, token: CssTokenizer.Token): void;
    }
    type StyleSource = {
        url: string;
        text: string | null;
        flavor: CssParser.StylesheetFlavor;
        classes: string | null;
        media: string | null;
    };
    function parseOPSResource(response: Net_$0.Response, store: XmlDoc_$0.XMLDocStore): Task.Result<XmlDoc_$0.XMLDocHolder>;
    class OPSDocStore extends Net_$0.ResourceStore<XmlDoc_$0.XMLDocHolder> {
        fontDeobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null;
        styleByKey: {
            [key: string]: Style;
        };
        styleFetcherByKey: {
            [key: string]: TaskUtil.Fetcher<Style>;
        };
        styleByDocURL: {
            [key: string]: Style;
        };
        triggersByDocURL: {
            [key: string]: Vtree_$0.Trigger[];
        };
        validatorSet: CssValidator.ValidatorSet;
        private styleSheets;
        private triggerSingleDocumentPreprocessing;
        constructor(fontDeobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null);
        init(authorStyleSheets: {
            url: string | null;
            text: string | null;
        }[] | null, userStyleSheets: {
            url: string | null;
            text: string | null;
        }[] | null): Task.Result<boolean>;
        getStyleForDoc(xmldoc: XmlDoc_$0.XMLDocHolder): Style;
        getTriggersForDoc(xmldoc: XmlDoc_$0.XMLDocHolder): Vtree_$0.Trigger[];
        private setStyleSheets;
        private clearStyleSheets;
        private addAuthorStyleSheet;
        private addUserStyleSheet;
        parseOPSResource(response: Net_$0.Response): Task.Result<XmlDoc_$0.XMLDocHolder>;
    }
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
declare namespace Vgen {
    const frontEdgeBlackListHor: {
        [key: string]: string;
    };
    const frontEdgeBlackListVert: {
        [key: string]: string;
    };
    const frontEdgeUnforcedBreakBlackListHor: {
        [key: string]: string;
    };
    const frontEdgeUnforcedBreakBlackListVert: {
        [key: string]: string;
    };
    type CustomRenderer = (p1: Element, p2: Element, p3: {
        [key: string]: Css.Val;
    }) => Task.Result<Element>;
    interface CustomRendererFactory {
        makeCustomRenderer(xmldoc: XmlDoc.XMLDocHolder): CustomRenderer;
    }
    function initIFrame(iframe: HTMLIFrameElement): void;
    interface StylerProducer {
        getStylerForDoc(xmldoc: XmlDoc.XMLDocHolder): CssStyler_$0.AbstractStyler;
    }
    class ViewFactory extends Base.SimpleEventTarget implements Vtree_$0.LayoutContext {
        readonly flowName: string;
        readonly context: Exprs.Context;
        readonly viewport: Viewport;
        readonly styler: CssStyler_$0.Styler;
        readonly regionIds: string[];
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly docFaces: Font.DocumentFaces;
        readonly footnoteStyle: CssCascade_$0.ElementStyle;
        readonly stylerProducer: StylerProducer;
        readonly page: Vtree_$0.Page;
        readonly customRenderer: CustomRenderer;
        readonly fallbackMap: {
            [key: string]: string;
        };
        readonly documentURLTransformer: Base.DocumentURLTransformer;
        private static SVG_URL_ATTRIBUTES;
        document: Document;
        exprContentListener: Vtree_$0.ExprContentListener;
        nodeContext: Vtree_$0.NodeContext | null;
        viewRoot: Element | null;
        isFootnote: boolean;
        sourceNode: Node | null;
        offsetInNode: number;
        viewNode: Node | null;
        constructor(flowName: string, context: Exprs.Context, viewport: Viewport, styler: CssStyler_$0.Styler, regionIds: string[], xmldoc: XmlDoc.XMLDocHolder, docFaces: Font.DocumentFaces, footnoteStyle: CssCascade_$0.ElementStyle, stylerProducer: StylerProducer, page: Vtree_$0.Page, customRenderer: CustomRenderer, fallbackMap: {
            [key: string]: string;
        }, documentURLTransformer: Base.DocumentURLTransformer);
        clone(): Vtree_$0.LayoutContext;
        createPseudoelementShadow(element: Element, isRoot: boolean, cascStyle: CssCascade_$0.ElementStyle, computedStyle: {
            [key: string]: Css.Val;
        }, styler: CssStyler_$0.AbstractStyler, context: Exprs.Context, parentShadow: Vtree_$0.ShadowContext, subShadow: Vtree_$0.ShadowContext): Vtree_$0.ShadowContext;
        getPseudoMap(cascStyle: CssCascade_$0.ElementStyle, regionIds: string[], isFootnote: boolean, nodeContext: Vtree_$0.NodeContext, context: Exprs.Context): {};
        createRefShadow(href: string, type: Vtree_$0.ShadowType, element: Element, parentShadow: Vtree_$0.ShadowContext, subShadow: Vtree_$0.ShadowContext): Task.Result<Vtree_$0.ShadowContext>;
        createShadows(element: Element, isRoot: any, cascStyle: CssCascade_$0.ElementStyle, computedStyle: {
            [key: string]: Css.Val;
        }, styler: CssStyler_$0.AbstractStyler, context: Exprs.Context, shadowContext: Vtree_$0.ShadowContext): Task.Result<Vtree_$0.ShadowContext>;
        setViewRoot(viewRoot: Element, isFootnote: boolean): void;
        computeStyle(vertical: boolean, rtl: boolean, style: CssCascade_$0.ElementStyle, computedStyle: {
            [key: string]: Css.Val;
        }): boolean;
        private inheritFromSourceParent;
        resolveURL(url: string): string;
        inheritLangAttribute(): void;
        transferPolyfilledInheritedProps(computedStyle: {
            [key: string]: Css.Val;
        }): void;
        resolveFormattingContext(nodeContext: Vtree_$0.NodeContext, firstTime: boolean, display: Css.Ident, position: Css.Ident, float: Css.Ident, isRoot: boolean): void;
        private createElementView;
        private processAfterIfcontinues;
        isSVGUrlAttribute(attributeName: string): boolean;
        modifyElemDimensionWithImageResolution(images: {
            image: HTMLElement;
            element: HTMLElement;
            fetcher: TaskUtil.Fetcher<string>;
        }[], imageResolution: number, computedStyle: {
            [key: string]: Css.Val;
        }, isVertical: boolean): void;
        private preprocessElementStyle;
        private findAndProcessRepeatingElements;
        private processRepeatOnBreak;
        private createTextNodeView;
        private preprocessTextContent;
        createNodeView(firstTime: boolean, atUnforcedBreak: boolean): Task.Result<boolean>;
        setCurrent(nodeContext: Vtree_$0.NodeContext, firstTime: boolean, atUnforcedBreak?: boolean): Task.Result<boolean>;
        processShadowContent(pos: Vtree_$0.NodeContext): Vtree_$0.NodeContext;
        private nextPositionInTree;
        isTransclusion(element: Element, elementStyle: CssCascade_$0.ElementStyle, transclusionType: string | null): boolean;
        nextInTree(position: Vtree_$0.NodeContext, atUnforcedBreak?: boolean): Task.Result<Vtree_$0.NodeContext>;
        addImageFetchers(bg: Css.Val): void;
        applyComputedStyles(target: Element, computedStyle: {
            [key: string]: Css.Val;
        }): void;
        applyPseudoelementStyle(nodeContext: Vtree_$0.NodeContext, pseudoName: string, target: Element): void;
        peelOff(nodeContext: Vtree_$0.NodeContext, nodeOffset: number): Task.Result<Vtree_$0.NodeContext>;
        createElement(ns: string, tag: string): Element;
        applyFootnoteStyle(vertical: boolean, rtl: boolean, target: Element): boolean;
        processFragmentedBlockEdge(nodeContext: Vtree_$0.NodeContext): void;
        convertLengthToPx(numeric: Css.Numeric, viewNode: Node, clientLayout: Vtree_$0.ClientLayout): number | Css.Numeric;
        isSameNodePositionStep(step1: Vtree_$0.NodePositionStep, step2: Vtree_$0.NodePositionStep): boolean;
        isSameNodePosition(nodePosition1: Vtree_$0.NodePosition, nodePosition2: Vtree_$0.NodePosition): boolean;
        isPseudoelement(elem: any): boolean;
    }
    const fb2Remap: {
        a: string;
        sub: string;
        sup: string;
        table: string;
        tr: string;
        td: string;
        th: string;
        code: string;
        body: string;
        p: string;
        v: string;
        date: string;
        emphasis: string;
        strong: string;
        style: string;
        strikethrough: string;
    };
    const propertiesNotPassedToDOM: {
        "box-decoration-break": boolean;
        "float-min-wrap-block": boolean;
        "float-reference": boolean;
        "flow-into": boolean;
        "flow-linger": boolean;
        "flow-options": boolean;
        "flow-priority": boolean;
        "footnote-policy": boolean;
        page: boolean;
    };
    class DefaultClientLayout implements Vtree_$0.ClientLayout {
        layoutBox: Element;
        window: Window;
        constructor(viewport: Viewport);
        private subtractOffsets;
        getRangeClientRects(range: Range): ClientRect[];
        getElementClientRect(element: Element): ClientRect;
        getElementComputedStyle(element: Element): CSSStyleDeclaration;
    }
    class Viewport {
        readonly window: Window;
        readonly fontSize: number;
        document: Document;
        root: HTMLElement;
        private outerZoomBox;
        contentContainer: HTMLElement;
        layoutBox: Element;
        width: number;
        height: number;
        constructor(window: Window, fontSize: number, opt_root?: HTMLElement, opt_width?: number, opt_height?: number);
        resetZoom(): void;
        zoom(width: number, height: number, scale: number): void;
        clear(): void;
    }
}
declare namespace Vtree_$0 {
    const delayedProps: {
        transform: boolean;
        "transform-origin": boolean;
    };
    const delayedPropsIfRelativePositioned: {
        top: boolean;
        bottom: boolean;
        left: boolean;
        right: boolean;
    };
    class DelayedItem {
        target: Element;
        name: string;
        value: Css.Val;
        constructor(target: Element, name: string, value: Css.Val);
    }
    type PageHyperlinkEvent = {
        type: string;
        target: any;
        currentTarget: any;
        anchorElement: Element;
        href: string;
    };
    type Trigger = {
        observer: string;
        event: string;
        action: string;
        ref: string;
    };
    const actions: {
        show: (obj: any) => void;
        hide: (obj: any) => void;
        play: (obj: any) => void;
        pause: (obj: any) => void;
        resume: (obj: any) => void;
        mute: (obj: any) => void;
        unmute: (obj: any) => void;
    };
    function makeListener(refs: Element[], action: string): EventListener | null;
    class Page extends Base.SimpleEventTarget {
        readonly container: HTMLElement;
        readonly bleedBox: HTMLElement;
        private static AUTO_PAGE_WIDTH_ATTRIBUTE;
        private static AUTO_PAGE_HEIGHT_ATTRIBUTE;
        pageAreaElement: HTMLElement | null;
        delayedItems: DelayedItem[];
        hrefHandler: (e: Event) => void;
        elementsById: {
            [key: string]: Element[];
        };
        dimensions: {
            width: number;
            height: number;
        };
        isFirstPage: boolean;
        isLastPage: boolean;
        isAutoPageWidth: boolean;
        isAutoPageHeight: boolean;
        spineIndex: number;
        position: LayoutPosition;
        offset: number;
        side: Constants.PageSide | null;
        fetchers: TaskUtil.Fetcher<{}>[];
        marginBoxes: {
            top: {
                [key: string]: Container_$0;
            };
            bottom: {
                [key: string]: Container_$0;
            };
            left: {
                [key: string]: Container_$0;
            };
            right: {
                [key: string]: Container_$0;
            };
        };
        constructor(container: HTMLElement, bleedBox: HTMLElement);
        setAutoPageWidth(isAuto: boolean): void;
        setAutoPageHeight(isAuto: boolean): void;
        registerElementWithId(element: Element, id: string): void;
        finish(triggers: Trigger[], clientLayout: ClientLayout_$0): void;
        zoom(scale: number): void;
        getPageAreaElement(): HTMLElement;
    }
    type Spread = {
        left: Page;
        right: Page;
    };
    const SPECIAL_ATTR = "data-adapt-spec";
    const Whitespace_$0: typeof Vtree.Whitespace_$0;
    type Whitespace_$0 = Vtree.Whitespace_$0;
    function whitespaceFromPropertyValue(whitespace: string): Whitespace_$0 | null;
    function canIgnore(node: Node, whitespace: Whitespace_$0): boolean;
    class Flow {
        readonly flowName: string;
        readonly parentFlowName: string | null;
        forcedBreakOffsets: number[];
        formattingContext: FormattingContext_$0 | null;
        constructor(flowName: string, parentFlowName: string | null);
    }
    class FlowChunk {
        flowName: string;
        element: Element;
        startOffset: number;
        priority: number;
        linger: number;
        exclusive: boolean;
        repeated: boolean;
        last: boolean;
        breakBefore: string | null;
        startPage: number;
        constructor(flowName: string, element: Element, startOffset: number, priority: number, linger: number, exclusive: boolean, repeated: boolean, last: boolean, breakBefore: string | null);
        isBetter(other: FlowChunk): boolean;
    }
    type ClientRect_$0 = Vtree.ClientRect_$0;
    function clientrectIncreasingTop(r1: ClientRect_$0, r2: ClientRect_$0): number;
    function clientrectDecreasingRight(r1: ClientRect_$0, r2: ClientRect_$0): number;
    type ClientLayout_$0 = Vtree.ClientLayout_$0;
    type LayoutContext_$0 = Vtree.LayoutContext_$0;
    type FormattingContext_$0 = Vtree.FormattingContext_$0;
    function eachAncestorFormattingContext(nodeContext: NodeContext_$0, callback: (p1: FormattingContext_$0) => any): void;
    type NodePositionStep_$0 = Vtree.NodePositionStep_$0;
    function isSameNodePositionStep(nps1: NodePositionStep_$0, nps2: NodePositionStep_$0): boolean;
    type NodePosition_$0 = Vtree.NodePosition_$0;
    function isSameNodePosition(np1: NodePosition_$0 | null, np2: NodePosition_$0 | null): boolean;
    function newNodePositionFromNode(node: Node): NodePosition_$0;
    function newNodePositionFromNodeContext(nodeContext: Vtree.NodeContext_$0, initialFragmentIndex: number | null): NodePosition_$0;
    function makeNodeContextFromNodePositionStep(step: NodePositionStep_$0, parent: Vtree.NodeContext_$0): NodeContext_$0;
    const ShadowType_$0: typeof Vtree.ShadowType_$0;
    type ShadowType_$0 = Vtree.ShadowType_$0;
    class ShadowContext_$0 implements Vtree.ShadowContext_$0 {
        readonly owner: Element;
        readonly root: Element;
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly parentShadow: ShadowContext_$0;
        readonly type: ShadowType_$0;
        readonly styler: object;
        subShadow: ShadowContext_$0;
        constructor(owner: Element, root: Element, xmldoc: XmlDoc.XMLDocHolder, parentShadow: ShadowContext_$0, superShadow: ShadowContext_$0, type: ShadowType_$0, styler: object);
        equals(other: ShadowContext_$0): boolean;
    }
    function isSameShadowContext(sc1: ShadowContext_$0, sc2: ShadowContext_$0): boolean;
    class FirstPseudo_$0 implements Vtree.FirstPseudo_$0 {
        readonly outer: FirstPseudo_$0;
        readonly count: number;
        constructor(outer: FirstPseudo_$0, count: number);
    }
    class NodeContext_$0 implements Vtree.NodeContext_$0 {
        sourceNode: Node;
        parent: NodeContext_$0;
        boxOffset: number;
        offsetInNode: number;
        after: boolean;
        shadowType: ShadowType_$0;
        shadowContext: ShadowContext_$0;
        nodeShadow: ShadowContext_$0;
        shadowSibling: NodeContext_$0;
        shared: boolean;
        inline: boolean;
        overflow: boolean;
        breakPenalty: number;
        display: string | null;
        floatReference: PageFloats.FloatReference;
        floatSide: string | null;
        clearSide: string | null;
        floatMinWrapBlock: Css.Numeric | null;
        columnSpan: Css.Val | null;
        verticalAlign: string;
        captionSide: string;
        inlineBorderSpacing: number;
        blockBorderSpacing: number;
        flexContainer: boolean;
        whitespace: Whitespace_$0;
        hyphenateCharacter: string | null;
        breakWord: boolean;
        establishesBFC: boolean;
        containingBlockForAbsolute: boolean;
        breakBefore: string | null;
        breakAfter: string | null;
        viewNode: Node;
        clearSpacer: Node;
        inheritedProps: {
            [key: string]: number | string | Css.Val;
        };
        vertical: boolean;
        direction: string;
        firstPseudo: FirstPseudo_$0;
        lang: string | null;
        preprocessedTextContent: Diff.Change[] | null;
        formattingContext: FormattingContext_$0;
        repeatOnBreak: string | null;
        pluginProps: {
            [key: string]: string | number | undefined | null | (number | null)[];
        };
        fragmentIndex: number;
        afterIfContinues: Selectors.AfterIfContinues;
        footnotePolicy: Css.Ident | null;
        constructor(sourceNode: Node, parent: NodeContext_$0, boxOffset: number);
        resetView(): void;
        private cloneItem;
        modify(): NodeContext_$0;
        copy(): NodeContext_$0;
        clone(): NodeContext_$0;
        toNodePositionStep(): NodePositionStep_$0;
        toNodePosition(): NodePosition_$0;
        isInsideBFC(): boolean;
        getContainingBlockForAbsolute(): NodeContext_$0;
        walkUpBlocks(callback: (p1: NodeContext_$0) => any): void;
        belongsTo(formattingContext: FormattingContext_$0): boolean;
    }
    class ChunkPosition_$0 implements Vtree.ChunkPosition_$0 {
        primary: NodePosition_$0;
        floats: NodePosition_$0[];
        constructor(primary: NodePosition_$0);
        clone(): ChunkPosition_$0;
        isSamePosition(other: ChunkPosition_$0): boolean;
    }
    class FlowChunkPosition {
        chunkPosition: ChunkPosition_$0;
        readonly flowChunk: FlowChunk;
        constructor(chunkPosition: ChunkPosition_$0, flowChunk: FlowChunk);
        clone(): FlowChunkPosition;
        isSamePosition(other: FlowChunkPosition): boolean;
    }
    class FlowPosition {
        positions: FlowChunkPosition[];
        startSide: string;
        breakAfter: string | null;
        clone(): FlowPosition;
        isSamePosition(other: FlowPosition): boolean;
        hasContent(offset: number): boolean;
    }
    class LayoutPosition {
        page: number;
        flows: {
            [key: string]: Flow;
        };
        flowPositions: {
            [key: string]: FlowPosition;
        };
        highestSeenOffset: number;
        highestSeenNode: Node;
        lookupPositionOffset: number;
        clone(): LayoutPosition;
        isSamePosition(other: LayoutPosition): boolean;
        hasContent(name: string, offset: number): boolean;
        startSideOfFlow(name: string): string;
        firstFlowChunkOfFlow(name: string): FlowChunk | null;
    }
    class Container_$0 implements Vtree.Container_$0 {
        element: Element;
        left: number;
        top: number;
        marginLeft: number;
        marginRight: number;
        marginTop: number;
        marginBottom: number;
        borderLeft: number;
        borderRight: number;
        borderTop: number;
        borderBottom: number;
        paddingLeft: number;
        paddingRight: number;
        paddingTop: number;
        paddingBottom: number;
        width: number;
        height: number;
        originX: number;
        originY: number;
        exclusions: GeometryUtil.Shape[];
        innerShape: GeometryUtil.Shape;
        computedBlockSize: number;
        snapWidth: number;
        snapHeight: number;
        snapOffsetX: number;
        snapOffsetY: number;
        vertical: boolean;
        constructor(element: Element);
        getInsetTop(): number;
        getInsetBottom(): number;
        getInsetLeft(): number;
        getInsetRight(): number;
        getInsetBefore(): number;
        getInsetAfter(): number;
        getInsetStart(): number;
        getInsetEnd(): number;
        getBeforeEdge(box: ClientRect_$0): number;
        getAfterEdge(box: ClientRect_$0): number;
        getStartEdge(box: ClientRect_$0): number;
        getEndEdge(box: ClientRect_$0): number;
        getInlineSize(box: ClientRect_$0): number;
        getBoxSize(box: ClientRect_$0): number;
        getBoxDir(): number;
        getInlineDir(): number;
        copyFrom(other: Container_$0): void;
        setVerticalPosition(top: number, height: number): void;
        setHorizontalPosition(left: number, width: number): void;
        setBlockPosition(start: number, extent: number): void;
        setInlinePosition(start: number, extent: number): void;
        clear(): void;
        getInnerShape(): GeometryUtil.Shape;
        getInnerRect(): GeometryUtil.Rect;
        getPaddingRect(): GeometryUtil.Rect;
        getOuterShape(outerShapeProp: Css.Val, context: Exprs.Context): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
    }
    type ExprContentListener_$0 = Vtree.ExprContentListener_$0;
    class ContentPropertyHandler extends Css.Visitor {
        readonly elem: Element;
        readonly context: Exprs.Context;
        readonly rootContentValue: Css.Val;
        readonly exprContentListener: ExprContentListener_$0;
        constructor(elem: Element, context: Exprs.Context, rootContentValue: Css.Val, exprContentListener: ExprContentListener_$0);
        private visitStrInner;
        visitStr(str: Css.Str): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function nonTrivialContent(val: Css.Val): boolean;
}
declare namespace XmlDoc_$0 {
    type XMLDocStore_$0 = XmlDoc.XMLDocStore_$0;
    const ELEMENT_OFFSET_ATTR = "data-adapt-eloff";
    class XMLDocHolder_$0 implements XmlDoc.XMLDocHolder_$0 {
        readonly store: XMLDocStore_$0;
        readonly url: string;
        readonly document: Document;
        lang: string | null;
        totalOffset: number;
        root: Element;
        body: Element;
        head: Element;
        last: Element;
        lastOffset: number;
        idMap: {
            [key: string]: Element;
        };
        constructor(store: XMLDocStore_$0, url: string, document: Document);
        doc(): XmlDoc.NodeList_$0;
        getElementOffset(element: Element): number;
        getNodeOffset(srcNode: Node, offsetInNode: number, after: boolean): number;
        getTotalOffset(): number;
        getNodeByOffset(offset: number): Node;
        private buildIdMap;
        getElement(url: string): Element | null;
    }
    enum DOMParserSupportedType {
        TEXT_HTML = "text/html",
        TEXT_XML = "text/xml",
        APPLICATION_XML = "application/xml",
        APPLICATION_XHTML_XML = "application/xhtml_xml",
        IMAGE_SVG_XML = "image/svg+xml"
    }
    function parseAndReturnNullIfError(str: string, type: string, opt_parser?: DOMParser): Document | null;
    function resolveContentType(response: Net_$0.Response): string | null;
    function parseXMLResource(response: Net_$0.Response, store: XMLDocStore_$0): Task.Result<XmlDoc.XMLDocHolder_$0>;
    function newXMLDocStore(): XMLDocStore_$0;
    class Predicate_$0 implements XmlDoc.Predicate_$0 {
        readonly fn: (p1: Node) => boolean;
        constructor(fn: (p1: Node) => boolean);
        check(node: Node): boolean;
        withAttribute(name: string, value: string): Predicate_$0;
        withChild(name: string, opt_childPredicate?: Predicate_$0): Predicate_$0;
    }
    const predicate: Predicate_$0;
    class NodeList_$0 implements XmlDoc.NodeList_$0 {
        readonly nodes: Node[];
        constructor(nodes: Node[]);
        asArray(): Node[];
        size(): number;
        predicate(pr: Predicate_$0): NodeList_$0;
        forEachNode(fn: (p1: Node, p2: (p1: Node) => void) => void): NodeList_$0;
        forEach<T>(fn: (p1: Node) => T): T[];
        forEachNonNull<T>(fn: (p1: Node) => T): T[];
        child(tag: string): NodeList_$0;
        childElements(): NodeList_$0;
        attribute(name: string): (string | null)[];
        textContent(): (string | null)[];
    }
}
declare namespace Base {
    let emptyObj: {};
    type JSON = any;
    function jsonToString(json: JSON): string;
    function stringToJSON(str: string): JSON;
    function stripFragment(url: string): string;
    function stripFragmentAndQuery(url: string): string;
    let baseURL: string;
    function setBaseURL(value: string): void;
    let resourceBaseURL: string;
    function setResourceBaseURL(value: string): void;
    function resolveURL(relURL: string, baseURL: string): string;
    function convertSpecialURL(url: string): string;
    interface DocumentURLTransformer {
        transformFragment(fragment: string, baseURL: string): string;
        transformURL(url: string, baseURL: string): string;
        restoreURL(encoded: string): string[];
    }
    enum NS {
        FB2 = "http://www.gribuser.ru/xml/fictionbook/2.0",
        epub = "http://www.idpf.org/2007/ops",
        EV = "http://www.w3.org/2001/xml-events",
        MATHML = "http://www.w3.org/1998/Math/MathML",
        XML = "http://www.w3.org/XML/1998/namespace",
        XHTML = "http://www.w3.org/1999/xhtml",
        XLINK = "http://www.w3.org/1999/xlink",
        SHADOW = "http://www.pyroxy.com/ns/shadow",
        SVG = "http://www.w3.org/2000/svg",
        DC = "http://purl.org/dc/elements/1.1/",
        NCX = "http://www.daisy.org/z3986/2005/ncx/",
        SSE = "http://example.com/sse"
    }
    function getURLParam(name: string, opt_url?: string): string | null;
    function setURLParam(url: string, name: string, value: string): string;
    function asString(v: any): any;
    interface Comparable {
        compare(other: Comparable): number;
    }
    class PriorityQueue {
        queue: Comparable[];
        length(): number;
        add(item: Comparable): void;
        peek(): Comparable;
        remove(): Comparable;
    }
    function cssToJSProp(prefix: string, cssPropName: string): string;
    const knownPrefixes: string[];
    const propNameMap: {};
    function checkIfPropertySupported(prefix: string, prop: string): boolean;
    function getPrefixedPropertyNames(prop: string): string[] | null;
    function setCSSProperty(elem: Element, prop: string, value: string): void;
    function getCSSProperty(elem: Element, prop: string, opt_value?: string): string;
    function getLangAttribute(element: Element): string;
    class StringBuffer {
        list: string[];
        append(str: string): StringBuffer;
        clear(): void;
        toString(): string;
    }
    function escapeChar(str: string): string;
    function escapeCSSIdent(name: string): string;
    function escapeCSSStr(str: string): string;
    function lightURLEncode(str: string): string;
    function isLetter(ch: string): boolean;
    function escapeCharToHex(str: string, prefix?: string): string;
    function escapeNameStrToHex(str: string, prefix?: string): string;
    function escapeRegExp(str: string): string;
    function unescapeCharFromHex(str: string, prefix?: string): string;
    function unescapeStrFromHex(str: string, prefix?: string): string;
    function binarySearch(high: number, good: (p1: number) => boolean): number;
    function numberCompare(a: number, b: number): number;
    const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    function appendBase64(sb: StringBuffer, data: string): void;
    function indexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T;
    };
    function arrayToSet(arr: string[]): {
        [key: string]: boolean;
    };
    function multiIndexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T[];
    };
    function mapObj<P, R>(obj: {
        [key: string]: P;
    }, fn: (p1: P, p2: string) => R): {
        [key: string]: R;
    };
    function mapSize(obj: object): number;
    type Event = {
        type: string;
        target?: any;
        currentTarget?: any;
        preventDefault?: any;
        newPage?: any;
        anchorElement?: any;
        href?: any;
        content?: any;
    };
    type EventListener = (p1: Event) => void;
    class SimpleEventTarget {
        listeners: {
            [key: string]: EventListener[];
        };
        dispatchEvent(evt: Event): void;
        addEventListener(type: string, listener: EventListener, capture?: boolean): void;
        removeEventListener(type: string, listener: EventListener, capture?: boolean): void;
    }
    type EventTarget = SimpleEventTarget;
    let hasLShapeFloatBug: boolean | null;
    function checkLShapeFloatBug(body: HTMLElement): boolean;
    let hasVerticalBBoxBug: boolean | null;
    function checkVerticalBBoxBug(body: HTMLElement): boolean;
    let hasInlineBlockJustificationBug: boolean | null;
    function checkInlineBlockJustificationBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityAfterHyphenBug: boolean | null;
    function checkSoftWrapOpportunityAfterHyphenBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityByWbrBug: boolean | null;
    function checkSoftWrapOpportunityByWbrBug(body: HTMLElement): boolean;
}
declare namespace Constants {
    let isDebug: boolean;
    function setDebug(value: boolean): void;
    enum PageProgression {
        LTR = "ltr",
        RTL = "rtl"
    }
    function pageProgressionOf(str: string): PageProgression;
    enum PageSide {
        LEFT = "left",
        RIGHT = "right"
    }
    enum ReadyState {
        LOADING = "loading",
        INTERACTIVE = "interactive",
        COMPLETE = "complete"
    }
    const constants: {
        PageProgression: typeof PageProgression;
        PageSide: typeof PageSide;
        ReadyState: typeof ReadyState;
    };
}
declare namespace Counters {
    class TargetCounterReference {
        readonly targetId: string;
        resolved: boolean;
        pageCounters: CssCascade_$0.CounterValues;
        spineIndex: number;
        pageIndex: number;
        constructor(targetId: string, resolved: boolean);
        equals(other: TargetCounterReference): boolean;
        isResolved(): boolean;
        resolve(): void;
        unresolve(): void;
    }
    class CounterStore {
        readonly documentURLTransformer: Base.DocumentURLTransformer;
        countersById: {
            [key: string]: CssCascade_$0.CounterValues;
        };
        pageCountersById: {
            [key: string]: CssCascade_$0.CounterValues;
        };
        currentPageCounters: CssCascade_$0.CounterValues;
        previousPageCounters: CssCascade_$0.CounterValues;
        currentPageCountersStack: CssCascade_$0.CounterValues[];
        pageIndicesById: {
            [key: string]: {
                spineIndex: number;
                pageIndex: number;
            };
        };
        currentPage: Vtree_$0.Page;
        newReferencesOfCurrentPage: TargetCounterReference[];
        referencesToSolve: TargetCounterReference[];
        referencesToSolveStack: TargetCounterReference[][];
        unresolvedReferences: {
            [key: string]: TargetCounterReference[];
        };
        resolvedReferences: {
            [key: string]: TargetCounterReference[];
        };
        private pagesCounterExprs;
        constructor(documentURLTransformer: Base.DocumentURLTransformer);
        createCounterListener(baseURL: string): CssCascade_$0.CounterListener;
        createCounterResolver(baseURL: string, rootScope: Exprs.LexicalScope, pageScope: Exprs.LexicalScope): CssCascade_$0.CounterResolver;
        setCurrentPage(page: Vtree_$0.Page): void;
        private definePageCounter;
        forceSetPageCounter(pageNumber: number): void;
        updatePageCounters(cascadedPageStyle: CssCascade_$0.ElementStyle, context: Exprs.Context): void;
        pushPageCounters(counters: CssCascade_$0.CounterValues): void;
        popPageCounters(): void;
        resolveReference(id: string): void;
        saveReferenceOfCurrentPage(id: string, resolved: boolean): void;
        finishPage(spineIndex: number, pageIndex: number): void;
        getUnresolvedRefsToPage(page: Vtree_$0.Page): {
            spineIndex: number;
            pageIndex: number;
            pageCounters: CssCascade_$0.CounterValues;
            refs: TargetCounterReference[];
        }[];
        pushReferencesToSolve(refs: TargetCounterReference[]): void;
        popReferencesToSolve(): void;
        registerPageCounterExpr(name: string, format: (p1: number[]) => string, expr: Exprs.Val): void;
        getExprContentListener(): Vtree_$0.ExprContentListener;
        private exprContentListener;
        finishLastPage(viewport: Vgen.Viewport): void;
        createLayoutConstraint(pageIndex: number): Layout.LayoutConstraint;
    }
    const PAGES_COUNTER_ATTR = "data-vivliostyle-pages-counter";
}
declare namespace Css {
    class Visitor {
        visitValues(values: Val_$0[]): any;
        visitEmpty(empty: Val_$0): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class FilterVisitor extends Visitor {
        constructor();
        visitValues(values: Val_$0[]): Val_$0[];
        visitStr(str: Str): Val_$0;
        visitIdent(ident: Ident): Val_$0;
        visitSlash(slash: Val_$0): Val_$0;
        visitNumeric(numeric: Numeric_$0): Val_$0;
        visitNum(num: Num): Val_$0;
        visitInt(num: Int): Val_$0;
        visitColor(color: Color): Val_$0;
        visitURL(url: URL): Val_$0;
        visitSpaceList(list: SpaceList): Val_$0;
        visitCommaList(list: CommaList): Val_$0;
        visitFunc(func: Func): Val_$0;
        visitExpr(expr: Expr): Val_$0;
    }
    class Val_$0 {
        toString(): string;
        stringValue(): string;
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        isExpr(): boolean;
        isNumeric(): boolean;
        isNum(): boolean;
        isIdent(): boolean;
        isSpaceList(): boolean;
        visit(visitor: any): any;
    }
    class Empty extends Val_$0 {
        private static empty;
        static get instance(): Empty;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const empty: Empty;
    class Slash extends Val_$0 {
        private static slash;
        static get instance(): Slash;
        private constructor();
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    const slash: Slash;
    class Str extends Val_$0 {
        str: string;
        constructor(str: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Ident extends Val_$0 {
        name: string;
        constructor(name: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isIdent(): boolean;
    }
    function getName(name: string): Ident;
    class Numeric_$0 extends Val_$0 {
        num: number;
        unit: string;
        constructor(num: number, unit: string);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNumeric(): boolean;
    }
    class Num extends Val_$0 {
        num: number;
        constructor(num: number);
        toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isNum(): boolean;
    }
    class Int extends Num {
        constructor(num: number);
        visit(visitor: any): any;
    }
    class Color extends Val_$0 {
        rgb: number;
        constructor(rgb: number);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class URL extends Val_$0 {
        url: string;
        constructor(url: string);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    function appendList(buf: Base.StringBuffer, values: Val_$0[], separator: string, toString: boolean): void;
    class SpaceList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isSpaceList(): boolean;
    }
    class CommaList extends Val_$0 {
        values: Val_$0[];
        constructor(values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Func extends Val_$0 {
        name: string;
        values: Val_$0[];
        constructor(name: string, values: Val_$0[]);
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
    }
    class Expr extends Val_$0 {
        expr: Exprs.Val_$0;
        constructor(expr: Exprs.Val_$0);
        toExpr(): Exprs.Val_$0;
        appendTo(buf: Base.StringBuffer, toString: boolean): void;
        visit(visitor: any): any;
        isExpr(): boolean;
    }
    function toNumber(val: Val_$0, context: Exprs.Context): number;
    function convertNumericToPx(val: Val_$0, context: Exprs.Context): Numeric_$0;
    const ident: {
        [key: string]: Ident;
    };
    const hundredPercent: Numeric_$0;
    const fullWidth: Numeric_$0;
    const fullHeight: Numeric_$0;
    const numericZero: Numeric_$0;
    const processingOrder: {
        "font-size": number;
        color: number;
    };
    function processingOrderFn(name1: string, name2: string): number;
}
declare namespace Exprs {
    type Preferences = {
        fontFamily: string;
        lineHeight: number;
        margin: number;
        hyphenate: boolean;
        columnWidth: number;
        horizontal: boolean;
        nightMode: boolean;
        spreadView: boolean;
        pageBorder: number;
        enabledMediaTypes: {
            [key: string]: boolean;
        };
        defaultPaperSize?: {
            [key: string]: number;
        };
    };
    function defaultPreferences(): Preferences;
    function clonePreferences(pref: Preferences): Preferences;
    const defaultPreferencesInstance: Preferences;
    const Special: {
        PENDING: Pending;
    };
    type Result = string | number | boolean | undefined;
    type PendingResult = Special | Result;
    function letterbox(viewW: number, viewH: number, objW: number, objH: number): string;
    function cssString(str: string): string;
    function cssIdent(name: string): string;
    function makeQualifiedName(objName: string | null, memberName: string): string;
    let nextKeyIndex: number;
    class LexicalScope {
        parent: LexicalScope;
        resolver?: (p1: string, p2: boolean) => Val;
        scopeKey: string;
        children: LexicalScope[];
        zero: Const;
        one: Const;
        _true: Const;
        _false: Const;
        values: {
            [key: string]: Val;
        };
        funcs: {
            [key: string]: Val;
        };
        builtIns: {
            [key: string]: (...p1: Result[]) => Result;
        };
        constructor(parent: LexicalScope, resolver?: (p1: string, p2: boolean) => Val);
        defineBuiltInName(name: string, fn: () => Result): void;
        defineName(qualifiedName: string, val: Val): void;
        defineFunc(qualifiedName: string, val: Val): void;
        defineBuiltIn(qualifiedName: string, fn: (...p1: Result[]) => Result): void;
    }
    function isAbsoluteLengthUnit(unit: string): boolean;
    function isViewportRelativeLengthUnit(unit: string): boolean;
    function isFontRelativeLengthUnit(unit: string): boolean;
    const defaultUnitSizes: {
        [key: string]: number;
    };
    function needUnitConversion(unit: string): boolean;
    type ScopeContext = {
        [key: string]: Result;
    };
    class Context {
        readonly rootScope: LexicalScope;
        readonly viewportWidth: number;
        readonly viewportHeight: number;
        protected actualPageWidth: number | null;
        pageWidth: () => number;
        protected actualPageHeight: number | null;
        pageHeight: () => number;
        initialFontSize: number;
        rootFontSize: number | null;
        fontSize: () => number;
        pref: Preferences;
        scopes: {
            [key: string]: ScopeContext;
        };
        pageAreaWidth: number | null;
        pageAreaHeight: number | null;
        pageVertical: boolean | null;
        pubTitle: string | null;
        docTitle: string | null;
        constructor(rootScope: LexicalScope, viewportWidth: number, viewportHeight: number, fontSize: number);
        private getScopeContext;
        clearScope(scope: LexicalScope): void;
        queryUnitSize(unit: string, isRoot: boolean): number;
        evalName(scope: LexicalScope, qualifiedName: string): Val;
        evalCall(scope: LexicalScope, qualifiedName: string, params: Val[], noBuiltInEval: boolean): Val;
        evalMediaName(name: string, not: boolean): boolean;
        evalMediaTest(feature: string, value: Val): boolean;
        queryVal(scope: LexicalScope, key: string): Result | undefined;
        storeVal(scope: LexicalScope, key: string, val: Result): void;
    }
    type DependencyCache = {
        [key: string]: boolean | Special;
    };
    class Val {
        scope: LexicalScope;
        key: string;
        constructor(scope: LexicalScope);
        toString(): string;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        expand(context: Context, params: Val[]): Val;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        dependOuter(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        depend(other: Val, context: Context): boolean;
        evaluate(context: Context): Result;
        isMediaName(): boolean;
    }
    class Prefix extends Val {
        val: Val;
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Infix extends Val {
        lhs: Val;
        rhs: Val;
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Logical extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Comparison extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Additive extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Multiplicative extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Not extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class Negate extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class And extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class AndMedia extends And {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Or extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class OrMedia extends Or {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Lt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Le extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Gt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ge extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Eq extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ne extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Add extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Subtract extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Multiply extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Divide extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Modulo extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Numeric extends Val {
        num: number;
        unit: string;
        constructor(scope: LexicalScope, num: number, unit: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class Named extends Val {
        qualifiedName: string;
        constructor(scope: LexicalScope, qualifiedName: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    }
    class MediaName extends Val {
        not: boolean;
        name: string;
        value: Val;
        constructor(scope: LexicalScope, not: boolean, name: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        isMediaName(): boolean;
    }
    class Native extends Val {
        fn: () => Result;
        str: string;
        constructor(scope: LexicalScope, fn: () => Result, str: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    function appendValArray(buf: Base.StringBuffer, arr: Val[]): void;
    function expandValArray(context: Context, arr: Val[], params: Val[]): Val[];
    function evalValArray(context: Context, arr: Val[]): Result[];
    class Call extends Val {
        qualifiedName: string;
        params: Val[];
        constructor(scope: LexicalScope, qualifiedName: string, params: Val[]);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Cond extends Val {
        cond: Val;
        ifTrue: Val;
        ifFalse: Val;
        constructor(scope: LexicalScope, cond: Val, ifTrue: Val, ifFalse: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Const extends Val {
        val: Result;
        constructor(scope: LexicalScope, val: Result);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class MediaTest extends Val {
        name: MediaName;
        value: Val;
        constructor(scope: LexicalScope, name: MediaName, value: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Param extends Val {
        index: number;
        constructor(scope: LexicalScope, index: number);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    function and(scope: LexicalScope, v1: Val, v2: Val): Val;
    function add(scope: LexicalScope, v1: Val, v2: Val): Val;
    function sub(scope: LexicalScope, v1: Val, v2: Val): Val;
    function mul(scope: LexicalScope, v1: Val, v2: Val): Val;
    function div(scope: LexicalScope, v1: Val, v2: Val): Val;
}
declare namespace Font {
    const traitProps: {
        [key: string]: Css.Val;
    };
    const bogusFontData: string;
    let bogusFontCounter: number;
    function makeFontTraitKey(properties: {
        [key: string]: Css.Val;
    }): string;
    function fillDefaults(properties: {
        [key: string]: Css.Val;
    }): void;
    function prepareProperties(properties: CssCascade_$0.ElementStyle, context: Exprs.Context): {
        [key: string]: Css.Val;
    };
    class Face {
        readonly properties: {
            [key: string]: Css.Val;
        };
        fontTraitKey: string;
        src: string | null;
        blobURLs: string[];
        blobs: Blob[];
        family: string | null;
        constructor(properties: {
            [key: string]: Css.Val;
        });
        traitsEqual(other: Face): boolean;
        makeAtRule(src: string, fontBytes: Blob): string;
    }
    class DocumentFaces {
        readonly deobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null;
        familyMap: {
            [key: string]: string;
        };
        constructor(deobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null);
        registerFamily(srcFace: Face, viewFace: Face): void;
        filterFontFamily(val: Css.Val): Css.Val;
    }
    class Mapper {
        readonly head: Element;
        readonly body: Element;
        srcURLMap: {
            [key: string]: TaskUtil.Fetcher<Face>;
        };
        familyPrefix: string;
        familyCounter: number;
        constructor(head: Element, body: Element, opt_familyPrefix?: string);
        getViewFontFamily(srcFace: Face, documentFaces: DocumentFaces): string;
        private initFont;
        loadFont(srcFace: Face, documentFaces: DocumentFaces): TaskUtil.Fetcher<Face>;
        findOrLoadFonts(srcFaces: Face[], documentFaces: DocumentFaces): Task.Result<boolean>;
    }
}
declare namespace Net_$0 {
    enum XMLHttpRequestResponseType {
        DEFAULT = "",
        ARRAYBUFFER = "arraybuffer",
        BLOB = "blob",
        DOCUMENT = "document",
        JSON = "json",
        TEXT = "text"
    }
    type Response_$0 = Net.Response_$0;
    function ajax(url: string, opt_type?: XMLHttpRequestResponseType, opt_method?: string, opt_data?: string, opt_contentType?: string): Task.Result<Response_$0>;
    function makeBlob(parts: (string | Blob | ArrayBuffer | ArrayBufferView)[], opt_type?: string): any;
    function readBlob(blob: Blob): any;
    function revokeObjectURL(url: string): void;
    function createObjectURL(blob: Blob): string;
    class ResourceStore_$0<Resource> implements Net.ResourceStore_$0<Resource> {
        readonly parser: (p1: Response_$0, p2: ResourceStore_$0<Resource>) => Task.Result<Resource>;
        readonly type: XMLHttpRequestResponseType;
        resources: {
            [key: string]: Resource;
        };
        fetchers: {
            [key: string]: TaskUtil.Fetcher<Resource>;
        };
        constructor(parser: (p1: Response_$0, p2: ResourceStore_$0<Resource>) => Task.Result<Resource>, type: XMLHttpRequestResponseType);
        load(url: string, opt_required?: boolean, opt_message?: string): Task.Result<Resource>;
        private fetchInner;
        fetch(url: string, opt_required?: boolean, opt_message?: string): TaskUtil.Fetcher<Resource>;
        get(url: string): XmlDoc.XMLDocHolder;
        delete(url: string): void;
    }
    type JSONStore = ResourceStore_$0<Base.JSON>;
    function parseJSONResource(response: Response_$0, store: JSONStore): Task.Result<Base.JSON>;
    function newJSONStore(): JSONStore;
}
declare namespace OPS {
    const uaStylesheetBaseFetcher: TaskUtil.Fetcher<boolean>;
    function loadUABase(): Task.Result<boolean>;
    type FontFace = {
        properties: CssCascade.ElementStyle;
        condition: Exprs.Val;
    };
    class Style {
        readonly store: OPSDocStore;
        readonly rootScope: Exprs.LexicalScope;
        readonly pageScope: Exprs.LexicalScope;
        readonly cascade: CssCascade.Cascade;
        readonly rootBox: PageMaster.RootPageBox;
        readonly fontFaces: FontFace[];
        readonly footnoteProps: CssCascade.ElementStyle;
        readonly flowProps: {
            [key: string]: CssCascade.ElementStyle;
        };
        readonly viewportProps: CssCascade.ElementStyle[];
        readonly pageProps: {
            [key: string]: CssCascade.ElementStyle;
        };
        fontDeobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null;
        validatorSet: CssValidator.ValidatorSet;
        constructor(store: OPSDocStore, rootScope: Exprs.LexicalScope, pageScope: Exprs.LexicalScope, cascade: CssCascade.Cascade, rootBox: PageMaster.RootPageBox, fontFaces: FontFace[], footnoteProps: CssCascade.ElementStyle, flowProps: {
            [key: string]: CssCascade.ElementStyle;
        }, viewportProps: CssCascade.ElementStyle[], pageProps: {
            [key: string]: CssCascade.ElementStyle;
        });
        sizeViewport(viewportWidth: number, viewportHeight: number, fontSize: number, pref?: Exprs.Preferences): {
            width: number;
            height: number;
            fontSize: number;
        };
    }
    class StyleInstance extends Exprs.Context implements CssStyler_$0.FlowListener, PageMaster.InstanceHolder, Vgen.StylerProducer {
        readonly style: Style;
        readonly xmldoc: XmlDoc_$0.XMLDocHolder;
        readonly viewport: Vgen.Viewport;
        readonly clientLayout: Vtree_$0.ClientLayout;
        readonly fontMapper: Font.Mapper;
        readonly customRenderer: Vgen.CustomRenderer;
        readonly fallbackMap: {
            [key: string]: string;
        };
        readonly pageNumberOffset: number;
        readonly documentURLTransformer: Base.DocumentURLTransformer;
        readonly counterStore: Counters.CounterStore;
        lang: string | null;
        primaryFlows: {
            [key: string]: boolean;
        };
        rootPageBoxInstance: PageMaster.RootPageBoxInstance;
        styler: CssStyler_$0.Styler;
        stylerMap: {
            [key: string]: CssStyler_$0.Styler;
        };
        currentLayoutPosition: Vtree_$0.LayoutPosition;
        layoutPositionAtPageStart: Vtree_$0.LayoutPosition;
        lookupOffset: number;
        faces: Font.DocumentFaces;
        pageBoxInstances: {
            [key: string]: PageMaster.PageBoxInstance;
        };
        pageManager: CssPage.PageManager;
        private rootPageFloatLayoutContext;
        pageBreaks: {
            [key: string]: boolean;
        };
        pageProgression: Constants.PageProgression | null;
        pageSheetSize: {
            [key: string]: {
                width: number;
                height: number;
            };
        };
        pageSheetHeight: number;
        pageSheetWidth: number;
        actualPageWidth: number;
        actualPageHeight: number;
        constructor(style: Style, xmldoc: XmlDoc_$0.XMLDocHolder, defaultLang: string | null, viewport: Vgen.Viewport, clientLayout: Vtree_$0.ClientLayout, fontMapper: Font.Mapper, customRenderer: Vgen.CustomRenderer, fallbackMap: {
            [key: string]: string;
        }, pageNumberOffset: number, documentURLTransformer: Base.DocumentURLTransformer, counterStore: Counters.CounterStore, pageProgression?: Constants.PageProgression);
        init(): Task.Result<boolean>;
        getStylerForDoc(xmldoc: XmlDoc_$0.XMLDocHolder): CssStyler_$0.AbstractStyler;
        registerInstance(key: string, instance: PageMaster.PageBoxInstance): void;
        lookupInstance(key: string): PageMaster.PageBoxInstance;
        encounteredFlowChunk(flowChunk: Vtree_$0.FlowChunk, flow: Vtree_$0.Flow): any;
        getConsumedOffset(flowPosition: Vtree_$0.FlowPosition): number;
        getPosition(layoutPosition?: Vtree_$0.LayoutPosition, noLookAhead?: boolean): number;
        dumpLocation(position: any): void;
        matchPageSide(side: string): boolean;
        updateStartSide(layoutPosition: Vtree_$0.LayoutPosition): void;
        selectPageMaster(cascadedPageStyle: CssCascade.ElementStyle): PageMaster.PageMasterInstance;
        flowChunkIsAfterParentFlowForcedBreak(flowChunk: Vtree_$0.FlowChunk): boolean;
        setFormattingContextToColumn(column: LayoutType.Column, flowName: string): void;
        layoutDeferredPageFloats(column: LayoutType.Column): Task.Result<boolean>;
        getLastAfterPositionIfDeferredFloatsExists(column: LayoutType.Column, newPosition: Vtree_$0.ChunkPosition | null): Vtree_$0.ChunkPosition | null;
        layoutColumn(column: LayoutType.Column, flowName: string): Task.Result<boolean>;
        createLayoutConstraint(pageFloatLayoutContext: PageFloats_$0.PageFloatLayoutContext): LayoutType.LayoutConstraint;
        private createAndLayoutColumn;
        setPagePageFloatLayoutContextContainer(pagePageFloatLayoutContext: PageFloats_$0.PageFloatLayoutContext, boxInstance: PageMaster.PageBoxInstance, layoutContainer: Vtree_$0.Container): void;
        getRegionPageFloatLayoutContext(pagePageFloatLayoutContext: PageFloats_$0.PageFloatLayoutContext, boxInstance: PageMaster.PageBoxInstance, layoutContainer: Vtree_$0.Container, flowName: string): PageFloats_$0.PageFloatLayoutContext;
        layoutFlowColumnsWithBalancing(page: Vtree_$0.Page, boxInstance: PageMaster.PageBoxInstance, offsetX: number, offsetY: number, exclusions: GeometryUtil.Shape[], pagePageFloatLayoutContext: PageFloats_$0.PageFloatLayoutContext, layoutContainer: Vtree_$0.Container, flowNameStr: string, columnCount: number): Task.Result<LayoutType.Column[]>;
        layoutFlowColumns(page: Vtree_$0.Page, boxInstance: PageMaster.PageBoxInstance, offsetX: number, offsetY: number, exclusions: GeometryUtil.Shape[], pagePageFloatLayoutContext: PageFloats_$0.PageFloatLayoutContext, regionPageFloatLayoutContext: PageFloats_$0.PageFloatLayoutContext, layoutContainer: Vtree_$0.Container, flowNameStr: string, columnCount: number, forceNonFitting: boolean): Task.Result<LayoutType.Column[] | null>;
        layoutContainer(page: Vtree_$0.Page, boxInstance: PageMaster.PageBoxInstance, parentContainer: HTMLElement, offsetX: number, offsetY: number, exclusions: GeometryUtil.Shape[], pagePageFloatLayoutContext: PageFloats_$0.PageFloatLayoutContext): Task.Result<boolean>;
        processLinger(): void;
        initLingering(): void;
        noMorePrimaryFlows(cp: Vtree_$0.LayoutPosition): boolean;
        layoutNextPage(page: Vtree_$0.Page, cp?: Vtree_$0.LayoutPosition): Task.Result<Vtree_$0.LayoutPosition>;
        private setPageSizeAndBleed;
    }
    class BaseParserHandler extends CssCascade.CascadeParserHandler {
        masterHandler: StyleParserHandler;
        insideRegion: boolean;
        constructor(masterHandler: StyleParserHandler, condition: Exprs.Val, parent: BaseParserHandler, regionId: string | null);
        startPageTemplateRule(): void;
        startPageMasterRule(name: string | null, pseudoName: string | null, classes: string[]): void;
        startWhenRule(expr: Css.Expr): void;
        startDefineRule(): void;
        startFontFaceRule(): void;
        startFlowRule(flowName: string): void;
        startViewportRule(): void;
        startFootnoteRule(pseudoelem: string | null): void;
        startRegionRule(): void;
        startPageRule(): void;
        startRuleBody(): void;
    }
    function processViewportMeta(meta: Element): string;
    class StyleParserHandler extends CssParser.DispatchParserHandler {
        readonly validatorSet: CssValidator.ValidatorSet;
        rootScope: Exprs.LexicalScope;
        pageScope: Exprs.LexicalScope;
        rootBox: PageMaster.RootPageBox;
        cascadeParserHandler: BaseParserHandler;
        regionCount: number;
        fontFaces: FontFace[];
        footnoteProps: CssCascade.ElementStyle;
        flowProps: {
            [key: string]: CssCascade.ElementStyle;
        };
        viewportProps: CssCascade.ElementStyle[];
        pageProps: {
            [key: string]: CssCascade.ElementStyle;
        };
        slave: BaseParserHandler;
        constructor(validatorSet: CssValidator.ValidatorSet);
        error(mnemonics: string, token: CssTokenizer.Token): void;
    }
    type StyleSource = {
        url: string;
        text: string | null;
        flavor: CssParser.StylesheetFlavor;
        classes: string | null;
        media: string | null;
    };
    function parseOPSResource(response: Net_$0.Response, store: XmlDoc_$0.XMLDocStore): Task.Result<XmlDoc_$0.XMLDocHolder>;
    class OPSDocStore extends Net_$0.ResourceStore<XmlDoc_$0.XMLDocHolder> {
        fontDeobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null;
        styleByKey: {
            [key: string]: Style;
        };
        styleFetcherByKey: {
            [key: string]: TaskUtil.Fetcher<Style>;
        };
        styleByDocURL: {
            [key: string]: Style;
        };
        triggersByDocURL: {
            [key: string]: Vtree_$0.Trigger[];
        };
        validatorSet: CssValidator.ValidatorSet;
        private styleSheets;
        private triggerSingleDocumentPreprocessing;
        constructor(fontDeobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null);
        init(authorStyleSheets: {
            url: string | null;
            text: string | null;
        }[] | null, userStyleSheets: {
            url: string | null;
            text: string | null;
        }[] | null): Task.Result<boolean>;
        getStyleForDoc(xmldoc: XmlDoc_$0.XMLDocHolder): Style;
        getTriggersForDoc(xmldoc: XmlDoc_$0.XMLDocHolder): Vtree_$0.Trigger[];
        private setStyleSheets;
        private clearStyleSheets;
        private addAuthorStyleSheet;
        private addUserStyleSheet;
        parseOPSResource(response: Net_$0.Response): Task.Result<XmlDoc_$0.XMLDocHolder>;
    }
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
declare namespace Toc {
    const bulletClosed = "\u25B8";
    const bulletOpen = "\u25BE";
    const bulletEmpty = "\u25B9";
    class TOCView implements Vgen.CustomRendererFactory {
        readonly store: OPS.OPSDocStore;
        readonly url: string;
        readonly lang: string | null;
        readonly clientLayout: Vtree_$0.ClientLayout;
        readonly fontMapper: Font.Mapper;
        readonly rendererFactory: Vgen.CustomRendererFactory;
        readonly fallbackMap: {
            [key: string]: string;
        };
        readonly documentURLTransformer: Base.DocumentURLTransformer;
        readonly counterStore: Counters.CounterStore;
        pref: Exprs.Preferences;
        page: Vtree_$0.Page;
        instance: OPS.StyleInstance;
        constructor(store: OPS.OPSDocStore, url: string, lang: string | null, clientLayout: Vtree_$0.ClientLayout, fontMapper: Font.Mapper, pref: Exprs.Preferences, rendererFactory: Vgen.CustomRendererFactory, fallbackMap: {
            [key: string]: string;
        }, documentURLTransformer: Base.DocumentURLTransformer, counterStore: Counters.CounterStore);
        setAutoHeight(elem: Element, depth: number): void;
        makeCustomRenderer(xmldoc: XmlDoc_$0.XMLDocHolder): Vgen.CustomRenderer;
        showTOC(elem: HTMLElement, viewport: Vgen.Viewport, width: number, height: number, fontSize: number): Task.Result<Vtree_$0.Page>;
        hideTOC(): void;
        isTOCVisible(): boolean;
    }
    function toggleNodeExpansion(evt: Event): void;
}
declare namespace Vgen {
    const frontEdgeBlackListHor: {
        [key: string]: string;
    };
    const frontEdgeBlackListVert: {
        [key: string]: string;
    };
    const frontEdgeUnforcedBreakBlackListHor: {
        [key: string]: string;
    };
    const frontEdgeUnforcedBreakBlackListVert: {
        [key: string]: string;
    };
    type CustomRenderer = (p1: Element, p2: Element, p3: {
        [key: string]: Css.Val;
    }) => Task.Result<Element>;
    interface CustomRendererFactory {
        makeCustomRenderer(xmldoc: XmlDoc.XMLDocHolder): CustomRenderer;
    }
    function initIFrame(iframe: HTMLIFrameElement): void;
    interface StylerProducer {
        getStylerForDoc(xmldoc: XmlDoc.XMLDocHolder): CssStyler_$0.AbstractStyler;
    }
    class ViewFactory extends Base.SimpleEventTarget implements Vtree_$0.LayoutContext {
        readonly flowName: string;
        readonly context: Exprs.Context;
        readonly viewport: Viewport;
        readonly styler: CssStyler_$0.Styler;
        readonly regionIds: string[];
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly docFaces: Font.DocumentFaces;
        readonly footnoteStyle: CssCascade_$0.ElementStyle;
        readonly stylerProducer: StylerProducer;
        readonly page: Vtree_$0.Page;
        readonly customRenderer: CustomRenderer;
        readonly fallbackMap: {
            [key: string]: string;
        };
        readonly documentURLTransformer: Base.DocumentURLTransformer;
        private static SVG_URL_ATTRIBUTES;
        document: Document;
        exprContentListener: Vtree_$0.ExprContentListener;
        nodeContext: Vtree_$0.NodeContext | null;
        viewRoot: Element | null;
        isFootnote: boolean;
        sourceNode: Node | null;
        offsetInNode: number;
        viewNode: Node | null;
        constructor(flowName: string, context: Exprs.Context, viewport: Viewport, styler: CssStyler_$0.Styler, regionIds: string[], xmldoc: XmlDoc.XMLDocHolder, docFaces: Font.DocumentFaces, footnoteStyle: CssCascade_$0.ElementStyle, stylerProducer: StylerProducer, page: Vtree_$0.Page, customRenderer: CustomRenderer, fallbackMap: {
            [key: string]: string;
        }, documentURLTransformer: Base.DocumentURLTransformer);
        clone(): Vtree_$0.LayoutContext;
        createPseudoelementShadow(element: Element, isRoot: boolean, cascStyle: CssCascade_$0.ElementStyle, computedStyle: {
            [key: string]: Css.Val;
        }, styler: CssStyler_$0.AbstractStyler, context: Exprs.Context, parentShadow: Vtree_$0.ShadowContext, subShadow: Vtree_$0.ShadowContext): Vtree_$0.ShadowContext;
        getPseudoMap(cascStyle: CssCascade_$0.ElementStyle, regionIds: string[], isFootnote: boolean, nodeContext: Vtree_$0.NodeContext, context: Exprs.Context): {};
        createRefShadow(href: string, type: Vtree_$0.ShadowType, element: Element, parentShadow: Vtree_$0.ShadowContext, subShadow: Vtree_$0.ShadowContext): Task.Result<Vtree_$0.ShadowContext>;
        createShadows(element: Element, isRoot: any, cascStyle: CssCascade_$0.ElementStyle, computedStyle: {
            [key: string]: Css.Val;
        }, styler: CssStyler_$0.AbstractStyler, context: Exprs.Context, shadowContext: Vtree_$0.ShadowContext): Task.Result<Vtree_$0.ShadowContext>;
        setViewRoot(viewRoot: Element, isFootnote: boolean): void;
        computeStyle(vertical: boolean, rtl: boolean, style: CssCascade_$0.ElementStyle, computedStyle: {
            [key: string]: Css.Val;
        }): boolean;
        private inheritFromSourceParent;
        resolveURL(url: string): string;
        inheritLangAttribute(): void;
        transferPolyfilledInheritedProps(computedStyle: {
            [key: string]: Css.Val;
        }): void;
        resolveFormattingContext(nodeContext: Vtree_$0.NodeContext, firstTime: boolean, display: Css.Ident, position: Css.Ident, float: Css.Ident, isRoot: boolean): void;
        private createElementView;
        private processAfterIfcontinues;
        isSVGUrlAttribute(attributeName: string): boolean;
        modifyElemDimensionWithImageResolution(images: {
            image: HTMLElement;
            element: HTMLElement;
            fetcher: TaskUtil.Fetcher<string>;
        }[], imageResolution: number, computedStyle: {
            [key: string]: Css.Val;
        }, isVertical: boolean): void;
        private preprocessElementStyle;
        private findAndProcessRepeatingElements;
        private processRepeatOnBreak;
        private createTextNodeView;
        private preprocessTextContent;
        createNodeView(firstTime: boolean, atUnforcedBreak: boolean): Task.Result<boolean>;
        setCurrent(nodeContext: Vtree_$0.NodeContext, firstTime: boolean, atUnforcedBreak?: boolean): Task.Result<boolean>;
        processShadowContent(pos: Vtree_$0.NodeContext): Vtree_$0.NodeContext;
        private nextPositionInTree;
        isTransclusion(element: Element, elementStyle: CssCascade_$0.ElementStyle, transclusionType: string | null): boolean;
        nextInTree(position: Vtree_$0.NodeContext, atUnforcedBreak?: boolean): Task.Result<Vtree_$0.NodeContext>;
        addImageFetchers(bg: Css.Val): void;
        applyComputedStyles(target: Element, computedStyle: {
            [key: string]: Css.Val;
        }): void;
        applyPseudoelementStyle(nodeContext: Vtree_$0.NodeContext, pseudoName: string, target: Element): void;
        peelOff(nodeContext: Vtree_$0.NodeContext, nodeOffset: number): Task.Result<Vtree_$0.NodeContext>;
        createElement(ns: string, tag: string): Element;
        applyFootnoteStyle(vertical: boolean, rtl: boolean, target: Element): boolean;
        processFragmentedBlockEdge(nodeContext: Vtree_$0.NodeContext): void;
        convertLengthToPx(numeric: Css.Numeric, viewNode: Node, clientLayout: Vtree_$0.ClientLayout): number | Css.Numeric;
        isSameNodePositionStep(step1: Vtree_$0.NodePositionStep, step2: Vtree_$0.NodePositionStep): boolean;
        isSameNodePosition(nodePosition1: Vtree_$0.NodePosition, nodePosition2: Vtree_$0.NodePosition): boolean;
        isPseudoelement(elem: any): boolean;
    }
    const fb2Remap: {
        a: string;
        sub: string;
        sup: string;
        table: string;
        tr: string;
        td: string;
        th: string;
        code: string;
        body: string;
        p: string;
        v: string;
        date: string;
        emphasis: string;
        strong: string;
        style: string;
        strikethrough: string;
    };
    const propertiesNotPassedToDOM: {
        "box-decoration-break": boolean;
        "float-min-wrap-block": boolean;
        "float-reference": boolean;
        "flow-into": boolean;
        "flow-linger": boolean;
        "flow-options": boolean;
        "flow-priority": boolean;
        "footnote-policy": boolean;
        page: boolean;
    };
    class DefaultClientLayout implements Vtree_$0.ClientLayout {
        layoutBox: Element;
        window: Window;
        constructor(viewport: Viewport);
        private subtractOffsets;
        getRangeClientRects(range: Range): ClientRect[];
        getElementClientRect(element: Element): ClientRect;
        getElementComputedStyle(element: Element): CSSStyleDeclaration;
    }
    class Viewport {
        readonly window: Window;
        readonly fontSize: number;
        document: Document;
        root: HTMLElement;
        private outerZoomBox;
        contentContainer: HTMLElement;
        layoutBox: Element;
        width: number;
        height: number;
        constructor(window: Window, fontSize: number, opt_root?: HTMLElement, opt_width?: number, opt_height?: number);
        resetZoom(): void;
        zoom(width: number, height: number, scale: number): void;
        clear(): void;
    }
}
declare namespace Vtree_$0 {
    const delayedProps: {
        transform: boolean;
        "transform-origin": boolean;
    };
    const delayedPropsIfRelativePositioned: {
        top: boolean;
        bottom: boolean;
        left: boolean;
        right: boolean;
    };
    class DelayedItem {
        target: Element;
        name: string;
        value: Css.Val;
        constructor(target: Element, name: string, value: Css.Val);
    }
    type PageHyperlinkEvent = {
        type: string;
        target: any;
        currentTarget: any;
        anchorElement: Element;
        href: string;
    };
    type Trigger = {
        observer: string;
        event: string;
        action: string;
        ref: string;
    };
    const actions: {
        show: (obj: any) => void;
        hide: (obj: any) => void;
        play: (obj: any) => void;
        pause: (obj: any) => void;
        resume: (obj: any) => void;
        mute: (obj: any) => void;
        unmute: (obj: any) => void;
    };
    function makeListener(refs: Element[], action: string): EventListener | null;
    class Page extends Base.SimpleEventTarget {
        readonly container: HTMLElement;
        readonly bleedBox: HTMLElement;
        private static AUTO_PAGE_WIDTH_ATTRIBUTE;
        private static AUTO_PAGE_HEIGHT_ATTRIBUTE;
        pageAreaElement: HTMLElement | null;
        delayedItems: DelayedItem[];
        hrefHandler: (e: Event) => void;
        elementsById: {
            [key: string]: Element[];
        };
        dimensions: {
            width: number;
            height: number;
        };
        isFirstPage: boolean;
        isLastPage: boolean;
        isAutoPageWidth: boolean;
        isAutoPageHeight: boolean;
        spineIndex: number;
        position: LayoutPosition;
        offset: number;
        side: Constants.PageSide | null;
        fetchers: TaskUtil.Fetcher<{}>[];
        marginBoxes: {
            top: {
                [key: string]: Container_$0;
            };
            bottom: {
                [key: string]: Container_$0;
            };
            left: {
                [key: string]: Container_$0;
            };
            right: {
                [key: string]: Container_$0;
            };
        };
        constructor(container: HTMLElement, bleedBox: HTMLElement);
        setAutoPageWidth(isAuto: boolean): void;
        setAutoPageHeight(isAuto: boolean): void;
        registerElementWithId(element: Element, id: string): void;
        finish(triggers: Trigger[], clientLayout: ClientLayout_$0): void;
        zoom(scale: number): void;
        getPageAreaElement(): HTMLElement;
    }
    type Spread = {
        left: Page;
        right: Page;
    };
    const SPECIAL_ATTR = "data-adapt-spec";
    const Whitespace_$0: typeof Vtree.Whitespace_$0;
    type Whitespace_$0 = Vtree.Whitespace_$0;
    function whitespaceFromPropertyValue(whitespace: string): Whitespace_$0 | null;
    function canIgnore(node: Node, whitespace: Whitespace_$0): boolean;
    class Flow {
        readonly flowName: string;
        readonly parentFlowName: string | null;
        forcedBreakOffsets: number[];
        formattingContext: FormattingContext_$0 | null;
        constructor(flowName: string, parentFlowName: string | null);
    }
    class FlowChunk {
        flowName: string;
        element: Element;
        startOffset: number;
        priority: number;
        linger: number;
        exclusive: boolean;
        repeated: boolean;
        last: boolean;
        breakBefore: string | null;
        startPage: number;
        constructor(flowName: string, element: Element, startOffset: number, priority: number, linger: number, exclusive: boolean, repeated: boolean, last: boolean, breakBefore: string | null);
        isBetter(other: FlowChunk): boolean;
    }
    type ClientRect_$0 = Vtree.ClientRect_$0;
    function clientrectIncreasingTop(r1: ClientRect_$0, r2: ClientRect_$0): number;
    function clientrectDecreasingRight(r1: ClientRect_$0, r2: ClientRect_$0): number;
    type ClientLayout_$0 = Vtree.ClientLayout_$0;
    type LayoutContext_$0 = Vtree.LayoutContext_$0;
    type FormattingContext_$0 = Vtree.FormattingContext_$0;
    function eachAncestorFormattingContext(nodeContext: NodeContext_$0, callback: (p1: FormattingContext_$0) => any): void;
    type NodePositionStep_$0 = Vtree.NodePositionStep_$0;
    function isSameNodePositionStep(nps1: NodePositionStep_$0, nps2: NodePositionStep_$0): boolean;
    type NodePosition_$0 = Vtree.NodePosition_$0;
    function isSameNodePosition(np1: NodePosition_$0 | null, np2: NodePosition_$0 | null): boolean;
    function newNodePositionFromNode(node: Node): NodePosition_$0;
    function newNodePositionFromNodeContext(nodeContext: Vtree.NodeContext_$0, initialFragmentIndex: number | null): NodePosition_$0;
    function makeNodeContextFromNodePositionStep(step: NodePositionStep_$0, parent: Vtree.NodeContext_$0): NodeContext_$0;
    const ShadowType_$0: typeof Vtree.ShadowType_$0;
    type ShadowType_$0 = Vtree.ShadowType_$0;
    class ShadowContext_$0 implements Vtree.ShadowContext_$0 {
        readonly owner: Element;
        readonly root: Element;
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly parentShadow: ShadowContext_$0;
        readonly type: ShadowType_$0;
        readonly styler: object;
        subShadow: ShadowContext_$0;
        constructor(owner: Element, root: Element, xmldoc: XmlDoc.XMLDocHolder, parentShadow: ShadowContext_$0, superShadow: ShadowContext_$0, type: ShadowType_$0, styler: object);
        equals(other: ShadowContext_$0): boolean;
    }
    function isSameShadowContext(sc1: ShadowContext_$0, sc2: ShadowContext_$0): boolean;
    class FirstPseudo_$0 implements Vtree.FirstPseudo_$0 {
        readonly outer: FirstPseudo_$0;
        readonly count: number;
        constructor(outer: FirstPseudo_$0, count: number);
    }
    class NodeContext_$0 implements Vtree.NodeContext_$0 {
        sourceNode: Node;
        parent: NodeContext_$0;
        boxOffset: number;
        offsetInNode: number;
        after: boolean;
        shadowType: ShadowType_$0;
        shadowContext: ShadowContext_$0;
        nodeShadow: ShadowContext_$0;
        shadowSibling: NodeContext_$0;
        shared: boolean;
        inline: boolean;
        overflow: boolean;
        breakPenalty: number;
        display: string | null;
        floatReference: PageFloats.FloatReference;
        floatSide: string | null;
        clearSide: string | null;
        floatMinWrapBlock: Css.Numeric | null;
        columnSpan: Css.Val | null;
        verticalAlign: string;
        captionSide: string;
        inlineBorderSpacing: number;
        blockBorderSpacing: number;
        flexContainer: boolean;
        whitespace: Whitespace_$0;
        hyphenateCharacter: string | null;
        breakWord: boolean;
        establishesBFC: boolean;
        containingBlockForAbsolute: boolean;
        breakBefore: string | null;
        breakAfter: string | null;
        viewNode: Node;
        clearSpacer: Node;
        inheritedProps: {
            [key: string]: number | string | Css.Val;
        };
        vertical: boolean;
        direction: string;
        firstPseudo: FirstPseudo_$0;
        lang: string | null;
        preprocessedTextContent: Diff.Change[] | null;
        formattingContext: FormattingContext_$0;
        repeatOnBreak: string | null;
        pluginProps: {
            [key: string]: string | number | undefined | null | (number | null)[];
        };
        fragmentIndex: number;
        afterIfContinues: Selectors.AfterIfContinues;
        footnotePolicy: Css.Ident | null;
        constructor(sourceNode: Node, parent: NodeContext_$0, boxOffset: number);
        resetView(): void;
        private cloneItem;
        modify(): NodeContext_$0;
        copy(): NodeContext_$0;
        clone(): NodeContext_$0;
        toNodePositionStep(): NodePositionStep_$0;
        toNodePosition(): NodePosition_$0;
        isInsideBFC(): boolean;
        getContainingBlockForAbsolute(): NodeContext_$0;
        walkUpBlocks(callback: (p1: NodeContext_$0) => any): void;
        belongsTo(formattingContext: FormattingContext_$0): boolean;
    }
    class ChunkPosition_$0 implements Vtree.ChunkPosition_$0 {
        primary: NodePosition_$0;
        floats: NodePosition_$0[];
        constructor(primary: NodePosition_$0);
        clone(): ChunkPosition_$0;
        isSamePosition(other: ChunkPosition_$0): boolean;
    }
    class FlowChunkPosition {
        chunkPosition: ChunkPosition_$0;
        readonly flowChunk: FlowChunk;
        constructor(chunkPosition: ChunkPosition_$0, flowChunk: FlowChunk);
        clone(): FlowChunkPosition;
        isSamePosition(other: FlowChunkPosition): boolean;
    }
    class FlowPosition {
        positions: FlowChunkPosition[];
        startSide: string;
        breakAfter: string | null;
        clone(): FlowPosition;
        isSamePosition(other: FlowPosition): boolean;
        hasContent(offset: number): boolean;
    }
    class LayoutPosition {
        page: number;
        flows: {
            [key: string]: Flow;
        };
        flowPositions: {
            [key: string]: FlowPosition;
        };
        highestSeenOffset: number;
        highestSeenNode: Node;
        lookupPositionOffset: number;
        clone(): LayoutPosition;
        isSamePosition(other: LayoutPosition): boolean;
        hasContent(name: string, offset: number): boolean;
        startSideOfFlow(name: string): string;
        firstFlowChunkOfFlow(name: string): FlowChunk | null;
    }
    class Container_$0 implements Vtree.Container_$0 {
        element: Element;
        left: number;
        top: number;
        marginLeft: number;
        marginRight: number;
        marginTop: number;
        marginBottom: number;
        borderLeft: number;
        borderRight: number;
        borderTop: number;
        borderBottom: number;
        paddingLeft: number;
        paddingRight: number;
        paddingTop: number;
        paddingBottom: number;
        width: number;
        height: number;
        originX: number;
        originY: number;
        exclusions: GeometryUtil.Shape[];
        innerShape: GeometryUtil.Shape;
        computedBlockSize: number;
        snapWidth: number;
        snapHeight: number;
        snapOffsetX: number;
        snapOffsetY: number;
        vertical: boolean;
        constructor(element: Element);
        getInsetTop(): number;
        getInsetBottom(): number;
        getInsetLeft(): number;
        getInsetRight(): number;
        getInsetBefore(): number;
        getInsetAfter(): number;
        getInsetStart(): number;
        getInsetEnd(): number;
        getBeforeEdge(box: ClientRect_$0): number;
        getAfterEdge(box: ClientRect_$0): number;
        getStartEdge(box: ClientRect_$0): number;
        getEndEdge(box: ClientRect_$0): number;
        getInlineSize(box: ClientRect_$0): number;
        getBoxSize(box: ClientRect_$0): number;
        getBoxDir(): number;
        getInlineDir(): number;
        copyFrom(other: Container_$0): void;
        setVerticalPosition(top: number, height: number): void;
        setHorizontalPosition(left: number, width: number): void;
        setBlockPosition(start: number, extent: number): void;
        setInlinePosition(start: number, extent: number): void;
        clear(): void;
        getInnerShape(): GeometryUtil.Shape;
        getInnerRect(): GeometryUtil.Rect;
        getPaddingRect(): GeometryUtil.Rect;
        getOuterShape(outerShapeProp: Css.Val, context: Exprs.Context): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
    }
    type ExprContentListener_$0 = Vtree.ExprContentListener_$0;
    class ContentPropertyHandler extends Css.Visitor {
        readonly elem: Element;
        readonly context: Exprs.Context;
        readonly rootContentValue: Css.Val;
        readonly exprContentListener: ExprContentListener_$0;
        constructor(elem: Element, context: Exprs.Context, rootContentValue: Css.Val, exprContentListener: ExprContentListener_$0);
        private visitStrInner;
        visitStr(str: Css.Str): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function nonTrivialContent(val: Css.Val): boolean;
}
declare namespace XmlDoc_$0 {
    type XMLDocStore_$0 = XmlDoc.XMLDocStore_$0;
    const ELEMENT_OFFSET_ATTR = "data-adapt-eloff";
    class XMLDocHolder_$0 implements XmlDoc.XMLDocHolder_$0 {
        readonly store: XMLDocStore_$0;
        readonly url: string;
        readonly document: Document;
        lang: string | null;
        totalOffset: number;
        root: Element;
        body: Element;
        head: Element;
        last: Element;
        lastOffset: number;
        idMap: {
            [key: string]: Element;
        };
        constructor(store: XMLDocStore_$0, url: string, document: Document);
        doc(): XmlDoc.NodeList_$0;
        getElementOffset(element: Element): number;
        getNodeOffset(srcNode: Node, offsetInNode: number, after: boolean): number;
        getTotalOffset(): number;
        getNodeByOffset(offset: number): Node;
        private buildIdMap;
        getElement(url: string): Element | null;
    }
    enum DOMParserSupportedType {
        TEXT_HTML = "text/html",
        TEXT_XML = "text/xml",
        APPLICATION_XML = "application/xml",
        APPLICATION_XHTML_XML = "application/xhtml_xml",
        IMAGE_SVG_XML = "image/svg+xml"
    }
    function parseAndReturnNullIfError(str: string, type: string, opt_parser?: DOMParser): Document | null;
    function resolveContentType(response: Net_$0.Response): string | null;
    function parseXMLResource(response: Net_$0.Response, store: XMLDocStore_$0): Task.Result<XmlDoc.XMLDocHolder_$0>;
    function newXMLDocStore(): XMLDocStore_$0;
    class Predicate_$0 implements XmlDoc.Predicate_$0 {
        readonly fn: (p1: Node) => boolean;
        constructor(fn: (p1: Node) => boolean);
        check(node: Node): boolean;
        withAttribute(name: string, value: string): Predicate_$0;
        withChild(name: string, opt_childPredicate?: Predicate_$0): Predicate_$0;
    }
    const predicate: Predicate_$0;
    class NodeList_$0 implements XmlDoc.NodeList_$0 {
        readonly nodes: Node[];
        constructor(nodes: Node[]);
        asArray(): Node[];
        size(): number;
        predicate(pr: Predicate_$0): NodeList_$0;
        forEachNode(fn: (p1: Node, p2: (p1: Node) => void) => void): NodeList_$0;
        forEach<T>(fn: (p1: Node) => T): T[];
        forEachNonNull<T>(fn: (p1: Node) => T): T[];
        child(tag: string): NodeList_$0;
        childElements(): NodeList_$0;
        attribute(name: string): (string | null)[];
        textContent(): (string | null)[];
    }
}
declare namespace Base {
    let emptyObj: {};
    type JSON = any;
    function jsonToString(json: JSON): string;
    function stringToJSON(str: string): JSON;
    function stripFragment(url: string): string;
    function stripFragmentAndQuery(url: string): string;
    let baseURL: string;
    function setBaseURL(value: string): void;
    let resourceBaseURL: string;
    function setResourceBaseURL(value: string): void;
    function resolveURL(relURL: string, baseURL: string): string;
    function convertSpecialURL(url: string): string;
    interface DocumentURLTransformer {
        transformFragment(fragment: string, baseURL: string): string;
        transformURL(url: string, baseURL: string): string;
        restoreURL(encoded: string): string[];
    }
    enum NS {
        FB2 = "http://www.gribuser.ru/xml/fictionbook/2.0",
        epub = "http://www.idpf.org/2007/ops",
        EV = "http://www.w3.org/2001/xml-events",
        MATHML = "http://www.w3.org/1998/Math/MathML",
        XML = "http://www.w3.org/XML/1998/namespace",
        XHTML = "http://www.w3.org/1999/xhtml",
        XLINK = "http://www.w3.org/1999/xlink",
        SHADOW = "http://www.pyroxy.com/ns/shadow",
        SVG = "http://www.w3.org/2000/svg",
        DC = "http://purl.org/dc/elements/1.1/",
        NCX = "http://www.daisy.org/z3986/2005/ncx/",
        SSE = "http://example.com/sse"
    }
    function getURLParam(name: string, opt_url?: string): string | null;
    function setURLParam(url: string, name: string, value: string): string;
    function asString(v: any): any;
    interface Comparable {
        compare(other: Comparable): number;
    }
    class PriorityQueue {
        queue: Comparable[];
        length(): number;
        add(item: Comparable): void;
        peek(): Comparable;
        remove(): Comparable;
    }
    function cssToJSProp(prefix: string, cssPropName: string): string;
    const knownPrefixes: string[];
    const propNameMap: {};
    function checkIfPropertySupported(prefix: string, prop: string): boolean;
    function getPrefixedPropertyNames(prop: string): string[] | null;
    function setCSSProperty(elem: Element, prop: string, value: string): void;
    function getCSSProperty(elem: Element, prop: string, opt_value?: string): string;
    function getLangAttribute(element: Element): string;
    class StringBuffer {
        list: string[];
        append(str: string): StringBuffer;
        clear(): void;
        toString(): string;
    }
    function escapeChar(str: string): string;
    function escapeCSSIdent(name: string): string;
    function escapeCSSStr(str: string): string;
    function lightURLEncode(str: string): string;
    function isLetter(ch: string): boolean;
    function escapeCharToHex(str: string, prefix?: string): string;
    function escapeNameStrToHex(str: string, prefix?: string): string;
    function escapeRegExp(str: string): string;
    function unescapeCharFromHex(str: string, prefix?: string): string;
    function unescapeStrFromHex(str: string, prefix?: string): string;
    function binarySearch(high: number, good: (p1: number) => boolean): number;
    function numberCompare(a: number, b: number): number;
    const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    function appendBase64(sb: StringBuffer, data: string): void;
    function indexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T;
    };
    function arrayToSet(arr: string[]): {
        [key: string]: boolean;
    };
    function multiIndexArray<T>(arr: T[], key: (p1: T) => string | null): {
        [key: string]: T[];
    };
    function mapObj<P, R>(obj: {
        [key: string]: P;
    }, fn: (p1: P, p2: string) => R): {
        [key: string]: R;
    };
    function mapSize(obj: object): number;
    type Event = {
        type: string;
        target?: any;
        currentTarget?: any;
        preventDefault?: any;
        newPage?: any;
        anchorElement?: any;
        href?: any;
        content?: any;
    };
    type EventListener = (p1: Event) => void;
    class SimpleEventTarget {
        listeners: {
            [key: string]: EventListener[];
        };
        dispatchEvent(evt: Event): void;
        addEventListener(type: string, listener: EventListener, capture?: boolean): void;
        removeEventListener(type: string, listener: EventListener, capture?: boolean): void;
    }
    type EventTarget = SimpleEventTarget;
    let hasLShapeFloatBug: boolean | null;
    function checkLShapeFloatBug(body: HTMLElement): boolean;
    let hasVerticalBBoxBug: boolean | null;
    function checkVerticalBBoxBug(body: HTMLElement): boolean;
    let hasInlineBlockJustificationBug: boolean | null;
    function checkInlineBlockJustificationBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityAfterHyphenBug: boolean | null;
    function checkSoftWrapOpportunityAfterHyphenBug(body: HTMLElement): boolean;
    let hasSoftWrapOpportunityByWbrBug: boolean | null;
    function checkSoftWrapOpportunityByWbrBug(body: HTMLElement): boolean;
}
declare namespace Constants {
    let isDebug: boolean;
    function setDebug(value: boolean): void;
    enum PageProgression {
        LTR = "ltr",
        RTL = "rtl"
    }
    function pageProgressionOf(str: string): PageProgression;
    enum PageSide {
        LEFT = "left",
        RIGHT = "right"
    }
    enum ReadyState {
        LOADING = "loading",
        INTERACTIVE = "interactive",
        COMPLETE = "complete"
    }
    const constants: {
        PageProgression: typeof PageProgression;
        PageSide: typeof PageSide;
        ReadyState: typeof ReadyState;
    };
}
declare namespace Epub {
    type Position_$0 = {
        spineIndex: number;
        pageIndex: number;
        offsetInItem: number;
    };
    class EPUBDocStore extends OPS.OPSDocStore {
        plainXMLStore: XmlDoc_$0.XMLDocStore;
        jsonStore: Net_$0.JSONStore;
        opfByURL: {
            [key: string]: OPFDoc;
        };
        primaryOPFByEPubURL: {
            [key: string]: OPFDoc;
        };
        deobfuscators: {
            [key: string]: (p1: Blob) => Task.Result<Blob>;
        };
        documents: {
            [key: string]: Task.Result<XmlDoc_$0.XMLDocHolder>;
        };
        constructor();
        makeDeobfuscatorFactory(): ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null;
        loadAsPlainXML(url: string, opt_required?: boolean, opt_message?: string): Task.Result<XmlDoc_$0.XMLDocHolder>;
        startLoadingAsPlainXML(url: string): void;
        loadAsJSON(url: string, opt_required?: boolean, opt_message?: string): Task.Result<Base.JSON>;
        startLoadingAsJSON(url: string): void;
        loadPubDoc(url: string, haveZipMetadata: boolean): Task.Result<OPFDoc>;
        loadEPUBDoc(url: string, haveZipMetadata: boolean): Task.Result<OPFDoc>;
        loadOPF(pubURL: string, root: string, haveZipMetadata: boolean): Task.Result<OPFDoc>;
        loadWebPub(url: string): Task.Result<OPFDoc>;
        addDocument(url: string, doc: Document): Task.Result<XmlDoc_$0.XMLDocHolder>;
        load(url: string): Task.Result<XmlDoc_$0.XMLDocHolder>;
    }
    type OPFItemParam = {
        url: string;
        index: number;
        startPage: number | null;
        skipPagesBefore: number | null;
    };
    class OPFItem {
        id: string | null;
        src: string;
        mediaType: string | null;
        title: string | null;
        itemRefElement: Element | null;
        spineIndex: number;
        compressedSize: number;
        compressed: boolean | null;
        epage: number;
        epageCount: number;
        startPage: number | null;
        skipPagesBefore: number | null;
        itemProperties: {
            [key: string]: boolean;
        };
        constructor();
        initWithElement(itemElem: Element, opfURL: string): void;
        initWithParam(param: OPFItemParam): void;
    }
    function getOPFItemId(item: OPFItem): string | null;
    function makeDeobfuscator(uid: string): (p1: Blob) => Task.Result<Blob>;
    function makeObfuscationKey(uid: string): string;
    type RawMetaItem = {
        name: string;
        value: string;
        id: string | null;
        refines: string | null;
        scheme: string | null;
        lang: string | null;
        order: number;
    };
    const predefinedPrefixes: {
        dcterms: string;
        marc: string;
        media: string;
        rendition: string;
        onix: string;
        xsd: string;
    };
    const defaultIRI = "http://idpf.org/epub/vocab/package/#";
    const metaTerms: {
        language: string;
        title: string;
        creator: string;
        layout: string;
        titleType: string;
        displaySeq: string;
        alternateScript: string;
    };
    function getMetadataComparator(term: string, lang: string): (p1: Base.JSON, p2: Base.JSON) => number;
    function readMetadata(mroot: XmlDoc_$0.NodeList, prefixes: string | null): Base.JSON;
    function getMathJaxHub(): object;
    function checkMathJax(): void;
    const supportedMediaTypes: {
        "application/xhtml+xml": boolean;
        "image/jpeg": boolean;
        "image/png": boolean;
        "image/svg+xml": boolean;
        "image/gif": boolean;
        "audio/mp3": boolean;
    };
    const transformedIdPrefix = "viv-id-";
    class OPFDoc {
        readonly store: EPUBDocStore;
        readonly pubURL: string;
        opfXML: XmlDoc_$0.XMLDocHolder;
        encXML: XmlDoc_$0.XMLDocHolder;
        items: OPFItem[];
        spine: OPFItem[];
        itemMap: {
            [key: string]: OPFItem;
        };
        itemMapByPath: {
            [key: string]: OPFItem;
        };
        uid: string | null;
        bindings: {
            [key: string]: string;
        };
        lang: string | null;
        epageCount: number;
        prePaginated: boolean;
        epageIsRenderedPage: boolean;
        epageCountCallback: (p1: number) => void | null;
        metadata: Base.JSON;
        ncxToc: OPFItem;
        xhtmlToc: OPFItem;
        cover: OPFItem;
        fallbackMap: {
            [key: string]: string;
        };
        pageProgression: Constants.PageProgression | null;
        documentURLTransformer: Base.DocumentURLTransformer;
        constructor(store: EPUBDocStore, pubURL: string);
        createDocumentURLTransformer(): Base.DocumentURLTransformer;
        getMetadata(): Base.JSON;
        getPathFromURL(url: string): string | null;
        initWithXMLDoc(opfXML: XmlDoc_$0.XMLDocHolder, encXML: XmlDoc_$0.XMLDocHolder, zipMetadata: Base.JSON, manifestURL: string): Task.Result<any>;
        assignAutoPages(): void;
        setEPageCountMode(epageIsRenderedPage: boolean): void;
        countEPages(epageCountCallback: ((p1: number) => void) | null): Task.Result<boolean>;
        initWithChapters(params: OPFItemParam[], doc?: Document | null): Task.Result<any>;
        initWithWebPubManifest(manifestObj: Base.JSON, doc?: Document): Task.Result<boolean>;
        getCFI(spineIndex: number, offsetInItem: number): Task.Result<string | null>;
        resolveFragment(fragstr: string | null): Task.Result<Position_$0 | null>;
        resolveEPage(epage: number): Task.Result<Position_$0 | null>;
        getEPageFromPosition(position: Position_$0): Task.Result<number>;
    }
    type PageAndPosition = {
        page: Vtree_$0.Page;
        position: Position_$0;
    };
    const makePageAndPosition: (page: Vtree_$0.Page, pageIndex: number) => PageAndPosition;
    type OPFViewItem = {
        item: OPFItem;
        xmldoc: XmlDoc_$0.XMLDocHolder;
        instance: OPS.StyleInstance;
        layoutPositions: Vtree_$0.LayoutPosition[];
        pages: Vtree_$0.Page[];
        complete: boolean;
    };
    class OPFView implements Vgen.CustomRendererFactory {
        readonly opf: OPFDoc;
        readonly viewport: Vgen.Viewport;
        readonly fontMapper: Font.Mapper;
        readonly pageSheetSizeReporter: (p1: {
            width: number;
            height: number;
        }, p2: {
            [key: string]: {
                width: number;
                height: number;
            };
        }, p3: number, p4: number) => any;
        spineItems: OPFViewItem[];
        spineItemLoadingContinuations: Task.Continuation<any>[][];
        pref: Exprs.Preferences;
        clientLayout: Vgen.DefaultClientLayout;
        counterStore: Counters.CounterStore;
        tocAutohide: boolean;
        tocView?: Toc.TOCView;
        constructor(opf: OPFDoc, viewport: Vgen.Viewport, fontMapper: Font.Mapper, pref: Exprs.Preferences, pageSheetSizeReporter: (p1: {
            width: number;
            height: number;
        }, p2: {
            [key: string]: {
                width: number;
                height: number;
            };
        }, p3: number, p4: number) => any);
        private getPage;
        getCurrentPageProgression(position: Position_$0): Constants.PageProgression | null;
        private finishPageContainer;
        private renderSinglePage;
        private normalizeSeekPosition;
        private findPage;
        renderPage(position: Position_$0): Task.Result<PageAndPosition | null>;
        renderAllPages(): Task.Result<PageAndPosition | null>;
        renderPagesUpto(position: Position_$0, notAllPages: boolean): Task.Result<PageAndPosition | null>;
        firstPage(position: Position_$0, sync: boolean): Task.Result<PageAndPosition | null>;
        lastPage(position: Position_$0, sync: boolean): Task.Result<PageAndPosition | null>;
        nextPage(position: Position_$0, sync: boolean): Task.Result<PageAndPosition | null>;
        previousPage(position: Position_$0, sync: boolean): Task.Result<PageAndPosition | null>;
        private isRectoPage;
        getSpread(position: Position_$0, sync: boolean): Task.Result<Vtree_$0.Spread>;
        nextSpread(position: Position_$0, sync: boolean): Task.Result<PageAndPosition | null>;
        previousSpread(position: Position_$0, sync: boolean): Task.Result<PageAndPosition | null>;
        navigateToEPage(epage: number, position: Position_$0, sync: boolean): Task.Result<PageAndPosition | null>;
        navigateToFragment(fragment: string, position: Position_$0, sync: boolean): Task.Result<PageAndPosition | null>;
        navigateTo(href: string, position: Position_$0, sync: boolean): Task.Result<PageAndPosition | null>;
        makePage(viewItem: OPFViewItem, pos: Vtree_$0.LayoutPosition): Vtree_$0.Page;
        makeObjectView(xmldoc: XmlDoc_$0.XMLDocHolder, srcElem: Element, viewParent: Element, computedStyle: {
            [key: string]: Css.Val;
        }): Task.Result<Element>;
        makeMathJaxView(xmldoc: XmlDoc_$0.XMLDocHolder, srcElem: Element, viewParent: Element, computedStyle: {
            [key: string]: Css.Val;
        }): Task.Result<Element>;
        private resolveURLsInMathML;
        makeSSEView(xmldoc: XmlDoc_$0.XMLDocHolder, srcElem: Element, viewParent: Element, computedStyle: {
            [key: string]: Css.Val;
        }): Task.Result<Element>;
        makeCustomRenderer(xmldoc: XmlDoc_$0.XMLDocHolder): Vgen.CustomRenderer;
        getPageViewItem(spineIndex: number): Task.Result<OPFViewItem>;
        removeRenderedPages(): void;
        hasAutoSizedPages(): boolean;
        hasPages(): boolean;
        showTOC(autohide: boolean): Task.Result<Vtree_$0.Page>;
        hideTOC(): void;
        isTOCVisible(): boolean;
    }
    interface RenderSinglePageResult {
        pageAndPosition: PageAndPosition;
        nextLayoutPosition: Vtree_$0.LayoutPosition;
    }
}
declare namespace Exprs {
    type Preferences = {
        fontFamily: string;
        lineHeight: number;
        margin: number;
        hyphenate: boolean;
        columnWidth: number;
        horizontal: boolean;
        nightMode: boolean;
        spreadView: boolean;
        pageBorder: number;
        enabledMediaTypes: {
            [key: string]: boolean;
        };
        defaultPaperSize?: {
            [key: string]: number;
        };
    };
    function defaultPreferences(): Preferences;
    function clonePreferences(pref: Preferences): Preferences;
    const defaultPreferencesInstance: Preferences;
    const Special: {
        PENDING: Pending;
    };
    type Result = string | number | boolean | undefined;
    type PendingResult = Special | Result;
    function letterbox(viewW: number, viewH: number, objW: number, objH: number): string;
    function cssString(str: string): string;
    function cssIdent(name: string): string;
    function makeQualifiedName(objName: string | null, memberName: string): string;
    let nextKeyIndex: number;
    class LexicalScope {
        parent: LexicalScope;
        resolver?: (p1: string, p2: boolean) => Val;
        scopeKey: string;
        children: LexicalScope[];
        zero: Const;
        one: Const;
        _true: Const;
        _false: Const;
        values: {
            [key: string]: Val;
        };
        funcs: {
            [key: string]: Val;
        };
        builtIns: {
            [key: string]: (...p1: Result[]) => Result;
        };
        constructor(parent: LexicalScope, resolver?: (p1: string, p2: boolean) => Val);
        defineBuiltInName(name: string, fn: () => Result): void;
        defineName(qualifiedName: string, val: Val): void;
        defineFunc(qualifiedName: string, val: Val): void;
        defineBuiltIn(qualifiedName: string, fn: (...p1: Result[]) => Result): void;
    }
    function isAbsoluteLengthUnit(unit: string): boolean;
    function isViewportRelativeLengthUnit(unit: string): boolean;
    function isFontRelativeLengthUnit(unit: string): boolean;
    const defaultUnitSizes: {
        [key: string]: number;
    };
    function needUnitConversion(unit: string): boolean;
    type ScopeContext = {
        [key: string]: Result;
    };
    class Context {
        readonly rootScope: LexicalScope;
        readonly viewportWidth: number;
        readonly viewportHeight: number;
        protected actualPageWidth: number | null;
        pageWidth: () => number;
        protected actualPageHeight: number | null;
        pageHeight: () => number;
        initialFontSize: number;
        rootFontSize: number | null;
        fontSize: () => number;
        pref: Preferences;
        scopes: {
            [key: string]: ScopeContext;
        };
        pageAreaWidth: number | null;
        pageAreaHeight: number | null;
        pageVertical: boolean | null;
        pubTitle: string | null;
        docTitle: string | null;
        constructor(rootScope: LexicalScope, viewportWidth: number, viewportHeight: number, fontSize: number);
        private getScopeContext;
        clearScope(scope: LexicalScope): void;
        queryUnitSize(unit: string, isRoot: boolean): number;
        evalName(scope: LexicalScope, qualifiedName: string): Val;
        evalCall(scope: LexicalScope, qualifiedName: string, params: Val[], noBuiltInEval: boolean): Val;
        evalMediaName(name: string, not: boolean): boolean;
        evalMediaTest(feature: string, value: Val): boolean;
        queryVal(scope: LexicalScope, key: string): Result | undefined;
        storeVal(scope: LexicalScope, key: string, val: Result): void;
    }
    type DependencyCache = {
        [key: string]: boolean | Special;
    };
    class Val {
        scope: LexicalScope;
        key: string;
        constructor(scope: LexicalScope);
        toString(): string;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        expand(context: Context, params: Val[]): Val;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        dependOuter(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        depend(other: Val, context: Context): boolean;
        evaluate(context: Context): Result;
        isMediaName(): boolean;
    }
    class Prefix extends Val {
        val: Val;
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Infix extends Val {
        lhs: Val;
        rhs: Val;
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    class Logical extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Comparison extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Additive extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Multiplicative extends Infix {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getPriority(): number;
    }
    class Not extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class Negate extends Prefix {
        constructor(scope: LexicalScope, val: Val);
        getOp(): string;
        evalPrefix(val: Result): Result;
    }
    class And extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class AndMedia extends And {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Or extends Logical {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evaluateCore(context: Context): Result;
    }
    class OrMedia extends Or {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
    }
    class Lt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Le extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Gt extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ge extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Eq extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Ne extends Comparison {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Add extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Subtract extends Additive {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Multiply extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Divide extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Modulo extends Multiplicative {
        constructor(scope: LexicalScope, lhs: Val, rhs: Val);
        getOp(): string;
        evalInfix(lhs: Result, rhs: Result): Result;
    }
    class Numeric extends Val {
        num: number;
        unit: string;
        constructor(scope: LexicalScope, num: number, unit: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class Named extends Val {
        qualifiedName: string;
        constructor(scope: LexicalScope, qualifiedName: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    }
    class MediaName extends Val {
        not: boolean;
        name: string;
        value: Val;
        constructor(scope: LexicalScope, not: boolean, name: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        isMediaName(): boolean;
    }
    class Native extends Val {
        fn: () => Result;
        str: string;
        constructor(scope: LexicalScope, fn: () => Result, str: string);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    function appendValArray(buf: Base.StringBuffer, arr: Val[]): void;
    function expandValArray(context: Context, arr: Val[], params: Val[]): Val[];
    function evalValArray(context: Context, arr: Val[]): Result[];
    class Call extends Val {
        qualifiedName: string;
        params: Val[];
        constructor(scope: LexicalScope, qualifiedName: string, params: Val[]);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Cond extends Val {
        cond: Val;
        ifTrue: Val;
        ifFalse: Val;
        constructor(scope: LexicalScope, cond: Val, ifTrue: Val, ifFalse: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Const extends Val {
        val: Result;
        constructor(scope: LexicalScope, val: Result);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
    }
    class MediaTest extends Val {
        name: MediaName;
        value: Val;
        constructor(scope: LexicalScope, name: MediaName, value: Val);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        evaluateCore(context: Context): Result;
        dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
        expand(context: Context, params: Val[]): Val;
    }
    class Param extends Val {
        index: number;
        constructor(scope: LexicalScope, index: number);
        appendTo(buf: Base.StringBuffer, priority: number): void;
        expand(context: Context, params: Val[]): Val;
    }
    function and(scope: LexicalScope, v1: Val, v2: Val): Val;
    function add(scope: LexicalScope, v1: Val, v2: Val): Val;
    function sub(scope: LexicalScope, v1: Val, v2: Val): Val;
    function mul(scope: LexicalScope, v1: Val, v2: Val): Val;
    function div(scope: LexicalScope, v1: Val, v2: Val): Val;
}
declare namespace Font {
    const traitProps: {
        [key: string]: Css.Val;
    };
    const bogusFontData: string;
    let bogusFontCounter: number;
    function makeFontTraitKey(properties: {
        [key: string]: Css.Val;
    }): string;
    function fillDefaults(properties: {
        [key: string]: Css.Val;
    }): void;
    function prepareProperties(properties: CssCascade_$0.ElementStyle, context: Exprs.Context): {
        [key: string]: Css.Val;
    };
    class Face {
        readonly properties: {
            [key: string]: Css.Val;
        };
        fontTraitKey: string;
        src: string | null;
        blobURLs: string[];
        blobs: Blob[];
        family: string | null;
        constructor(properties: {
            [key: string]: Css.Val;
        });
        traitsEqual(other: Face): boolean;
        makeAtRule(src: string, fontBytes: Blob): string;
    }
    class DocumentFaces {
        readonly deobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null;
        familyMap: {
            [key: string]: string;
        };
        constructor(deobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null);
        registerFamily(srcFace: Face, viewFace: Face): void;
        filterFontFamily(val: Css.Val): Css.Val;
    }
    class Mapper {
        readonly head: Element;
        readonly body: Element;
        srcURLMap: {
            [key: string]: TaskUtil.Fetcher<Face>;
        };
        familyPrefix: string;
        familyCounter: number;
        constructor(head: Element, body: Element, opt_familyPrefix?: string);
        getViewFontFamily(srcFace: Face, documentFaces: DocumentFaces): string;
        private initFont;
        loadFont(srcFace: Face, documentFaces: DocumentFaces): TaskUtil.Fetcher<Face>;
        findOrLoadFonts(srcFaces: Face[], documentFaces: DocumentFaces): Task.Result<boolean>;
    }
}
declare namespace Task {
    interface Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    interface Result_$0<T> {
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    let privateCurrentTask: Task | null;
    let primaryScheduler: Scheduler | null;
    function currentTask(): Task | null;
    function newFrame<T>(name: string): Frame<T>;
    function newEventSource(): EventSource;
    function newScheduler(opt_timer?: Timer): Scheduler;
    function newResult<T>(opt_value: T): Result_$0<T>;
    function handle<T>(name: any, code: (p1: Frame<T>) => void, onErr: (p1: Frame<T>, p2: Error) => void): Result_$0<T>;
    function start<T>(func: () => Result_$0<T>, opt_name?: string): Task;
    enum FrameState {
        INIT = 0,
        ACTIVE = 1,
        FINISHED = 2,
        DEAD = 3
    }
    class TimerImpl implements Timer {
        currentTime(): number;
        setTimeout(fn: () => void, delay: number): number;
        clearTimeout(token: number): void;
    }
    class Scheduler {
        timer: Timer;
        timeout: number;
        slice: number;
        sliceOverTime: number;
        queue: Base.PriorityQueue;
        wakeupTime: number | null;
        timeoutToken: number | null;
        inTimeSlice: boolean;
        order: number;
        constructor(timer: Timer);
        setSlice(slice: number): void;
        setTimeout(timeout: number): void;
        isTimeSliceOver(): boolean;
        private arm;
        schedule(continuation: Continuation<any>, opt_delay?: number): void;
        private doTimeSlice;
        run(func: () => Result_$0<any>, opt_name?: string): Task;
    }
    class Continuation<T> implements Base.Comparable {
        task: Task;
        scheduledTime: number;
        order: number;
        result: T;
        canceled: boolean;
        constructor(task: Task);
        compare(otherComp: Base.Comparable): number;
        getTask(): Task;
        schedule(result: T, opt_delay?: number): void;
        resumeInternal(): boolean;
        cancel(): void;
    }
    class Task {
        scheduler: Scheduler;
        name: string;
        callbacks: (() => void)[];
        exception: Error | null;
        running: boolean;
        result: any;
        waitTarget: string | null;
        top: Frame<any> | null;
        continuation: Continuation<any> | null;
        constructor(scheduler: Scheduler, name: string);
        getName(): string;
        interrupt(err: Error): void;
        getScheduler(): Scheduler;
        isRunning(): boolean;
        whenDone(callback: () => void): void;
        join(): Result_$0<any>;
        unwind(): void;
        raise(err: Error, opt_frame?: Frame<any>): void;
        fillStack(err: Error): void;
    }
    class SyncResultImpl<T> implements Result_$0<T> {
        value: T;
        constructor(value: T);
        then(callback: (T: any) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class ResultImpl<T> implements Result_$0<T> {
        readonly frame: Frame<T>;
        constructor(frame: Frame<T>);
        then(callback: (p1: T) => void): void;
        thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
        thenReturn<T1>(result: T1): Result_$0<any> | SyncResultImpl<T1>;
        thenFinish(frame: Frame<T>): void;
        isPending(): boolean;
        get(): T | null;
    }
    class Frame<T> {
        task: Task;
        parent: Frame<T>;
        name: string;
        res: T;
        state: FrameState;
        callback: ((p1: any) => void) | null;
        handler: ((p1: Frame<any>, p2: Error) => void) | null;
        constructor(task: Task, parent: Frame<T>, name: string);
        private checkEnvironment;
        result(): Result_$0<T>;
        finish(res: T): void;
        getTask(): Task;
        getName(): string;
        getScheduler(): Scheduler;
        then(callback: (p1: T) => void): void;
        timeSlice(): Result_$0<boolean>;
        sleep(delay: number): Result_$0<boolean>;
        loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
        loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
        suspend(opt_waitTarget?: any): Continuation<T>;
    }
    class LoopBodyFrame extends Frame<boolean> {
        constructor(task: Task, parent: Frame<boolean>);
        continueLoop(): void;
        breakLoop(): void;
    }
    class EventItem {
        event: Base.Event;
        next: EventItem;
        constructor(event: Base.Event);
    }
    class EventSource {
        continuation: Continuation<boolean>;
        listeners: {
            target: Base.EventTarget;
            type: string;
            listener: Base.EventListener;
        }[];
        head: EventItem;
        tail: EventItem;
        constructor();
        attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
        detach(target: Base.EventTarget, type: string): void;
        nextEvent(): Result_$0<Base.Event>;
    }
}
declare namespace Vgen {
    const frontEdgeBlackListHor: {
        [key: string]: string;
    };
    const frontEdgeBlackListVert: {
        [key: string]: string;
    };
    const frontEdgeUnforcedBreakBlackListHor: {
        [key: string]: string;
    };
    const frontEdgeUnforcedBreakBlackListVert: {
        [key: string]: string;
    };
    type CustomRenderer = (p1: Element, p2: Element, p3: {
        [key: string]: Css.Val;
    }) => Task.Result<Element>;
    interface CustomRendererFactory {
        makeCustomRenderer(xmldoc: XmlDoc.XMLDocHolder): CustomRenderer;
    }
    function initIFrame(iframe: HTMLIFrameElement): void;
    interface StylerProducer {
        getStylerForDoc(xmldoc: XmlDoc.XMLDocHolder): CssStyler_$0.AbstractStyler;
    }
    class ViewFactory extends Base.SimpleEventTarget implements Vtree_$0.LayoutContext {
        readonly flowName: string;
        readonly context: Exprs.Context;
        readonly viewport: Viewport;
        readonly styler: CssStyler_$0.Styler;
        readonly regionIds: string[];
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly docFaces: Font.DocumentFaces;
        readonly footnoteStyle: CssCascade_$0.ElementStyle;
        readonly stylerProducer: StylerProducer;
        readonly page: Vtree_$0.Page;
        readonly customRenderer: CustomRenderer;
        readonly fallbackMap: {
            [key: string]: string;
        };
        readonly documentURLTransformer: Base.DocumentURLTransformer;
        private static SVG_URL_ATTRIBUTES;
        document: Document;
        exprContentListener: Vtree_$0.ExprContentListener;
        nodeContext: Vtree_$0.NodeContext | null;
        viewRoot: Element | null;
        isFootnote: boolean;
        sourceNode: Node | null;
        offsetInNode: number;
        viewNode: Node | null;
        constructor(flowName: string, context: Exprs.Context, viewport: Viewport, styler: CssStyler_$0.Styler, regionIds: string[], xmldoc: XmlDoc.XMLDocHolder, docFaces: Font.DocumentFaces, footnoteStyle: CssCascade_$0.ElementStyle, stylerProducer: StylerProducer, page: Vtree_$0.Page, customRenderer: CustomRenderer, fallbackMap: {
            [key: string]: string;
        }, documentURLTransformer: Base.DocumentURLTransformer);
        clone(): Vtree_$0.LayoutContext;
        createPseudoelementShadow(element: Element, isRoot: boolean, cascStyle: CssCascade_$0.ElementStyle, computedStyle: {
            [key: string]: Css.Val;
        }, styler: CssStyler_$0.AbstractStyler, context: Exprs.Context, parentShadow: Vtree_$0.ShadowContext, subShadow: Vtree_$0.ShadowContext): Vtree_$0.ShadowContext;
        getPseudoMap(cascStyle: CssCascade_$0.ElementStyle, regionIds: string[], isFootnote: boolean, nodeContext: Vtree_$0.NodeContext, context: Exprs.Context): {};
        createRefShadow(href: string, type: Vtree_$0.ShadowType, element: Element, parentShadow: Vtree_$0.ShadowContext, subShadow: Vtree_$0.ShadowContext): Task.Result<Vtree_$0.ShadowContext>;
        createShadows(element: Element, isRoot: any, cascStyle: CssCascade_$0.ElementStyle, computedStyle: {
            [key: string]: Css.Val;
        }, styler: CssStyler_$0.AbstractStyler, context: Exprs.Context, shadowContext: Vtree_$0.ShadowContext): Task.Result<Vtree_$0.ShadowContext>;
        setViewRoot(viewRoot: Element, isFootnote: boolean): void;
        computeStyle(vertical: boolean, rtl: boolean, style: CssCascade_$0.ElementStyle, computedStyle: {
            [key: string]: Css.Val;
        }): boolean;
        private inheritFromSourceParent;
        resolveURL(url: string): string;
        inheritLangAttribute(): void;
        transferPolyfilledInheritedProps(computedStyle: {
            [key: string]: Css.Val;
        }): void;
        resolveFormattingContext(nodeContext: Vtree_$0.NodeContext, firstTime: boolean, display: Css.Ident, position: Css.Ident, float: Css.Ident, isRoot: boolean): void;
        private createElementView;
        private processAfterIfcontinues;
        isSVGUrlAttribute(attributeName: string): boolean;
        modifyElemDimensionWithImageResolution(images: {
            image: HTMLElement;
            element: HTMLElement;
            fetcher: TaskUtil.Fetcher<string>;
        }[], imageResolution: number, computedStyle: {
            [key: string]: Css.Val;
        }, isVertical: boolean): void;
        private preprocessElementStyle;
        private findAndProcessRepeatingElements;
        private processRepeatOnBreak;
        private createTextNodeView;
        private preprocessTextContent;
        createNodeView(firstTime: boolean, atUnforcedBreak: boolean): Task.Result<boolean>;
        setCurrent(nodeContext: Vtree_$0.NodeContext, firstTime: boolean, atUnforcedBreak?: boolean): Task.Result<boolean>;
        processShadowContent(pos: Vtree_$0.NodeContext): Vtree_$0.NodeContext;
        private nextPositionInTree;
        isTransclusion(element: Element, elementStyle: CssCascade_$0.ElementStyle, transclusionType: string | null): boolean;
        nextInTree(position: Vtree_$0.NodeContext, atUnforcedBreak?: boolean): Task.Result<Vtree_$0.NodeContext>;
        addImageFetchers(bg: Css.Val): void;
        applyComputedStyles(target: Element, computedStyle: {
            [key: string]: Css.Val;
        }): void;
        applyPseudoelementStyle(nodeContext: Vtree_$0.NodeContext, pseudoName: string, target: Element): void;
        peelOff(nodeContext: Vtree_$0.NodeContext, nodeOffset: number): Task.Result<Vtree_$0.NodeContext>;
        createElement(ns: string, tag: string): Element;
        applyFootnoteStyle(vertical: boolean, rtl: boolean, target: Element): boolean;
        processFragmentedBlockEdge(nodeContext: Vtree_$0.NodeContext): void;
        convertLengthToPx(numeric: Css.Numeric, viewNode: Node, clientLayout: Vtree_$0.ClientLayout): number | Css.Numeric;
        isSameNodePositionStep(step1: Vtree_$0.NodePositionStep, step2: Vtree_$0.NodePositionStep): boolean;
        isSameNodePosition(nodePosition1: Vtree_$0.NodePosition, nodePosition2: Vtree_$0.NodePosition): boolean;
        isPseudoelement(elem: any): boolean;
    }
    const fb2Remap: {
        a: string;
        sub: string;
        sup: string;
        table: string;
        tr: string;
        td: string;
        th: string;
        code: string;
        body: string;
        p: string;
        v: string;
        date: string;
        emphasis: string;
        strong: string;
        style: string;
        strikethrough: string;
    };
    const propertiesNotPassedToDOM: {
        "box-decoration-break": boolean;
        "float-min-wrap-block": boolean;
        "float-reference": boolean;
        "flow-into": boolean;
        "flow-linger": boolean;
        "flow-options": boolean;
        "flow-priority": boolean;
        "footnote-policy": boolean;
        page: boolean;
    };
    class DefaultClientLayout implements Vtree_$0.ClientLayout {
        layoutBox: Element;
        window: Window;
        constructor(viewport: Viewport);
        private subtractOffsets;
        getRangeClientRects(range: Range): ClientRect[];
        getElementClientRect(element: Element): ClientRect;
        getElementComputedStyle(element: Element): CSSStyleDeclaration;
    }
    class Viewport {
        readonly window: Window;
        readonly fontSize: number;
        document: Document;
        root: HTMLElement;
        private outerZoomBox;
        contentContainer: HTMLElement;
        layoutBox: Element;
        width: number;
        height: number;
        constructor(window: Window, fontSize: number, opt_root?: HTMLElement, opt_width?: number, opt_height?: number);
        resetZoom(): void;
        zoom(width: number, height: number, scale: number): void;
        clear(): void;
    }
}
declare namespace Vtree_$0 {
    const delayedProps: {
        transform: boolean;
        "transform-origin": boolean;
    };
    const delayedPropsIfRelativePositioned: {
        top: boolean;
        bottom: boolean;
        left: boolean;
        right: boolean;
    };
    class DelayedItem {
        target: Element;
        name: string;
        value: Css.Val;
        constructor(target: Element, name: string, value: Css.Val);
    }
    type PageHyperlinkEvent = {
        type: string;
        target: any;
        currentTarget: any;
        anchorElement: Element;
        href: string;
    };
    type Trigger = {
        observer: string;
        event: string;
        action: string;
        ref: string;
    };
    const actions: {
        show: (obj: any) => void;
        hide: (obj: any) => void;
        play: (obj: any) => void;
        pause: (obj: any) => void;
        resume: (obj: any) => void;
        mute: (obj: any) => void;
        unmute: (obj: any) => void;
    };
    function makeListener(refs: Element[], action: string): EventListener | null;
    class Page extends Base.SimpleEventTarget {
        readonly container: HTMLElement;
        readonly bleedBox: HTMLElement;
        private static AUTO_PAGE_WIDTH_ATTRIBUTE;
        private static AUTO_PAGE_HEIGHT_ATTRIBUTE;
        pageAreaElement: HTMLElement | null;
        delayedItems: DelayedItem[];
        hrefHandler: (e: Event) => void;
        elementsById: {
            [key: string]: Element[];
        };
        dimensions: {
            width: number;
            height: number;
        };
        isFirstPage: boolean;
        isLastPage: boolean;
        isAutoPageWidth: boolean;
        isAutoPageHeight: boolean;
        spineIndex: number;
        position: LayoutPosition;
        offset: number;
        side: Constants.PageSide | null;
        fetchers: TaskUtil.Fetcher<{}>[];
        marginBoxes: {
            top: {
                [key: string]: Container_$0;
            };
            bottom: {
                [key: string]: Container_$0;
            };
            left: {
                [key: string]: Container_$0;
            };
            right: {
                [key: string]: Container_$0;
            };
        };
        constructor(container: HTMLElement, bleedBox: HTMLElement);
        setAutoPageWidth(isAuto: boolean): void;
        setAutoPageHeight(isAuto: boolean): void;
        registerElementWithId(element: Element, id: string): void;
        finish(triggers: Trigger[], clientLayout: ClientLayout_$0): void;
        zoom(scale: number): void;
        getPageAreaElement(): HTMLElement;
    }
    type Spread = {
        left: Page;
        right: Page;
    };
    const SPECIAL_ATTR = "data-adapt-spec";
    const Whitespace_$0: typeof Vtree.Whitespace_$0;
    type Whitespace_$0 = Vtree.Whitespace_$0;
    function whitespaceFromPropertyValue(whitespace: string): Whitespace_$0 | null;
    function canIgnore(node: Node, whitespace: Whitespace_$0): boolean;
    class Flow {
        readonly flowName: string;
        readonly parentFlowName: string | null;
        forcedBreakOffsets: number[];
        formattingContext: FormattingContext_$0 | null;
        constructor(flowName: string, parentFlowName: string | null);
    }
    class FlowChunk {
        flowName: string;
        element: Element;
        startOffset: number;
        priority: number;
        linger: number;
        exclusive: boolean;
        repeated: boolean;
        last: boolean;
        breakBefore: string | null;
        startPage: number;
        constructor(flowName: string, element: Element, startOffset: number, priority: number, linger: number, exclusive: boolean, repeated: boolean, last: boolean, breakBefore: string | null);
        isBetter(other: FlowChunk): boolean;
    }
    type ClientRect_$0 = Vtree.ClientRect_$0;
    function clientrectIncreasingTop(r1: ClientRect_$0, r2: ClientRect_$0): number;
    function clientrectDecreasingRight(r1: ClientRect_$0, r2: ClientRect_$0): number;
    type ClientLayout_$0 = Vtree.ClientLayout_$0;
    type LayoutContext_$0 = Vtree.LayoutContext_$0;
    type FormattingContext_$0 = Vtree.FormattingContext_$0;
    function eachAncestorFormattingContext(nodeContext: NodeContext_$0, callback: (p1: FormattingContext_$0) => any): void;
    type NodePositionStep_$0 = Vtree.NodePositionStep_$0;
    function isSameNodePositionStep(nps1: NodePositionStep_$0, nps2: NodePositionStep_$0): boolean;
    type NodePosition_$0 = Vtree.NodePosition_$0;
    function isSameNodePosition(np1: NodePosition_$0 | null, np2: NodePosition_$0 | null): boolean;
    function newNodePositionFromNode(node: Node): NodePosition_$0;
    function newNodePositionFromNodeContext(nodeContext: Vtree.NodeContext_$0, initialFragmentIndex: number | null): NodePosition_$0;
    function makeNodeContextFromNodePositionStep(step: NodePositionStep_$0, parent: Vtree.NodeContext_$0): NodeContext_$0;
    const ShadowType_$0: typeof Vtree.ShadowType_$0;
    type ShadowType_$0 = Vtree.ShadowType_$0;
    class ShadowContext_$0 implements Vtree.ShadowContext_$0 {
        readonly owner: Element;
        readonly root: Element;
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly parentShadow: ShadowContext_$0;
        readonly type: ShadowType_$0;
        readonly styler: object;
        subShadow: ShadowContext_$0;
        constructor(owner: Element, root: Element, xmldoc: XmlDoc.XMLDocHolder, parentShadow: ShadowContext_$0, superShadow: ShadowContext_$0, type: ShadowType_$0, styler: object);
        equals(other: ShadowContext_$0): boolean;
    }
    function isSameShadowContext(sc1: ShadowContext_$0, sc2: ShadowContext_$0): boolean;
    class FirstPseudo_$0 implements Vtree.FirstPseudo_$0 {
        readonly outer: FirstPseudo_$0;
        readonly count: number;
        constructor(outer: FirstPseudo_$0, count: number);
    }
    class NodeContext_$0 implements Vtree.NodeContext_$0 {
        sourceNode: Node;
        parent: NodeContext_$0;
        boxOffset: number;
        offsetInNode: number;
        after: boolean;
        shadowType: ShadowType_$0;
        shadowContext: ShadowContext_$0;
        nodeShadow: ShadowContext_$0;
        shadowSibling: NodeContext_$0;
        shared: boolean;
        inline: boolean;
        overflow: boolean;
        breakPenalty: number;
        display: string | null;
        floatReference: PageFloats.FloatReference;
        floatSide: string | null;
        clearSide: string | null;
        floatMinWrapBlock: Css.Numeric | null;
        columnSpan: Css.Val | null;
        verticalAlign: string;
        captionSide: string;
        inlineBorderSpacing: number;
        blockBorderSpacing: number;
        flexContainer: boolean;
        whitespace: Whitespace_$0;
        hyphenateCharacter: string | null;
        breakWord: boolean;
        establishesBFC: boolean;
        containingBlockForAbsolute: boolean;
        breakBefore: string | null;
        breakAfter: string | null;
        viewNode: Node;
        clearSpacer: Node;
        inheritedProps: {
            [key: string]: number | string | Css.Val;
        };
        vertical: boolean;
        direction: string;
        firstPseudo: FirstPseudo_$0;
        lang: string | null;
        preprocessedTextContent: Diff.Change[] | null;
        formattingContext: FormattingContext_$0;
        repeatOnBreak: string | null;
        pluginProps: {
            [key: string]: string | number | undefined | null | (number | null)[];
        };
        fragmentIndex: number;
        afterIfContinues: Selectors.AfterIfContinues;
        footnotePolicy: Css.Ident | null;
        constructor(sourceNode: Node, parent: NodeContext_$0, boxOffset: number);
        resetView(): void;
        private cloneItem;
        modify(): NodeContext_$0;
        copy(): NodeContext_$0;
        clone(): NodeContext_$0;
        toNodePositionStep(): NodePositionStep_$0;
        toNodePosition(): NodePosition_$0;
        isInsideBFC(): boolean;
        getContainingBlockForAbsolute(): NodeContext_$0;
        walkUpBlocks(callback: (p1: NodeContext_$0) => any): void;
        belongsTo(formattingContext: FormattingContext_$0): boolean;
    }
    class ChunkPosition_$0 implements Vtree.ChunkPosition_$0 {
        primary: NodePosition_$0;
        floats: NodePosition_$0[];
        constructor(primary: NodePosition_$0);
        clone(): ChunkPosition_$0;
        isSamePosition(other: ChunkPosition_$0): boolean;
    }
    class FlowChunkPosition {
        chunkPosition: ChunkPosition_$0;
        readonly flowChunk: FlowChunk;
        constructor(chunkPosition: ChunkPosition_$0, flowChunk: FlowChunk);
        clone(): FlowChunkPosition;
        isSamePosition(other: FlowChunkPosition): boolean;
    }
    class FlowPosition {
        positions: FlowChunkPosition[];
        startSide: string;
        breakAfter: string | null;
        clone(): FlowPosition;
        isSamePosition(other: FlowPosition): boolean;
        hasContent(offset: number): boolean;
    }
    class LayoutPosition {
        page: number;
        flows: {
            [key: string]: Flow;
        };
        flowPositions: {
            [key: string]: FlowPosition;
        };
        highestSeenOffset: number;
        highestSeenNode: Node;
        lookupPositionOffset: number;
        clone(): LayoutPosition;
        isSamePosition(other: LayoutPosition): boolean;
        hasContent(name: string, offset: number): boolean;
        startSideOfFlow(name: string): string;
        firstFlowChunkOfFlow(name: string): FlowChunk | null;
    }
    class Container_$0 implements Vtree.Container_$0 {
        element: Element;
        left: number;
        top: number;
        marginLeft: number;
        marginRight: number;
        marginTop: number;
        marginBottom: number;
        borderLeft: number;
        borderRight: number;
        borderTop: number;
        borderBottom: number;
        paddingLeft: number;
        paddingRight: number;
        paddingTop: number;
        paddingBottom: number;
        width: number;
        height: number;
        originX: number;
        originY: number;
        exclusions: GeometryUtil.Shape[];
        innerShape: GeometryUtil.Shape;
        computedBlockSize: number;
        snapWidth: number;
        snapHeight: number;
        snapOffsetX: number;
        snapOffsetY: number;
        vertical: boolean;
        constructor(element: Element);
        getInsetTop(): number;
        getInsetBottom(): number;
        getInsetLeft(): number;
        getInsetRight(): number;
        getInsetBefore(): number;
        getInsetAfter(): number;
        getInsetStart(): number;
        getInsetEnd(): number;
        getBeforeEdge(box: ClientRect_$0): number;
        getAfterEdge(box: ClientRect_$0): number;
        getStartEdge(box: ClientRect_$0): number;
        getEndEdge(box: ClientRect_$0): number;
        getInlineSize(box: ClientRect_$0): number;
        getBoxSize(box: ClientRect_$0): number;
        getBoxDir(): number;
        getInlineDir(): number;
        copyFrom(other: Container_$0): void;
        setVerticalPosition(top: number, height: number): void;
        setHorizontalPosition(left: number, width: number): void;
        setBlockPosition(start: number, extent: number): void;
        setInlinePosition(start: number, extent: number): void;
        clear(): void;
        getInnerShape(): GeometryUtil.Shape;
        getInnerRect(): GeometryUtil.Rect;
        getPaddingRect(): GeometryUtil.Rect;
        getOuterShape(outerShapeProp: Css.Val, context: Exprs.Context): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
    }
    type ExprContentListener_$0 = Vtree.ExprContentListener_$0;
    class ContentPropertyHandler extends Css.Visitor {
        readonly elem: Element;
        readonly context: Exprs.Context;
        readonly rootContentValue: Css.Val;
        readonly exprContentListener: ExprContentListener_$0;
        constructor(elem: Element, context: Exprs.Context, rootContentValue: Css.Val, exprContentListener: ExprContentListener_$0);
        private visitStrInner;
        visitStr(str: Css.Str): Css.Val;
        visitURL(url: Css.URL): Css.Val;
        visitSpaceList(list: Css.SpaceList): Css.Val;
        visitExpr(expr: Css.Expr): Css.Val;
    }
    function nonTrivialContent(val: Css.Val): boolean;
}
declare namespace AdaptiveViewer {
    type Action_$0 = (p1: Base.JSON) => Task.Result<boolean>;
    type ViewportSize = {
        marginLeft: number;
        marginRight: number;
        marginTop: number;
        marginBottom: number;
        width: number;
        height: number;
    };
    const VIEWPORT_STATUS_ATTRIBUTE = "data-vivliostyle-viewer-status";
    const VIEWPORT_SPREAD_VIEW_ATTRIBUTE = "data-vivliostyle-spread-view";
    enum PageViewMode {
        SINGLE_PAGE = "singlePage",
        SPREAD = "spread",
        AUTO_SPREAD = "autoSpread"
    }
    type SingleDocumentParam = {
        url: string;
        startPage: number | null;
        skipPagesBefore: number | null;
    };
    class AdaptiveViewer {
        readonly window: Window;
        readonly viewportElement: HTMLElement;
        readonly instanceId: string;
        readonly callbackFn: (p1: Base.JSON) => void;
        fontMapper: Font.Mapper;
        kick: () => void;
        sendCommand: (p1: Base.JSON | string) => void;
        resizeListener: () => void;
        hyperlinkListener: Base.EventListener;
        pageRuleStyleElement: HTMLElement;
        pageSheetSizeAlreadySet: boolean;
        renderTask: Task.Task | null;
        actions: {
            [key: string]: Action_$0;
        };
        readyState: Constants.ReadyState;
        packageURL: string[];
        opf: Epub.OPFDoc;
        haveZipMetadata: boolean;
        touchActive: boolean;
        touchX: number;
        touchY: number;
        needResize: boolean;
        needRefresh: boolean;
        viewportSize: ViewportSize | null;
        currentPage: Vtree_$0.Page;
        currentSpread: Vtree_$0.Spread | null;
        pagePosition: Epub.Position | null;
        fontSize: number;
        zoom: number;
        fitToScreen: boolean;
        pageViewMode: PageViewMode;
        waitForLoading: boolean;
        renderAllPages: boolean;
        pref: Exprs.Preferences;
        pageSizes: {
            width: number;
            height: number;
        }[];
        viewport: Vgen.Viewport | null;
        opfView: Epub.OPFView;
        constructor(window: Window, viewportElement: HTMLElement, instanceId: string, callbackFn: (p1: Base.JSON) => void);
        private init;
        addLogListeners(): void;
        private callback;
        setReadyState(readyState: Constants.ReadyState): void;
        loadPublication(command: Base.JSON): Task.Result<boolean>;
        loadXML(command: Base.JSON): Task.Result<boolean>;
        private render;
        private resolveLength;
        configure(command: Base.JSON): Task.Result<boolean>;
        configurePlugins(command: Base.JSON): void;
        pageReplacedListener(evt: Base.Event): void;
        private forCurrentPages;
        private removePageListeners;
        private hidePages;
        private showSinglePage;
        private showPage;
        private showSpread;
        private reportPosition;
        private createViewport;
        private resolveSpreadView;
        private updateSpreadView;
        private sizeIsGood;
        private setPageSize;
        private setPageSizePageRules;
        removePageSizePageRules(): void;
        private reset;
        private showCurrent;
        setPageZoom(page: Vtree_$0.Page): void;
        setSpreadZoom(spread: Vtree_$0.Spread): void;
        getAdjustedZoomFactor(pageDimension: {
            width: number;
            height: number;
        }): number;
        getSpreadDimensions(spread: Vtree_$0.Spread): {
            width: number;
            height: number;
        };
        queryZoomFactor(type: ZoomType): number;
        calculateZoomFactorToFitInsideViewPort(pageDimension: {
            width: number;
            height: number;
        }): number;
        private cancelRenderingTask;
        resize(): Task.Result<boolean>;
        private sendLocationNotification;
        getCurrentPageProgression(): Constants.PageProgression | null;
        moveTo(command: Base.JSON): Task.Result<boolean>;
        showTOC(command: Base.JSON): Task.Result<boolean>;
        runCommand(command: Base.JSON): Task.Result<boolean>;
        initEmbed(cmd: Base.JSON | string): void;
    }
    enum ZoomType {
        FIT_INSIDE_VIEWPORT = "fit inside viewport"
    }
    function maybeParse(cmd: any): Base.JSON;
}
declare namespace Constants {
    let isDebug: boolean;
    function setDebug(value: boolean): void;
    enum PageProgression {
        LTR = "ltr",
        RTL = "rtl"
    }
    function pageProgressionOf(str: string): PageProgression;
    enum PageSide {
        LEFT = "left",
        RIGHT = "right"
    }
    enum ReadyState {
        LOADING = "loading",
        INTERACTIVE = "interactive",
        COMPLETE = "complete"
    }
    const constants: {
        PageProgression: typeof PageProgression;
        PageSide: typeof PageSide;
        ReadyState: typeof ReadyState;
    };
}
/**
 * Copyright 2015 Trim-marks Inc.
 * Copyright 2019 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 Constants
 */
/**
 * Debug flag.
 */
declare let isDebug: boolean;
declare function setDebug(value: boolean): void;
/**
 * Page progression direction.
 * @enum {string}
 */
declare enum PageProgression {
    LTR = "ltr",
    RTL = "rtl"
}
/**
 * Return PageProgression corresponding to the specified string
 */
declare function pageProgressionOf(str: string): PageProgression;
/**
 * Page side (left/right).
 * @enum {string}
 */
declare enum PageSide {
    LEFT = "left",
    RIGHT = "right"
}
/**
 * Viewer ready state.
 * @enum {string}
 */
declare enum ReadyState {
    LOADING = "loading",
    INTERACTIVE = "interactive",
    COMPLETE = "complete"
}
/**
 * Pubilc members of the bundled library.
 */
declare const constants: {
    PageProgression: typeof PageProgression;
    PageSide: typeof PageSide;
    ReadyState: typeof ReadyState;
};
declare type JSON = any;
interface Comparable {
    /**
     * @return -1 when this less then other, 0 when this equals other
     */
    compare(other: Comparable): number;
}
declare class StringBuffer {
    list: string[];
    append(str: string): StringBuffer;
    clear(): void;
    /**
     * @override
     */
    toString(): string;
}
declare type Event = {
    type: string;
    target?: any;
    currentTarget?: any;
    preventDefault?: any;
    newPage?: any;
    anchorElement?: any;
    href?: any;
    content?: any;
};
declare type EventListener = (p1: Event) => void;
/**
 * Extemely simple-minded EventTarget implementation. Consider using
 * goog.events.EventTarget if you are using Closure library.
 */
declare class SimpleEventTarget {
    listeners: {
        [key: string]: EventListener[];
    };
    dispatchEvent(evt: Event): void;
    addEventListener(type: string, listener: EventListener, capture?: boolean): void;
    removeEventListener(type: string, listener: EventListener, capture?: boolean): void;
}
declare type Preferences = {
    fontFamily: string;
    lineHeight: number;
    margin: number;
    hyphenate: boolean;
    columnWidth: number;
    horizontal: boolean;
    nightMode: boolean;
    spreadView: boolean;
    pageBorder: number;
    enabledMediaTypes: {
        [key: string]: boolean;
    };
    defaultPaperSize?: {
        [key: string]: number;
    };
};
interface Pending {
}
declare type Special = Pending;
/**
 * Special marker value that indicates that the expression result is being
 * calculated.
 */
declare const Special: {
    PENDING: Pending;
};
declare type Result = string | number | boolean | undefined;
/**
 * Lexical scope of the expression.
 */
declare class LexicalScope {
    parent: LexicalScope;
    resolver?: (p1: string, p2: boolean) => Val;
    scopeKey: string;
    children: LexicalScope[];
    zero: Const;
    one: Const;
    _true: Const;
    _false: Const;
    values: {
        [key: string]: Val;
    };
    funcs: {
        [key: string]: Val;
    };
    builtIns: {
        [key: string]: (...p1: Result[]) => Result;
    };
    constructor(parent: LexicalScope, resolver?: (p1: string, p2: boolean) => Val);
    defineBuiltInName(name: string, fn: () => Result): void;
    defineName(qualifiedName: string, val: Val): void;
    defineFunc(qualifiedName: string, val: Val): void;
    defineBuiltIn(qualifiedName: string, fn: (...p1: Result[]) => Result): void;
}
declare type ScopeContext = {
    [key: string]: Result;
};
/**
 * Run-time instance of a scope and its children.
 */
declare class Context {
    readonly rootScope: LexicalScope;
    readonly viewportWidth: number;
    readonly viewportHeight: number;
    protected actualPageWidth: number | null;
    pageWidth: () => number;
    protected actualPageHeight: number | null;
    pageHeight: () => number;
    initialFontSize: number;
    rootFontSize: number | null;
    fontSize: () => number;
    pref: Preferences;
    scopes: {
        [key: string]: ScopeContext;
    };
    pageAreaWidth: number | null;
    pageAreaHeight: number | null;
    pageVertical: boolean | null;
    pubTitle: string | null;
    docTitle: string | null;
    constructor(rootScope: LexicalScope, viewportWidth: number, viewportHeight: number, fontSize: number);
    private getScopeContext;
    clearScope(scope: LexicalScope): void;
    queryUnitSize(unit: string, isRoot: boolean): number;
    evalName(scope: LexicalScope, qualifiedName: string): Val;
    /**
     * @param noBuiltInEval don't evaluate built-ins (for dependency calculations)
     */
    evalCall(scope: LexicalScope, qualifiedName: string, params: Val[], noBuiltInEval: boolean): Val;
    evalMediaName(name: string, not: boolean): boolean;
    evalMediaTest(feature: string, value: Val): boolean;
    queryVal(scope: LexicalScope, key: string): Result | undefined;
    storeVal(scope: LexicalScope, key: string, val: Result): void;
}
declare type DependencyCache = {
    [key: string]: boolean | Special;
};
declare class Val {
    scope: LexicalScope;
    key: string;
    constructor(scope: LexicalScope);
    /**
     * @override
     */
    toString(): string;
    appendTo(buf: Base.StringBuffer, priority: number): void;
    protected evaluateCore(context: Context): Result;
    expand(context: Context, params: Val[]): Val;
    dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    dependOuter(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    depend(other: Val, context: Context): boolean;
    evaluate(context: Context): Result;
    isMediaName(): boolean;
}
declare class Prefix extends Val {
    val: Val;
    constructor(scope: LexicalScope, val: Val);
    protected getOp(): string;
    evalPrefix(val: Result): Result;
    /**
     * @override
     */
    evaluateCore(context: Context): Result;
    /**
     * @override
     */
    dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    /**
     * @override
     */
    appendTo(buf: Base.StringBuffer, priority: number): void;
    /**
     * @override
     */
    expand(context: Context, params: Val[]): Val;
}
declare class Infix extends Val {
    lhs: Val;
    rhs: Val;
    constructor(scope: LexicalScope, lhs: Val, rhs: Val);
    getPriority(): number;
    getOp(): string;
    evalInfix(lhs: Result, rhs: Result): Result;
    /**
     * @override
     */
    evaluateCore(context: Context): Result;
    /**
     * @override
     */
    dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    /**
     * @override
     */
    appendTo(buf: Base.StringBuffer, priority: number): void;
    /**
     * @override
     */
    expand(context: Context, params: Val[]): Val;
}
declare class Logical extends Infix {
    constructor(scope: LexicalScope, lhs: Val, rhs: Val);
    /**
     * @override
     */
    getPriority(): number;
}
declare class Comparison extends Infix {
    constructor(scope: LexicalScope, lhs: Val, rhs: Val);
    /**
     * @override
     */
    getPriority(): number;
}
declare class Additive extends Infix {
    constructor(scope: LexicalScope, lhs: Val, rhs: Val);
    /**
     * @override
     */
    getPriority(): number;
}
declare class Multiplicative extends Infix {
    constructor(scope: LexicalScope, lhs: Val, rhs: Val);
    /**
     * @override
     */
    getPriority(): number;
}
declare class And extends Logical {
    constructor(scope: LexicalScope, lhs: Val, rhs: Val);
    /**
     * @override
     */
    getOp(): string;
    /**
     * @override
     */
    evaluateCore(context: Context): Result;
}
declare class Or extends Logical {
    constructor(scope: LexicalScope, lhs: Val, rhs: Val);
    /**
     * @override
     */
    getOp(): string;
    /**
     * @override
     */
    evaluateCore(context: Context): Result;
}
/**
 * Named value.
 */
declare class MediaName extends Val {
    not: boolean;
    name: string;
    value: Val;
    constructor(scope: LexicalScope, not: boolean, name: string);
    /**
     * @override
     */
    appendTo(buf: Base.StringBuffer, priority: number): void;
    /**
     * @override
     */
    evaluateCore(context: Context): Result;
    /**
     * @override
     */
    dependCore(other: Val, context: Context, dependencyCache: DependencyCache): boolean;
    /**
     * @override
     */
    isMediaName(): boolean;
}
declare class Const extends Val {
    val: Result;
    constructor(scope: LexicalScope, val: Result);
    /**
     * @override
     */
    appendTo(buf: Base.StringBuffer, priority: number): void;
    /**
     * @override
     */
    evaluateCore(context: Context): Result;
}
declare class Visitor {
    /**
     * @return void
     */
    visitValues(values: Val_$0[]): any;
    visitEmpty(empty: Val_$0): Val_$0;
    visitSlash(slash: Val_$0): Val_$0;
    visitStr(str: Str): Val_$0;
    visitIdent(ident: Ident): Val_$0;
    visitNumeric(numeric: Numeric_$0): Val_$0;
    visitNum(num: Num): Val_$0;
    visitInt(num: Int): Val_$0;
    visitColor(color: Color): Val_$0;
    visitURL(url: URL): Val_$0;
    visitSpaceList(list: SpaceList): Val_$0;
    visitCommaList(list: CommaList): Val_$0;
    visitFunc(func: Func): Val_$0;
    visitExpr(expr: Expr): Val_$0;
}
declare class Val_$0 {
    /**
     * @override
     */
    toString(): string;
    stringValue(): string;
    toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
    appendTo(buf: Base.StringBuffer, toString: boolean): void;
    isExpr(): boolean;
    isNumeric(): boolean;
    isNum(): boolean;
    isIdent(): boolean;
    isSpaceList(): boolean;
    visit(visitor: any): any;
}
declare class Empty extends Val_$0 {
    private static empty;
    static get instance(): Empty;
    private constructor();
    /**
     * @override
     */
    toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
    /**
     * @override
     */
    appendTo(buf: Base.StringBuffer, toString: boolean): void;
    /**
     * @override
     */
    visit(visitor: any): any;
}
declare class Slash extends Val_$0 {
    private static slash;
    static get instance(): Slash;
    private constructor();
    /**
     * @override
     */
    toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
    /**
     * @override
     */
    appendTo(buf: Base.StringBuffer, toString: boolean): void;
    /**
     * @override
     */
    visit(visitor: any): any;
}
declare class Str extends Val_$0 {
    str: string;
    constructor(str: string);
    /**
     * @override
     */
    toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
    /**
     * @override
     */
    appendTo(buf: Base.StringBuffer, toString: boolean): void;
    /**
     * @override
     */
    visit(visitor: any): any;
}
declare class Ident extends Val_$0 {
    name: string;
    constructor(name: string);
    /**
     * @override
     */
    toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
    /**
     * @override
     */
    appendTo(buf: Base.StringBuffer, toString: boolean): void;
    /**
     * @override
     */
    visit(visitor: any): any;
    /**
     * @override
     */
    isIdent(): boolean;
}
declare class Numeric_$0 extends Val_$0 {
    num: number;
    unit: string;
    constructor(num: number, unit: string);
    /**
     * @override
     */
    toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
    /**
     * @override
     */
    appendTo(buf: Base.StringBuffer, toString: boolean): void;
    /**
     * @override
     */
    visit(visitor: any): any;
    /**
     * @override
     */
    isNumeric(): boolean;
}
declare class Num extends Val_$0 {
    num: number;
    constructor(num: number);
    /**
     * @override
     */
    toExpr(scope: Exprs.LexicalScope, ref: Exprs.Val_$0): Exprs.Val_$0;
    /**
     * @override
     */
    appendTo(buf: Base.StringBuffer, toString: boolean): void;
    /**
     * @override
     */
    visit(visitor: any): any;
    /**
     * @override
     */
    isNum(): boolean;
}
declare class Int extends Num {
    constructor(num: number);
    /**
     * @override
     */
    visit(visitor: any): any;
}
declare class Color extends Val_$0 {
    rgb: number;
    constructor(rgb: number);
    /**
     * @override
     */
    appendTo(buf: Base.StringBuffer, toString: boolean): void;
    /**
     * @override
     */
    visit(visitor: any): any;
}
declare class URL extends Val_$0 {
    url: string;
    constructor(url: string);
    /**
     * @override
     */
    appendTo(buf: Base.StringBuffer, toString: boolean): void;
    /**
     * @override
     */
    visit(visitor: any): any;
}
declare class SpaceList extends Val_$0 {
    values: Val_$0[];
    constructor(values: Val_$0[]);
    /**
     * @override
     */
    appendTo(buf: Base.StringBuffer, toString: boolean): void;
    /**
     * @override
     */
    visit(visitor: any): any;
    /**
     * @override
     */
    isSpaceList(): boolean;
}
declare class CommaList extends Val_$0 {
    values: Val_$0[];
    constructor(values: Val_$0[]);
    /**
     * @override
     */
    appendTo(buf: Base.StringBuffer, toString: boolean): void;
    /**
     * @override
     */
    visit(visitor: any): any;
}
declare class Func extends Val_$0 {
    name: string;
    values: Val_$0[];
    constructor(name: string, values: Val_$0[]);
    /**
     * @override
     */
    appendTo(buf: Base.StringBuffer, toString: boolean): void;
    /**
     * @override
     */
    visit(visitor: any): any;
}
declare class Expr extends Val_$0 {
    expr: Exprs.Val_$0;
    constructor(expr: Exprs.Val_$0);
    /**
     * @override
     */
    toExpr(): Exprs.Val_$0;
    /**
     * @override
     */
    appendTo(buf: Base.StringBuffer, toString: boolean): void;
    /**
     * @override
     */
    visit(visitor: any): any;
    /**
     * @override
     */
    isExpr(): boolean;
}
/**
 * Copyright 2013 Google, Inc.
 * Copyright 2017 Trim-marks Inc.
 * Copyright 2019 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 CssTokenizer - CSS Tokenizer.
 */
interface TokenizerHandler {
    error(mnemonics: string, token: Token): void;
}
/**
 * @enum {number}
 */
declare enum TokenType {
    EOF = 0,
    IDENT = 1,
    STR = 2,
    NUMERIC = 3,
    NUM = 4,
    INT = 5,
    FUNC = 6,
    HASH = 7,
    URL = 8,
    CLASS = 9,
    O_PAR = 10,
    C_PAR = 11,
    O_BRC = 12,
    C_BRC = 13,
    O_BRK = 14,
    C_BRK = 15,
    COMMA = 16,
    SEMICOL = 17,
    COLON = 18,
    SLASH = 19,
    AT = 20,
    PERCENT = 21,
    QMARK = 22,
    PLUS = 23,
    MINUS = 24,
    BAR_BAR = 25,
    AMP_AMP = 26,
    BANG = 31,
    DOLLAR = 32,
    HAT = 33,
    BAR = 34,
    TILDE = 35,
    STAR = 36,
    GT = 37,
    LT = 38,
    EQ = 39,
    BANG_EQ = 41,
    DOLLAR_EQ = 42,
    HAT_EQ = 43,
    BAR_EQ = 44,
    TILDE_EQ = 45,
    STAR_EQ = 46,
    GT_EQ = 47,
    LT_EQ = 48,
    EQ_EQ = 49,
    COL_COL = 50,
    INVALID = 51,
    LAST = 51
}
declare class Token {
    type: TokenType;
    precededBySpace: boolean;
    num: number;
    text: string;
    position: number;
    constructor();
}
/**
 * @enum {number}
 */
declare enum Action {
    SPACE = 1,
    INT = 2,
    IDENT = 3,
    BANG = 4,
    HASH = 6,
    DOLLAR = 7,
    PERCENT = 8,
    AMP = 9,
    O_PAR = 10,
    C_PAR = 11,
    STAR = 12,
    PLUS = 13,
    COMMA = 14,
    MINUS = 15,
    DOT = 16,
    SLASH = 17,
    COLON = 18,
    SEMICOL = 19,
    LT = 20,
    EQ = 21,
    GT = 22,
    QMARK = 23,
    AT = 24,
    O_BRK = 25,
    C_BRK = 26,
    O_BRC = 27,
    C_BRC = 28,
    BSLASH = 29,
    HAT = 30,
    BAR = 31,
    TILDE = 32,
    STR1 = 33,
    STR2 = 34,
    END = 35,
    EQTAIL = 36,
    ENDINT = 37,
    ENDNUM = 38,
    CONT = 39,
    UNIT = 40,
    PCUNIT = 41,
    NUMBER = 42,
    ENDIDNT = 43,
    IDNTESC = 44,
    ENDIDES = 45,
    ENDSTR = 46,
    ENDESTR = 47,
    STR1ESC = 48,
    STR2ESC = 49,
    BAR_BAR = 50,
    AMP_AMP = 51,
    FUNC = 52,
    FUNCES = 53,
    COMMENT = 54,
    COMMST = 55,
    ENDNOTK = 56,
    MINMIN = 57,
    TOINT = 58,
    TONUM = 59,
    TOIDENT = 60,
    TOIDES = 61,
    KILL1 = 62,
    KILL2 = 63,
    URL = 64,
    URL1 = 65,
    URL2 = 66,
    ENDURL = 67,
    TERMURL = 68,
    FINURL = 69,
    LT_BG = 70,
    LT_BG_M = 71,
    INVALID = 72,
    CHKPOSS = 73,
    CHKPOSN = 74,
    URLESC = 75,
    IDESCH = 76,
    COL_COL = 77,
    TOCLASS = 78,
    CHKSP = 79,
    EOF = 80
}
/**
 * External timer. Only needed for testing.
 */
interface Timer {
    /**
     * @return current time in milliseconds.
     */
    currentTime(): number;
    /**
     * Calls function after a given timeout.
     * @param fn function to call.
     * @param delay timeout in milliseconds.
     * @return unique number that can be used to clear the timeout.
     */
    setTimeout(fn: () => void, delay: number): number;
    /**
     * Calls function after a given timeout.
     * @param token timeout token.
     * @return.
     */
    clearTimeout(token: number): void;
}
/**
 * Result of an asynchronous function that may be available immediately or
 * some time later. Similar to Deferred.
 * @template T
 */
interface Result_$0<T> {
    /**
     * Call the given function when asynchronous function is finished. Callback
     * is executed in the task's context.
     */
    then(callback: (p1: T) => void): void;
    /**
     * Call the given asynchronous function when some asynchronous function is
     * finished. Callback is executed in the task's context.
     * @template T1
     */
    thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
    /**
     * Produce a Result that resolves to the given value when this Result is
     * resolved.
     * @template T1
     */
    thenReturn<T1>(result: T1): Result_$0<T1>;
    /**
     * Finish given frame with the result value when result becomes ready.
     */
    thenFinish(frame: Frame<T>): void;
    /**
     * Check if this Result is still pending.
     */
    isPending(): boolean;
    /**
     * If this Result is resolved, return the value that it holds.
     */
    get(): T | null;
}
/**
 * Frame state.
 * @enum {number}
 */
declare enum FrameState {
    INIT = 0,
    ACTIVE = 1,
    FINISHED = 2,
    DEAD = 3
}
/**
 * A class to create tasks.
 */
declare class Scheduler {
    timer: Timer;
    timeout: number;
    slice: number;
    sliceOverTime: number;
    queue: Base.PriorityQueue;
    wakeupTime: number | null;
    timeoutToken: number | null;
    inTimeSlice: boolean;
    order: number;
    constructor(timer: Timer);
    /**
     * Sets time slice length.
     * @param slice length in milliseconds.
     */
    setSlice(slice: number): void;
    /**
     * Sets timeout between time slices.
     * @param timeout in milliseconds.
     */
    setTimeout(timeout: number): void;
    /**
     * Checks if the current time slice is over.
     */
    isTimeSliceOver(): boolean;
    private arm;
    schedule(continuation: Continuation<any>, opt_delay?: number): void;
    private doTimeSlice;
    run(func: () => Result_$0<any>, opt_name?: string): Task;
}
/**
 * Task suspension point.
 * @template T
 */
declare class Continuation<T> implements Base.Comparable {
    task: Task;
    scheduledTime: number;
    order: number;
    result: T;
    canceled: boolean;
    constructor(task: Task);
    /**
     * @override
     */
    compare(otherComp: Base.Comparable): number;
    /**
     * Continuation's task
     */
    getTask(): Task;
    /**
     * Schedule task continuation after the given (optional) delay.
     * @param opt_delay optional delay in milliseconds.
     */
    schedule(result: T, opt_delay?: number): void;
    resumeInternal(): boolean;
    /**
     * Cancel continuation
     */
    cancel(): void;
}
/**
 * An asynchronous, time-sliced task.
 */
declare class Task {
    scheduler: Scheduler;
    name: string;
    callbacks: (() => void)[];
    exception: Error | null;
    running: boolean;
    result: any;
    waitTarget: string | null;
    top: Frame<any> | null;
    continuation: Continuation<any> | null;
    constructor(scheduler: Scheduler, name: string);
    /**
     * @return task name.
     */
    getName(): string;
    /**
     * @param err exception to throw in the task's context.
     */
    interrupt(err: Error): void;
    /**
     * @return this task's scheduler.
     */
    getScheduler(): Scheduler;
    /**
     * @return true if task is still running.
     */
    isRunning(): boolean;
    /**
     * Register a callback to be called when the task is done. Callback is not
     * executed in any task context. Multiple callbacks can be registered and
     * they will be called in the registration order.
     */
    whenDone(callback: () => void): void;
    /**
     * Wait for task to finish (from another task).
     */
    join(): Result_$0<any>;
    /**
     * Unwind the stack. We have two stacks: async (maintained by frame
     * parent link) and sync (regular JavaScript stack).
     */
    unwind(): void;
    raise(err: Error, opt_frame?: Frame<any>): void;
    /**
     * Fill the stack trace in the exception
     * @param err exception
     */
    fillStack(err: Error): void;
}
/**
 * @template T
 */
declare class SyncResultImpl<T> implements Result_$0<T> {
    value: T;
    constructor(value: T);
    /**
     * @override
     */
    then(callback: (T: any) => void): void;
    /**
     * @override
     */
    thenAsync<T1>(callback: (p1: T) => Result_$0<T1>): Result_$0<T1>;
    /**
     * @override
     */
    thenReturn<T1>(result: T1): SyncResultImpl<T1>;
    /**
     * @override
     */
    thenFinish(frame: Frame<T>): void;
    /**
     * @override
     */
    isPending(): boolean;
    /**
     * @override
     */
    get(): T | null;
}
/**
 * Asynchronous execution frame. Corresponds to an asynchronous function
 * invocation.
 * @template T
 */
declare class Frame<T> {
    task: Task;
    parent: Frame<T>;
    name: string;
    res: T;
    state: FrameState;
    callback: ((p1: any) => void) | null;
    handler: ((p1: Frame<any>, p2: Error) => void) | null;
    constructor(task: Task, parent: Frame<T>, name: string);
    private checkEnvironment;
    /**
     * @return to be returned as this asynchronous function return value.
     */
    result(): Result_$0<T>;
    finish(res: T): void;
    getTask(): Task;
    /**
     * @return frame name.
     */
    getName(): string;
    getScheduler(): Scheduler;
    then(callback: (p1: T) => void): void;
    /**
     * If this task was executed longer than task's slice parameter.
     * @return holds true
     */
    timeSlice(): Result_$0<boolean>;
    /**
     * Yield to other tasks for the specified time.
     * @param delay in milliseconds.
     * @return holds true
     */
    sleep(delay: number): Result_$0<boolean>;
    /**
     * Repeatedly execute the given function asynchronously until it returns
     * false.
     * @return holds true.
     */
    loop(func: () => Result_$0<boolean>): Result_$0<boolean>;
    /**
     * Similar to loop(), but provides a Frame for loop body function.
     * @return holds true.
     */
    loopWithFrame(func: (p1: LoopBodyFrame) => void): Result_$0<boolean>;
    suspend(opt_waitTarget?: any): Continuation<T>;
}
declare class LoopBodyFrame extends Frame<boolean> {
    constructor(task: Task, parent: Frame<boolean>);
    continueLoop(): void;
    breakLoop(): void;
}
declare class EventItem {
    event: Base.Event;
    next: EventItem;
    constructor(event: Base.Event);
}
/**
 * An class to listen to evens and present them as a readable asynchronous
 * stream to tasks.
 */
declare class EventSource {
    continuation: Continuation<boolean>;
    listeners: {
        target: Base.EventTarget;
        type: string;
        listener: Base.EventListener;
    }[];
    head: EventItem;
    tail: EventItem;
    constructor();
    /**
     * Attaches as an event listener to an EventTarget.
     */
    attach(target: Base.EventTarget, type: string, opt_preventDefault?: boolean): void;
    detach(target: Base.EventTarget, type: string): void;
    /**
     * Read next dispatched event, blocking the current task if needed.
     */
    nextEvent(): Result_$0<Base.Event>;
}
/**
 * A class that can fetch or compute a resource that may be needed by multiple
 * tasks. The first time a resource is requested, it is fetched and then given
 * to everyone requesting it.
 * @template T
 * @param fetch function that fetches/computes
 *    a resource; it will be run in a separate task.
 */
declare class Fetcher<T> {
    readonly fetch: () => Task.Result<T>;
    name: string;
    arrived: boolean;
    resource: T;
    task: Task.Task;
    piggybacks: ((p1: any) => void)[] | null;
    constructor(fetch: () => Task.Result<T>, opt_name?: string);
    /**
     * Start fetching/computing a resource, don't block current task.
     */
    start(): void;
    piggyback(fn: (p1: T) => void): void;
    /**
     * Fetches the resource, waits for it to arrive if it is already being
     * fetched.
     */
    get(): Task.Result<T>;
    hasArrived(): boolean;
}
/**
 * Copyright 2016 Trim-marks Inc.
 * Copyright 2019 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 Diff utility
 */
declare type Change = (number | string)[];
declare class Rect {
    x1: number;
    y1: number;
    x2: number;
    y2: number;
    constructor(x1: number, y1: number, x2: number, y2: number);
}
declare class Point {
    x: number;
    y: number;
    constructor(x: number, y: number);
}
declare class Segment {
    low: Point;
    high: Point;
    winding: number;
    shapeId: number;
    constructor(low: Point, high: Point, winding: number, shapeId: number);
}
/**
 * A single band for exclusion result. Left float is from the left box edge
 * to x1. Right float is from x2 to the right box edge.
 */
declare class Band {
    y1: number;
    y2: number;
    x1: number;
    x2: number;
    /** Left float. */
    left: Element | null;
    /** Right float. */
    right: Element | null;
    constructor(y1: number, y2: number, x1: number, x2: number);
}
declare class Shape {
    points: Point[];
    constructor(points: Point[]);
    /**
     * Converts this shape to a sequence of Segments and adds segments to the
     * given array.
     * @param arr array to add segments.
     * @param id shapeId to write into segments.
     */
    addSegments(arr: Segment[], id: number): void;
    withOffset(offsetX: number, offsetY: number): Shape;
}
declare class BandIntersection {
    x: number;
    winding: number;
    shapeId: number;
    lowOrHigh: number;
    constructor(x: number, winding: number, shapeId: number, lowOrHigh: number);
}
declare type FormattingContextType = "Block" | "RepetitiveElementsOwner" | "Table";
declare type FragmentLayoutConstraintType = "AfterIfContinue" | "EntireTable" | "RepetitiveElementsOwner" | "TableRow";
declare namespace CssCascade {
    interface ElementStyle {
    }
}
declare namespace CssStyler {
    interface AbstractStyler {
        getStyle(element: Element, deep: boolean): CssCascade.ElementStyle;
        processContent(element: Element, styles: {
            [key: string]: Css.Val;
        }): any;
    }
}
declare namespace Layout {
    /**
     * Represents a constraint on layout
     */
    interface LayoutConstraint {
        /**
         * Returns if this constraint allows the node context to be laid out at the
         * current position.
         */
        allowLayout(nodeContext: Vtree.NodeContext): boolean;
    }
    /**
     * Represents constraints on laying out fragments
     */
    interface FragmentLayoutConstraint {
        flagmentLayoutConstraintType: FragmentLayoutConstraintType;
        allowLayout(nodeContext: Vtree.NodeContext, overflownNodeContext: Vtree.NodeContext, column: Column): boolean;
        nextCandidate(nodeContext: Vtree.NodeContext): boolean;
        postLayout(allowed: boolean, positionAfter: Vtree.NodeContext, initialPosition: Vtree.NodeContext, column: Column): any;
        finishBreak(nodeContext: Vtree.NodeContext, column: Column): Task.Result<boolean>;
        equalsTo(constraint: FragmentLayoutConstraint): boolean;
        getPriorityOfFinishBreak(): number;
    }
    /**
     * Potential breaking position.
     */
    interface BreakPosition {
        /**
         * @return break position, if found
         */
        findAcceptableBreak(column: Column, penalty: number): Vtree.NodeContext;
        /**
         * @return penalty for this break position
         */
        getMinBreakPenalty(): number;
        calculateOffset(column: Column): {
            current: number;
            minimum: number;
        };
        breakPositionChosen(column: Column): void;
    }
    interface AbstractBreakPosition extends BreakPosition {
        getNodeContext(): Vtree.NodeContext;
    }
    type BreakPositionAndNodeContext = {
        breakPosition: BreakPosition;
        nodeContext: Vtree.NodeContext;
    };
    /**
     * Potential breaking position inside CSS box (between lines).
     * @param checkPoints array of breaking points for
     *    breakable block
     */
    interface BoxBreakPosition extends AbstractBreakPosition {
        breakNodeContext: Vtree.NodeContext;
        readonly checkPoints: Vtree.NodeContext[];
        readonly penalty: number;
    }
    /**
     * Potential edge breaking position.
     */
    interface EdgeBreakPosition extends AbstractBreakPosition {
        overflowIfRepetitiveElementsDropped: boolean;
        readonly position: Vtree.NodeContext;
        readonly breakOnEdge: string | null;
        overflows: boolean;
        readonly computedBlockSize: number;
    }
    interface Column extends Vtree.Container {
        last: Node;
        viewDocument: Document;
        flowRootFormattingContext: Vtree.FormattingContext;
        isFloat: boolean;
        isFootnote: boolean;
        startEdge: number;
        endEdge: number;
        beforeEdge: number;
        afterEdge: number;
        footnoteEdge: number;
        box: GeometryUtil.Rect;
        chunkPositions: Vtree.ChunkPosition[];
        bands: GeometryUtil.Band[];
        overflown: boolean;
        breakPositions: BreakPosition[];
        pageBreakType: string | null;
        forceNonfitting: boolean;
        leftFloatEdge: number;
        /**
         * bottom of the bottommost left float
         */
        rightFloatEdge: number;
        /**
         * bottom of the bottommost right float
         */
        bottommostFloatTop: number;
        /**
         * Top of the bottommost float
         */
        stopAtOverflow: boolean;
        lastAfterPosition: Vtree.NodePosition | null;
        fragmentLayoutConstraints: FragmentLayoutConstraint[];
        pseudoParent: Column;
        nodeContextOverflowingDueToRepetitiveElements: Vtree.NodeContext | null;
        blockDistanceToBlockEndFloats: number;
        computedBlockSize: number;
        layoutContext: Vtree.LayoutContext;
        clientLayout: Vtree.ClientLayout;
        readonly layoutConstraint: LayoutConstraint;
        readonly pageFloatLayoutContext: PageFloats.PageFloatLayoutContext;
        getTopEdge(): number;
        getBottomEdge(): number;
        getLeftEdge(): number;
        getRightEdge(): number;
        isFloatNodeContext(nodeContext: Vtree.NodeContext): boolean;
        stopByOverflow(nodeContext: Vtree.NodeContext): boolean;
        isOverflown(edge: number): boolean;
        getExclusions(): GeometryUtil.Shape[];
        openAllViews(position: Vtree.NodePosition): Task.Result<Vtree.NodeContext>;
        calculateOffsetInNodeForNodeContext(position: Vtree.NodePosition): number;
        /**
         * @param count first-XXX nesting identifier
         */
        maybePeelOff(position: Vtree.NodeContext, count: number): Task.Result<Vtree.NodeContext>;
        /**
         * Builds the view until a CSS box edge is reached.
         * @param position start source position.
         * @param checkPoints array to append possible breaking points.
         * @return holding box edge position reached or null if the source is exhausted.
         */
        buildViewToNextBlockEdge(position: Vtree.NodeContext, checkPoints: Vtree.NodeContext[]): Task.Result<Vtree.NodeContext>;
        nextInTree(position: Vtree.NodeContext, atUnforcedBreak?: boolean): Task.Result<Vtree.NodeContext>;
        /**
         * Builds the view for a single unbreakable element.
         * @param position start source position.
         * @return holding box edge position reached or null if the source is exhausted.
         */
        buildDeepElementView(position: Vtree.NodeContext): Task.Result<Vtree.NodeContext>;
        /**
         * Create a single floating element (for exclusion areas).
         * @param ref container's child to insert float before (can be null).
         * @param side float side ("left" or "right").
         * @param width float inline dimension.
         * @param height float box progression dimension.
         * @return newly created float element.
         */
        createFloat(ref: Node, side: string, width: number, height: number): Element;
        /**
         * Remove all the exclusion floats.
         */
        killFloats(): void;
        /**
         * Create exclusion floats for a column.
         */
        createFloats(): void;
        /**
         * @param nodeContext position after the block
         * @param checkPoints array of possible breaking points.
         * @param index index of the breaking point
         * @param boxOffset box offset
         * @return edge position
         */
        calculateEdge(nodeContext: Vtree.NodeContext, checkPoints: Vtree.NodeContext[], index: number, boxOffset: number): number;
        /**
         * Parse CSS computed length (in pixels)
         * @param val CSS length in "px" units or a number.
         * @return value in pixels or 0 if not parsable
         */
        parseComputedLength(val: string | number): number;
        /**
         * Reads element's computed CSS margin.
         */
        getComputedMargin(element: Element): GeometryUtil.Insets;
        /**
         * Reads element's computed padding + borders.
         */
        getComputedPaddingBorder(element: Element): GeometryUtil.Insets;
        /**
         * Reads element's computed CSS insets(margins + border + padding or margins :
         * depends on box-sizing)
         */
        getComputedInsets(element: Element): GeometryUtil.Insets;
        /**
         * Set element's computed CSS insets to Column Container
         */
        setComputedInsets(element: Element, container: Column): void;
        /**
         * Set element's computed width and height to Column Container
         */
        setComputedWidthAndHeight(element: Element, container: Column): void;
        /**
         * Layout a single unbreakable element.
         */
        layoutUnbreakable(nodeContextIn: Vtree.NodeContext): Task.Result<Vtree.NodeContext>;
        /**
         * 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;
        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;
        resolveFloatReferenceFromColumnSpan(floatReference: PageFloats.FloatReference, columnSpan: Css.Val, nodeContext: Vtree.NodeContext): Task.Result<PageFloats.FloatReference>;
        layoutPageFloat(nodeContext: Vtree.NodeContext): Task.Result<Vtree.NodeContext>;
        createJustificationAdjustmentElement(insertionPoint: Node, doc: Document, parentNode: Node, vertical: boolean): HTMLElement;
        addAndAdjustJustificationElement(nodeContext: Vtree.NodeContext, insertAfter: boolean, node: Node, insertionPoint: Node, doc: Document, parentNode: Node): HTMLElement;
        compensateJustificationLineHeight(span: Element, br: Element, nodeContext: Vtree.NodeContext): void;
        /**
         * Fix justification of the last line of text broken across pages (if
         * needed).
         */
        fixJustificationIfNeeded(nodeContext: Vtree.NodeContext, endOfColumn: boolean): void;
        processLineStyling(nodeContext: Vtree.NodeContext, resNodeContext: Vtree.NodeContext, checkPoints: Vtree.NodeContext[]): Task.Result<Vtree.NodeContext>;
        isLoneImage(checkPoints: Vtree.NodeContext[]): boolean;
        getTrailingMarginEdgeAdjustment(trailingEdgeContexts: Vtree.NodeContext[]): number;
        /**
         * Layout a single CSS box.
         */
        layoutBreakableBlock(nodeContext: Vtree.NodeContext): Task.Result<Vtree.NodeContext>;
        postLayoutBlock(nodeContext: Vtree.NodeContext, checkPoints: Vtree.NodeContext[]): void;
        findEndOfLine(linePosition: number, checkPoints: Vtree.NodeContext[], isUpdateMaxReachedAfterEdge: boolean): {
            nodeContext: Vtree.NodeContext;
            index: number;
            checkPointIndex: number;
        };
        findAcceptableBreakInside(checkPoints: Vtree.NodeContext[], edgePosition: number, force: boolean): Vtree.NodeContext;
        resolveTextNodeBreaker(nodeContext: Vtree.NodeContext): TextNodeBreaker;
        /**
         * Read ranges skipping special elments
         */
        getRangeBoxes(start: Node, end: Node): Vtree.ClientRect[];
        /**
         * Give block's initial and final nodes, find positions of the line bottoms.
         * This is, of course, somewhat hacky implementation.
         * @return position of line breaks
         */
        findLinePositions(checkPoints: Vtree.NodeContext[]): number[];
        calculateClonedPaddingBorder(nodeContext: Vtree.NodeContext): number;
        findBoxBreakPosition(bp: BoxBreakPosition, force: boolean): Vtree.NodeContext;
        getAfterEdgeOfBlockContainer(nodeContext: Vtree.NodeContext): number;
        findFirstOverflowingEdgeAndCheckPoint(checkPoints: Vtree.NodeContext[]): {
            edge: number;
            checkPoint: Vtree.NodeContext | null;
        };
        findEdgeBreakPosition(bp: EdgeBreakPosition): Vtree.NodeContext;
        /**
         * Finalize a line break.
         * @return holing true
         */
        finishBreak(nodeContext: Vtree.NodeContext, forceRemoveSelf: boolean, endOfColumn: boolean): Task.Result<boolean>;
        findAcceptableBreakPosition(): BreakPositionAndNodeContext;
        doFinishBreak(nodeContext: Vtree.NodeContext, overflownNodeContext: Vtree.NodeContext, initialNodeContext: Vtree.NodeContext, initialComputedBlockSize: number): Task.Result<Vtree.NodeContext>;
        /**
         * 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
         */
        checkOverflowAndSaveEdge(nodeContext: Vtree.NodeContext, trailingEdgeContexts: Vtree.NodeContext[]): boolean;
        /**
         * Save a possible page break position on a CSS block edge. Check if it
         * overflows.
         * @return true if overflows
         */
        checkOverflowAndSaveEdgeAndBreakPosition(nodeContext: Vtree.NodeContext, trailingEdgeContexts: Vtree.NodeContext[], saveEvenOverflown: boolean, breakAtTheEdge: string | null): boolean;
        applyClearance(nodeContext: Vtree.NodeContext): boolean;
        isBFC(formattingContext: Vtree.FormattingContext): boolean;
        /**
         * Skips positions until either the start of unbreakable block or inline
         * content. Also sets breakBefore on the result combining break-before and
         * break-after properties from all elements that meet at the edge.
         */
        skipEdges(nodeContext: Vtree.NodeContext, leadingEdge: boolean, forcedBreakValue: string | null): Task.Result<Vtree.NodeContext>;
        /**
         * Skips non-renderable positions until it hits the end of the flow or some
         * renderable content. Returns the nodeContext that was passed in if some
         * content remains and null if all content could be skipped.
         */
        skipTailEdges(nodeContext: Vtree.NodeContext): Task.Result<Vtree.NodeContext>;
        layoutFloatOrFootnote(nodeContext: Vtree.NodeContext): Task.Result<Vtree.NodeContext>;
        /**
         * Layout next portion of the source.
         */
        layoutNext(nodeContext: Vtree.NodeContext, leadingEdge: boolean, forcedBreakValue?: string | null): Task.Result<Vtree.NodeContext>;
        clearOverflownViewNodes(nodeContext: Vtree.NodeContext, removeSelf: boolean): void;
        initGeom(): void;
        init(): void;
        /**
         * Save the potential breaking position at the edge. Should, in general, save
         * "after" position but only after skipping all of the "before" ones and
         * getting to the non-empty content (to get breakAtEdge right).
         */
        saveEdgeBreakPosition(position: Vtree.NodeContext, breakAtEdge: string | null, overflows: boolean): void;
        /**
         * @param checkPoints array of breaking points for breakable block
         */
        saveBoxBreakPosition(checkPoints: Vtree.NodeContext[]): void;
        updateMaxReachedAfterEdge(afterEdge: number): void;
        /**
         * @param chunkPosition starting position.
         * @return holding end position.
         */
        layout(chunkPosition: Vtree.ChunkPosition, leadingEdge: boolean, breakAfter?: string | null): Task.Result<Vtree.ChunkPosition>;
        isFullWithPageFloats(): boolean;
        getMaxBlockSizeOfPageFloats(): number;
        doFinishBreakOfFragmentLayoutConstraints(nodeContext: any): void;
        /**
         * @param nodeContext starting position.
         * @return holding end position.
         */
        doLayout(nodeContext: Vtree.NodeContext, leadingEdge: boolean, breakAfter?: string | null): Task.Result<{
            nodeContext: Vtree.NodeContext;
            overflownNodeContext: Vtree.NodeContext;
        }>;
        /**
         * Re-layout already laid-out chunks. Return the position of the last flow if
         * there is an overflow.
         * TODO: deal with chunks that did not fit at all.
         * @return holding end position.
         */
        redoLayout(): Task.Result<Vtree.ChunkPosition>;
        saveDistanceToBlockEndFloats(): void;
        collectElementsOffset(): RepetitiveElement.ElementsOffset[];
    }
    type SinglePageFloatLayoutResult = {
        floatArea: PageFloatArea | null;
        pageFloatFragment: PageFloats.PageFloatFragment | null;
        newPosition: Vtree.ChunkPosition | null;
    };
    /**
     * breaking point resolver for Text Node.
     */
    interface TextNodeBreaker {
        breakTextNode(textNode: Text, nodeContext: Vtree.NodeContext, low: number, checkPoints: Vtree.NodeContext[], checkpointIndex: number, force: boolean): Vtree.NodeContext;
        breakAfterSoftHyphen(textNode: Text, text: string, viewIndex: number, nodeContext: Vtree.NodeContext): number;
        breakAfterOtherCharacter(textNode: Text, text: string, viewIndex: number, nodeContext: Vtree.NodeContext): number;
        updateNodeContext(nodeContext: Vtree.NodeContext, viewIndex: number, textNode: Text): Vtree.NodeContext;
    }
    interface LayoutMode {
        doLayout(nodeContext: Vtree.NodeContext, column: Layout.Column): Task.Result<Vtree.NodeContext>;
        accept(nodeContext: Vtree.NodeContext, column: Layout.Column): boolean;
        postLayout(positionAfter: Vtree.NodeContext, initialPosition: Vtree.NodeContext, column: Layout.Column, accepted: boolean): boolean;
    }
    interface PageFloatArea extends Column {
        adjustContentRelativeSize: boolean;
        readonly floatSide: string;
        readonly parentContainer: Vtree.Container;
        convertPercentageSizesToPx(target: Element): void;
        fixFloatSizeAndPosition(nodeContext: Vtree.NodeContext): void;
        getContentInlineSize(): number;
    }
}
declare namespace LayoutProcessor {
    interface BlockFormattingContext extends Vtree.FormattingContext {
    }
    function isInstanceOfBlockFormattingContext(object: Vtree.FormattingContext): object is BlockFormattingContext;
}
declare namespace Net {
    type Response = {
        status: number;
        statusText: string | null;
        url: string;
        contentType: string | null;
        responseText: string | null;
        responseXML: Document;
        responseBlob: Blob;
    };
    interface ResourceStore<Resource> {
        resources: {
            [key: string]: Resource;
        };
        fetchers: {
            [key: string]: TaskUtil.Fetcher<Resource>;
        };
        readonly parser: (p1: Response, p2: ResourceStore<Resource>) => Task.Result<Resource>;
        readonly type: XMLHttpRequestResponseType;
        /**
         * @return resource for the given URL
         */
        load(url: string, opt_required?: boolean, opt_message?: string): Task.Result<Resource>;
        /**
         * @return fetcher for the resource for the given URL
         */
        fetch(url: string, opt_required?: boolean, opt_message?: string): TaskUtil.Fetcher<Resource>;
        get(url: string): XmlDoc.XMLDocHolder;
        delete(url: string): void;
    }
}
declare namespace PageFloats {
    /**
     * @enum {string}
     */
    enum FloatReference {
        INLINE = "inline",
        COLUMN = "column",
        REGION = "region",
        PAGE = "page"
    }
    type PageFloatID = string;
    interface PageFloat {
        order: number | null;
        id: PageFloatID | null;
        readonly nodePosition: Vtree.NodePosition;
        readonly floatReference: FloatReference;
        readonly floatSide: string;
        readonly clearSide: string | null;
        readonly flowName: string;
        readonly floatMinWrapBlock: Css.Numeric | null;
        getOrder(): number;
        getId(): PageFloatID;
        isAllowedOnContext(pageFloatLayoutContext: PageFloatLayoutContext): boolean;
        isAllowedToPrecede(other: PageFloat): boolean;
    }
    interface PageFloatFragment {
        readonly floatReference: FloatReference;
        readonly floatSide: string;
        readonly continuations: PageFloatContinuation[];
        readonly area: Vtree.Container;
        readonly continues: boolean;
        hasFloat(float: PageFloat): boolean;
        findNotAllowedFloat(context: PageFloatLayoutContext): PageFloat | null;
        getOuterShape(): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
        getOrder(): number;
        shouldBeStashedBefore(float: PageFloat): boolean;
        addContinuations(continuations: PageFloatContinuation[]): void;
        getFlowName(): string;
    }
    interface PageFloatContinuation {
        readonly float: PageFloat;
        readonly nodePosition: Vtree.NodePosition;
        equals(other: PageFloatContinuation | null): boolean;
    }
    type PageFloatPlacementCondition = {
        [key: string]: boolean;
    };
    interface PageFloatLayoutContext {
        writingMode: Css.Val;
        direction: Css.Val;
        floatFragments: PageFloatFragment[];
        readonly parent: PageFloatLayoutContext;
        readonly flowName: string | null;
        readonly generatingNodePosition: Vtree.NodePosition | null;
        getContainer(floatReference?: FloatReference): Vtree.Container;
        setContainer(container: Vtree.Container): any;
        addPageFloat(float: PageFloat): void;
        getPageFloatLayoutContext(floatReference: FloatReference): PageFloatLayoutContext;
        findPageFloatByNodePosition(nodePosition: Vtree.NodePosition): PageFloat | null;
        isForbidden(float: PageFloat): boolean;
        addPageFloatFragment(floatFragment: PageFloatFragment, dontInvalidate?: boolean): void;
        removePageFloatFragment(floatFragment: PageFloatFragment, dontInvalidate?: boolean): void;
        findPageFloatFragment(float: PageFloat): PageFloatFragment | null;
        hasFloatFragments(condition?: (p1: PageFloatFragment) => boolean): boolean;
        hasContinuingFloatFragmentsInFlow(flowName: string): boolean;
        registerPageFloatAnchor(float: PageFloat, anchorViewNode: Node): void;
        collectPageFloatAnchors(): any;
        isAnchorAlreadyAppeared(floatId: PageFloatID): boolean;
        deferPageFloat(continuation: PageFloatContinuation): void;
        hasPrecedingFloatsDeferredToNext(float: PageFloat, ignoreReference?: boolean): boolean;
        getLastFollowingFloatInFragments(float: PageFloat): PageFloat | null;
        getDeferredPageFloatContinuations(flowName?: string | null): PageFloatContinuation[];
        getPageFloatContinuationsDeferredToNext(flowName?: string | null): PageFloatContinuation[];
        getFloatsDeferredToNextInChildContexts(): PageFloat[];
        checkAndForbidNotAllowedFloat(): boolean;
        checkAndForbidFloatFollowingDeferredFloat(): boolean;
        finish(): void;
        hasSameContainerAs(other: PageFloatLayoutContext): boolean;
        invalidate(): void;
        detachChildren(): PageFloatLayoutContext[];
        attachChildren(children: PageFloatLayoutContext[]): void;
        isInvalidated(): boolean;
        validate(): void;
        removeEndFloatFragments(floatSide: string): void;
        stashEndFloatFragments(float: PageFloat): void;
        restoreStashedFragments(floatReference: FloatReference): void;
        discardStashedFragments(floatReference: FloatReference): void;
        getStashedFloatFragments(floatReference: FloatReference): PageFloatFragment[];
        /**
         * @param anchorEdge Null indicates that the anchor is not in the current
         *     container.
         * @return Logical float side (snap-block is resolved when init=false). Null
         *     indicates that the float area does not fit inside the container
         */
        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;
        getPageFloatClearEdge(clear: string, column: Layout.Column): number;
        getPageFloatPlacementCondition(float: PageFloat, floatSide: string, clearSide: string | null): PageFloatPlacementCondition;
        getLayoutConstraints(): Layout.LayoutConstraint[];
        addLayoutConstraint(layoutConstraint: Layout.LayoutConstraint, floatReference: FloatReference): void;
        getMaxBlockSizeOfPageFloats(): number;
        lock(): void;
        unlock(): void;
        isLocked(): boolean;
    }
    interface PageFloatLayoutStrategy {
        appliesToNodeContext(nodeContext: Vtree.NodeContext): boolean;
        appliesToFloat(float: PageFloat): boolean;
        createPageFloat(nodeContext: Vtree.NodeContext, pageFloatLayoutContext: PageFloatLayoutContext, column: Layout.Column): Task.Result<PageFloat>;
        createPageFloatFragment(continuations: PageFloatContinuation[], floatSide: string, floatArea: Layout.PageFloatArea, continues: boolean): PageFloatFragment;
        findPageFloatFragment(float: PageFloat, pageFloatLayoutContext: PageFloatLayoutContext): PageFloatFragment | null;
        adjustPageFloatArea(floatArea: Layout.PageFloatArea, floatContainer: Vtree.Container, column: Layout.Column): any;
        forbid(float: PageFloat, pageFloatLayoutContext: PageFloatLayoutContext): any;
    }
}
declare namespace Selectors {
    interface AfterIfContinues {
        readonly sourceNode: Element;
        readonly styler: PseudoElement.PseudoelementStyler;
        createElement(column: Layout.Column, parentNodeContext: Vtree.NodeContext): Task.Result<Element>;
    }
    interface AfterIfContinuesLayoutConstraint extends Layout.FragmentLayoutConstraint {
        nodeContext: Vtree.NodeContext;
        afterIfContinues: AfterIfContinues;
        pseudoElementHeight: number;
        getRepetitiveElements(): AfterIfContinuesElementsOffset;
    }
    function isInstanceOfAfterIfContinuesLayoutConstraint(object: Layout.FragmentLayoutConstraint): object is AfterIfContinuesLayoutConstraint;
    interface AfterIfContinuesElementsOffset extends RepetitiveElement.ElementsOffset {
        nodeContext: Vtree.NodeContext;
        pseudoElementHeight: number;
        affectTo(nodeContext: Vtree.NodeContext): boolean;
    }
}
declare namespace PseudoElement {
    interface PseudoelementStyler extends CssStyler.AbstractStyler {
        contentProcessed: {
            [key: string]: boolean;
        };
        readonly element: Element;
        style: CssCascade.ElementStyle;
        styler: CssStyler.AbstractStyler;
        readonly context: Exprs.Context;
        readonly exprContentListener: Vtree.ExprContentListener;
    }
}
declare namespace RepetitiveElement {
    interface RepetitiveElementsOwnerFormattingContext extends Vtree.FormattingContext {
        isRoot: boolean;
        repetitiveElements: RepetitiveElements;
        readonly parent: Vtree.FormattingContext;
        readonly rootSourceNode: Element;
        getRepetitiveElements(): RepetitiveElements;
        getRootViewNode(position: Vtree.NodeContext): Element | null;
        getRootNodeContext(nodeContext: Vtree.NodeContext): Vtree.NodeContext | null;
        initializeRepetitiveElements(vertical: boolean): void;
    }
    function isInstanceOfRepetitiveElementsOwnerFormattingContext(object: Vtree.FormattingContext): object is RepetitiveElementsOwnerFormattingContext;
    interface ElementsOffset {
        calculateOffset(nodeContext: Vtree.NodeContext): number;
        calculateMinimumOffset(nodeContext: Vtree.NodeContext): number;
    }
    interface RepetitiveElements extends ElementsOffset {
        isSkipHeader: boolean;
        isSkipFooter: boolean;
        enableSkippingFooter: boolean;
        enableSkippingHeader: boolean;
        doneInitialLayout: boolean;
        firstContentSourceNode: Element | null;
        lastContentSourceNode: Element | null;
        allowInsert: boolean;
        allowInsertRepeatitiveElements: boolean;
        ownerSourceNode: Element;
        setHeaderNodeContext(nodeContext: Vtree.NodeContext): void;
        setFooterNodeContext(nodeContext: Vtree.NodeContext): void;
        updateHeight(column: Layout.Column): void;
        prepareLayoutFragment(): void;
        appendHeaderToFragment(rootNodeContext: Vtree.NodeContext, firstChild: Node | null, column: Layout.Column): Task.Result<boolean>;
        appendFooterToFragment(rootNodeContext: Vtree.NodeContext, firstChild: Node | null, column: Layout.Column): Task.Result<boolean>;
        appendElementToFragment(nodePosition: Vtree.NodePosition, rootNodeContext: Vtree.NodeContext, firstChild: Node | null, column: Layout.Column): Task.Result<boolean>;
        moveChildren(from: Element, to: Element, firstChild: Node | null): void;
        isAfterLastContent(nodeContext: Vtree.NodeContext): boolean;
        isFirstContentNode(nodeContext: Vtree.NodeContext): boolean;
        isEnableToUpdateState(): boolean;
        updateState(): void;
        preventSkippingHeader(): void;
        preventSkippingFooter(): void;
        isHeaderRegistered(): boolean;
        isFooterRegistered(): boolean;
        isHeaderSourceNode(node: Node): boolean;
        isFooterSourceNode(node: Node): boolean;
    }
    interface RepetitiveElementsOwnerLayoutConstraint extends Layout.FragmentLayoutConstraint {
        getRepetitiveElements(): RepetitiveElements;
    }
    function isInstanceOfRepetitiveElementsOwnerLayoutConstraint(object: Layout.FragmentLayoutConstraint): object is RepetitiveElementsOwnerLayoutConstraint;
}
declare namespace Vtree {
    type ClientRect = {
        left: number;
        top: number;
        right: number;
        bottom: number;
        width: number;
        height: number;
    };
    /**
     * Interface to read the position assigned to the elements and ranges by the
     * browser.
     */
    interface ClientLayout {
        getRangeClientRects(range: Range): ClientRect[];
        getElementClientRect(element: Element): ClientRect;
        /**
         * @return element's computed style
         */
        getElementComputedStyle(element: Element): CSSStyleDeclaration;
    }
    /**
     * Styling, creating a single node's view, etc.
     */
    interface LayoutContext {
        /**
         * Creates a functionally equivalent, but uninitialized layout context,
         * suitable for building a separate column.
         */
        clone(): LayoutContext;
        /**
         * Set the current source node and create a view. Parameter firstTime
         * is true (and possibly offsetInNode > 0) if node was broken on
         * the previous page.
         * @return true if children should be processed as well
         */
        setCurrent(nodeContext: NodeContext, firstTime: boolean, atUnforcedBreak?: boolean): Task.Result<boolean>;
        /**
         * Set the container element that holds view elements produced from the
         * source.
         */
        setViewRoot(viewRoot: Element, isFootnote: boolean): any;
        /**
         * Moves to the next view node, creating it and appending it to the view tree
         * if needed.
         * @return that corresponds to the next view node
         */
        nextInTree(nodeContext: NodeContext, atUnforcedBreak?: boolean): Task.Result<NodeContext>;
        /**
         * Apply pseudo-element styles (if any).
         * @param target element to apply styles to
         */
        applyPseudoelementStyle(nodeContext: NodeContext, pseudoName: string, target: Element): void;
        /**
         * Apply styles to footnote container.
         * @param target element to apply styles to
         * @return vertical
         */
        applyFootnoteStyle(vertical: boolean, rtl: boolean, target: Element): boolean;
        /**
         * Peel off innermost first-XXX pseudoelement, create and create view nodes
         * after the end of that pseudoelement.
         */
        peelOff(nodeContext: NodeContext, nodeOffset: number): Task.Result<NodeContext>;
        /**
         * Process a block-end edge of a fragmented block.
         */
        processFragmentedBlockEdge(nodeContext: NodeContext): any;
        convertLengthToPx(numeric: Css.Numeric, viewNode: Node, clientLayout: ClientLayout): number | Css.Numeric;
        /**
         * Returns if two NodePositions represents the same position in the document.
         */
        isSameNodePosition(nodePosition1: NodePosition, nodePosition2: NodePosition): boolean;
        addEventListener(type: string, listener: Base.EventListener, capture?: boolean): void;
        removeEventListener(type: string, listener: Base.EventListener, capture?: boolean): void;
        dispatchEvent(evt: Base.Event): void;
    }
    /**
     * Formatting context.
     */
    interface FormattingContext {
        formattingContextType: FormattingContextType;
        getName(): string;
        isFirstTime(nodeContext: NodeContext, firstTime: boolean): boolean;
        getParent(): FormattingContext;
        saveState(): any;
        restoreState(state: any): any;
    }
    type NodePositionStep = {
        node: Node;
        shadowType: ShadowType;
        shadowContext: ShadowContext | null;
        nodeShadow: ShadowContext | null;
        shadowSibling: NodePositionStep | null;
        formattingContext: FormattingContext | null;
        fragmentIndex: number;
    };
    type NodePosition = {
        steps: NodePositionStep[];
        offsetInNode: number;
        after: boolean;
        preprocessedTextContent: Diff.Change[] | null;
    };
    /**
     * Handling of purely whitespace sequences between blocks
     * @enum {number}
     */
    enum Whitespace {
        /**
         * Whitespace sequence between blocks is ignored
         */
        IGNORE = 0,
        /**
         * Whitespace sequence between blocks is ignored unless it containes newline
         */
        NEWLINE = 1,
        /**
         * Whitespace sequence between blocks is preserved
         */
        PRESERVE = 2
    }
    interface Container {
        left: number;
        top: number;
        marginLeft: number;
        marginRight: number;
        marginTop: number;
        marginBottom: number;
        borderLeft: number;
        borderRight: number;
        borderTop: number;
        borderBottom: number;
        paddingLeft: number;
        paddingRight: number;
        paddingTop: number;
        paddingBottom: number;
        width: number;
        height: number;
        originX: number;
        originY: number;
        exclusions: GeometryUtil.Shape[];
        innerShape: GeometryUtil.Shape;
        computedBlockSize: number;
        snapWidth: number;
        snapHeight: number;
        snapOffsetX: number;
        snapOffsetY: number;
        vertical: boolean;
        element: Element;
        getInsetTop(): number;
        getInsetBottom(): number;
        getInsetLeft(): number;
        getInsetRight(): number;
        getInsetBefore(): number;
        getInsetAfter(): number;
        getInsetStart(): number;
        getInsetEnd(): number;
        getBeforeEdge(box: ClientRect): number;
        getAfterEdge(box: ClientRect): number;
        getStartEdge(box: ClientRect): number;
        getEndEdge(box: ClientRect): number;
        getInlineSize(box: ClientRect): number;
        getBoxSize(box: ClientRect): number;
        getBoxDir(): number;
        getInlineDir(): number;
        copyFrom(other: Container): void;
        setVerticalPosition(top: number, height: number): void;
        setHorizontalPosition(left: number, width: number): void;
        setBlockPosition(start: number, extent: number): void;
        setInlinePosition(start: number, extent: number): void;
        clear(): void;
        getInnerShape(): GeometryUtil.Shape;
        getInnerRect(): GeometryUtil.Rect;
        getPaddingRect(): GeometryUtil.Rect;
        getOuterShape(outerShapeProp: Css.Val, context: Exprs.Context): GeometryUtil.Shape;
        getOuterRect(): GeometryUtil.Rect;
    }
    /**
     * @enum {number}
     */
    enum ShadowType {
        NONE = 0,
        CONTENT = 1,
        ROOTLESS = 2,
        ROOTED = 3
    }
    /**
     * Data about shadow tree instance.
     */
    interface ShadowContext {
        readonly owner: Element;
        readonly root: Element;
        readonly xmldoc: XmlDoc.XMLDocHolder;
        readonly parentShadow: ShadowContext;
        subShadow: ShadowContext;
        readonly type: Vtree.ShadowType;
        readonly styler: object;
        equals(other: ShadowContext): boolean;
    }
    /**
     * Information about :first-letter or :first-line pseudoelements
     * @param count 0 - first-letter, 1 or more - first line(s)
     */
    interface FirstPseudo {
        readonly outer: FirstPseudo;
        readonly count: number;
    }
    /**
     * NodeContext represents a position in the document + layout-related
     * information attached to it. When after=false and offsetInNode=0, the
     * position is inside the element (node), but just before its first child.
     * When offsetInNode>0 it represents offset in the textual content of the
     * node. When after=true it represents position right after the last child
     * of the node. boxOffset is incremented by 1 for any valid node position.
     */
    interface NodeContext {
        offsetInNode: number;
        after: boolean;
        shadowType: ShadowType;
        shadowContext: Vtree.ShadowContext;
        nodeShadow: Vtree.ShadowContext;
        shadowSibling: NodeContext;
        shared: boolean;
        inline: boolean;
        overflow: boolean;
        breakPenalty: number;
        display: string | null;
        floatReference: PageFloats.FloatReference;
        floatSide: string | null;
        clearSide: string | null;
        floatMinWrapBlock: Css.Numeric | null;
        columnSpan: Css.Val | null;
        verticalAlign: string;
        captionSide: string;
        inlineBorderSpacing: number;
        blockBorderSpacing: number;
        flexContainer: boolean;
        whitespace: Whitespace;
        hyphenateCharacter: string | null;
        breakWord: boolean;
        establishesBFC: boolean;
        containingBlockForAbsolute: boolean;
        breakBefore: string | null;
        breakAfter: string | null;
        viewNode: Node;
        clearSpacer: Node;
        inheritedProps: {
            [key: string]: number | string | Css.Val;
        };
        vertical: boolean;
        direction: string;
        firstPseudo: FirstPseudo;
        lang: string | null;
        preprocessedTextContent: Diff.Change[] | null;
        formattingContext: FormattingContext;
        repeatOnBreak: string | null;
        pluginProps: {
            [key: string]: string | number | undefined | null | (number | null)[];
        };
        fragmentIndex: number;
        afterIfContinues: Selectors.AfterIfContinues;
        footnotePolicy: Css.Ident | null;
        sourceNode: Node;
        parent: NodeContext;
        boxOffset: number;
        resetView(): void;
        modify(): NodeContext;
        copy(): NodeContext;
        clone(): NodeContext;
        toNodePositionStep(): NodePositionStep;
        toNodePosition(): NodePosition;
        isInsideBFC(): boolean;
        getContainingBlockForAbsolute(): NodeContext;
        /**
         * Walk up NodeContext tree (starting from itself) and call the callback for
         * each block.
         */
        walkUpBlocks(callback: (p1: NodeContext) => any): void;
        belongsTo(formattingContext: FormattingContext): boolean;
    }
    interface ChunkPosition {
        floats: NodePosition[];
        primary: NodePosition;
        clone(): ChunkPosition;
        isSamePosition(other: ChunkPosition): boolean;
    }
    type ExprContentListener = (p1: Exprs.Val, p2: string, p3: Document) => Node | null;
}
declare namespace XmlDoc {
    interface XMLDocHolder {
        lang: string | null;
        totalOffset: number;
        root: Element;
        body: Element;
        head: Element;
        last: Element;
        lastOffset: number;
        idMap: {
            [key: string]: Element;
        };
        readonly store: XMLDocStore;
        readonly url: string;
        readonly document: Document;
        doc(): NodeList;
        getElementOffset(element: Element): number;
        getNodeOffset(srcNode: Node, offsetInNode: number, after: boolean): number;
        getTotalOffset(): number;
        /**
         * @return last node such that its offset is less or equal to the given
         */
        getNodeByOffset(offset: number): Node;
        /**
         * Get element by URL in the source document(s). URL must be in either '#id'
         * or 'url#id' form.
         */
        getElement(url: string): Element | null;
    }
    interface Predicate {
        readonly fn: (p1: Node) => boolean;
        check(node: Node): boolean;
        withAttribute(name: string, value: string): Predicate;
        withChild(name: string, opt_childPredicate?: Predicate): Predicate;
    }
    interface NodeList {
        readonly nodes: Node[];
        asArray(): Node[];
        size(): number;
        /**
         * Filter with predicate
         */
        predicate(pr: Predicate): NodeList;
        forEachNode(fn: (p1: Node, p2: (p1: Node) => void) => void): NodeList;
        forEach<T>(fn: (p1: Node) => T): T[];
        forEachNonNull<T>(fn: (p1: Node) => T): T[];
        child(tag: string): NodeList;
        childElements(): NodeList;
        attribute(name: string): (string | null)[];
        textContent(): (string | null)[];
    }
    type XMLDocStore = Net.ResourceStore<XMLDocHolder>;
}
/**
 * @enum {string}
 */
declare enum XMLHttpRequestResponseType {
    DEFAULT = "",
    ARRAYBUFFER = "arraybuffer",
    BLOB = "blob",
    DOCUMENT = "document",
    JSON = "json",
    TEXT = "text"
}
declare type Response_$0 = Net.Response_$0;
/**
 * @template Resource
 */
declare class ResourceStore_$0<Resource> implements Net.ResourceStore_$0<Resource> {
    readonly parser: (p1: Response_$0, p2: ResourceStore_$0<Resource>) => Task.Result<Resource>;
    readonly type: XMLHttpRequestResponseType;
    resources: {
        [key: string]: Resource;
    };
    fetchers: {
        [key: string]: TaskUtil.Fetcher<Resource>;
    };
    constructor(parser: (p1: Response_$0, p2: ResourceStore_$0<Resource>) => Task.Result<Resource>, type: XMLHttpRequestResponseType);
    /**
     * @return resource for the given URL
     */
    load(url: string, opt_required?: boolean, opt_message?: string): Task.Result<Resource>;
    private fetchInner;
    /**
     * @return fetcher for the resource for the given URL
     */
    fetch(url: string, opt_required?: boolean, opt_message?: string): TaskUtil.Fetcher<Resource>;
    get(url: string): XmlDoc.XMLDocHolder;
    delete(url: string): void;
}
declare type JSONStore = ResourceStore_$0<Base.JSON>;
/**
 * @enum {string}
 */
declare enum StylesheetFlavor {
    USER_AGENT = "UA",
    USER = "User",
    AUTHOR = "Author"
}
declare class ParserHandler implements CssTokenizer.TokenizerHandler {
    scope: Exprs.LexicalScope;
    flavor: StylesheetFlavor;
    constructor(scope: Exprs.LexicalScope);
    getCurrentToken(): CssTokenizer.Token;
    getScope(): Exprs.LexicalScope;
    error(mnemonics: string, token: CssTokenizer.Token): void;
    startStylesheet(flavor: StylesheetFlavor): void;
    tagSelector(ns: string | null, name: string | null): void;
    classSelector(name: string): void;
    pseudoclassSelector(name: string, params: (number | string)[]): void;
    pseudoelementSelector(name: string, params: (number | string)[]): void;
    idSelector(id: string): void;
    attributeSelector(ns: string, name: string, op: CssTokenizer.TokenType, value: string | null): void;
    descendantSelector(): void;
    childSelector(): void;
    adjacentSiblingSelector(): void;
    followingSiblingSelector(): void;
    nextSelector(): void;
    startSelectorRule(): void;
    startFontFaceRule(): void;
    startFootnoteRule(pseudoelem: string | null): void;
    startViewportRule(): void;
    startDefineRule(): void;
    startRegionRule(): void;
    startPageRule(): void;
    startPageMarginBoxRule(name: string): void;
    startWhenRule(expr: Css.Expr): void;
    startMediaRule(expr: Css.Expr): void;
    startFlowRule(flowName: string): void;
    startPageTemplateRule(): void;
    startPageMasterRule(name: string | null, pseudoName: string | null, classes: string[]): void;
    startPartitionRule(name: string | null, pseudoName: string | null, classes: string[]): void;
    startPartitionGroupRule(name: string | null, pseudoName: string | null, classes: string[]): void;
    startRuleBody(): void;
    property(name: string, value: Css.Val, important: boolean): void;
    endRule(): void;
    /**
     * @param funcName The name of the function taking a selector list as an
     *     argument
     */
    startFuncWithSelector(funcName: string): void;
    endFuncWithSelector(): void;
    getImportantSpecificity(): number;
    getBaseSpecificity(): number;
}
declare class DispatchParserHandler extends ParserHandler {
    stack: ParserHandler[];
    tokenizer: CssTokenizer.Tokenizer;
    slave: ParserHandler;
    constructor();
    pushHandler(slave: ParserHandler): void;
    popHandler(): void;
    /**
     * @override
     */
    getCurrentToken(): CssTokenizer.Token;
    /**
     * @override
     */
    getScope(): Exprs.LexicalScope;
    /**
     * Forwards call to slave.
     * @override
     */
    error(mnemonics: string, token: CssTokenizer.Token): void;
    /**
     * Called by a slave.
     */
    errorMsg(mnemonics: string, token: CssTokenizer.Token): void;
    /**
     * @override
     */
    startStylesheet(flavor: StylesheetFlavor): void;
    /**
     * @override
     */
    tagSelector(ns: string | null, name: string | null): void;
    /**
     * @override
     */
    classSelector(name: string): void;
    /**
     * @override
     */
    pseudoclassSelector(name: string, params: (number | string)[]): void;
    /**
     * @override
     */
    pseudoelementSelector(name: string, params: (number | string)[]): void;
    /**
     * @override
     */
    idSelector(id: string): void;
    /**
     * @override
     */
    attributeSelector(ns: string, name: string, op: CssTokenizer.TokenType, value: string | null): void;
    /**
     * @override
     */
    descendantSelector(): void;
    /**
     * @override
     */
    childSelector(): void;
    /**
     * @override
     */
    adjacentSiblingSelector(): void;
    /**
     * @override
     */
    followingSiblingSelector(): void;
    /**
     * @override
     */
    nextSelector(): void;
    /**
     * @override
     */
    startSelectorRule(): void;
    /**
     * @override
     */
    startFontFaceRule(): void;
    /**
     * @override
     */
    startFootnoteRule(pseudoelem: string | null): void;
    /**
     * @override
     */
    startViewportRule(): void;
    /**
     * @override
     */
    startDefineRule(): void;
    /**
     * @override
     */
    startRegionRule(): void;
    /**
     * @override
     */
    startPageRule(): void;
    /**
     * @override
     */
    startPageMarginBoxRule(name: string): void;
    /**
     * @override
     */
    startWhenRule(expr: Css.Expr): void;
    /**
     * @override
     */
    startFlowRule(flowName: string): void;
    /**
     * @override
     */
    startPageTemplateRule(): void;
    /**
     * @override
     */
    startPageMasterRule(name: string | null, pseudoName: string | null, classes: string[]): void;
    /**
     * @override
     */
    startPartitionRule(name: string | null, pseudoName: string | null, classes: string[]): void;
    /**
     * @override
     */
    startPartitionGroupRule(name: string | null, pseudoName: string | null, classes: string[]): void;
    /**
     * @override
     */
    startRuleBody(): void;
    /**
     * @override
     */
    property(name: string, value: Css.Val, important: boolean): void;
    /**
     * @override
     */
    endRule(): void;
    /**
     * @override
     */
    startFuncWithSelector(funcName: string): void;
    /**
     * @override
     */
    endFuncWithSelector(): void;
}
declare class SkippingParserHandler extends ParserHandler {
    owner: DispatchParserHandler;
    readonly topLevel: any;
    depth: number;
    flavor: StylesheetFlavor;
    constructor(scope: Exprs.LexicalScope, owner: DispatchParserHandler, topLevel: any);
    /**
     * @override
     */
    getCurrentToken(): CssTokenizer.Token;
    /**
     * @override
     */
    error(mnemonics: string, token: CssTokenizer.Token): void;
    /**
     * @override
     */
    startRuleBody(): void;
    /**
     * @override
     */
    endRule(): void;
}
/**
 * @enum {number}
 */
declare enum Action_$0 {
    SELECTOR_NAME_1 = 1,
    SELECTOR_NAME = 2,
    SELECTOR_ANY_1 = 3,
    SELECTOR_ANY = 4,
    SELECTOR_ID_1 = 5,
    SELECTOR_ID = 6,
    SELECTOR_CLASS_1 = 7,
    SELECTOR_CLASS = 8,
    SELECTOR_ATTR_1 = 9,
    SELECTOR_ATTR = 10,
    SELECTOR_CHILD = 11,
    SELECTOR_SIBLING = 12,
    SELECTOR_BODY = 13,
    SELECTOR_PSEUDOCLASS = 14,
    VAL_IDENT = 15,
    VAL_HASH = 16,
    VAL_NUM = 17,
    VAL_INT = 18,
    VAL_NUMERIC = 19,
    VAL_STR = 20,
    VAL_URL = 21,
    VAL_COMMA = 22,
    VAL_SLASH = 23,
    VAL_FUNC = 24,
    VAL_C_PAR = 25,
    VAL_END = 26,
    RULE_END = 27,
    IDENT = 28,
    SELECTOR_START = 29,
    AT = 30,
    EXPR_IDENT = 31,
    EXPR_NUM = 32,
    EXPR_NUMERIC = 33,
    EXPR_STR = 34,
    EXPR_PARAM = 35,
    EXPR_PREFIX = 36,
    EXPR_INFIX = 37,
    EXPR_FUNC = 38,
    EXPR_C_PAR = 39,
    EXPR_O_PAR = 40,
    SELECTOR_NEXT = 41,
    SELECTOR_PSEUDOELEM = 42,
    EXPR_O_BRC = 43,
    VAL_FINISH = 44,
    EXPR_INFIX_NAME = 45,
    PROP = 46,
    VAL_BANG = 47,
    VAL_BRC = 48,
    EXPR_SEMICOL = 49,
    ERROR_PUSH = 50,
    ERROR_POP = 51,
    ERROR_POP_DECL = 52,
    ERROR_SEMICOL = 53,
    VAL_PLUS = 54,
    SELECTOR_PSEUDOCLASS_1 = 55,
    SELECTOR_FOLLOWING_SIBLING = 56,
    DONE = 200
}
/**
 * @enum {number}
 */
declare enum ExprContext {
    PROP = 0,
    WHEN = 1,
    MEDIA = 2,
    IMPORT = 3
}
declare class DelayedItem {
    target: Element;
    name: string;
    value: Css.Val;
    constructor(target: Element, name: string, value: Css.Val);
}
declare type Trigger = {
    observer: string;
    event: string;
    action: string;
    ref: string;
};
declare class Page extends Base.SimpleEventTarget {
    readonly container: HTMLElement;
    readonly bleedBox: HTMLElement;
    private static AUTO_PAGE_WIDTH_ATTRIBUTE;
    private static AUTO_PAGE_HEIGHT_ATTRIBUTE;
    pageAreaElement: HTMLElement | null;
    delayedItems: DelayedItem[];
    hrefHandler: (e: Event) => void;
    elementsById: {
        [key: string]: Element[];
    };
    dimensions: {
        width: number;
        height: number;
    };
    isFirstPage: boolean;
    isLastPage: boolean;
    isAutoPageWidth: boolean;
    isAutoPageHeight: boolean;
    spineIndex: number;
    position: LayoutPosition;
    offset: number;
    side: Constants.PageSide | null;
    fetchers: TaskUtil.Fetcher<{}>[];
    marginBoxes: {
        top: {
            [key: string]: Container_$0;
        };
        bottom: {
            [key: string]: Container_$0;
        };
        left: {
            [key: string]: Container_$0;
        };
        right: {
            [key: string]: Container_$0;
        };
    };
    constructor(container: HTMLElement, bleedBox: HTMLElement);
    setAutoPageWidth(isAuto: boolean): void;
    setAutoPageHeight(isAuto: boolean): void;
    registerElementWithId(element: Element, id: string): void;
    finish(triggers: Trigger[], clientLayout: ClientLayout_$0): void;
    /**
     * Zoom page.
     * @param scale Factor to which the page will be scaled.
     */
    zoom(scale: number): void;
    /**
     * Returns the page area element.
     */
    getPageAreaElement(): HTMLElement;
}
declare const Whitespace_$0: typeof Vtree.Whitespace_$0;
declare type Whitespace_$0 = Vtree.Whitespace_$0;
declare class Flow {
    readonly flowName: string;
    readonly parentFlowName: string | null;
    forcedBreakOffsets: number[];
    formattingContext: FormattingContext_$0 | null;
    constructor(flowName: string, parentFlowName: string | null);
}
declare class FlowChunk {
    flowName: string;
    element: Element;
    startOffset: number;
    priority: number;
    linger: number;
    exclusive: boolean;
    repeated: boolean;
    last: boolean;
    breakBefore: string | null;
    startPage: number;
    constructor(flowName: string, element: Element, startOffset: number, priority: number, linger: number, exclusive: boolean, repeated: boolean, last: boolean, breakBefore: string | null);
    isBetter(other: FlowChunk): boolean;
}
declare type ClientRect_$0 = Vtree.ClientRect_$0;
/**
 * Interface to read the position assigned to the elements and ranges by the
 * browser.
 */
declare type ClientLayout_$0 = Vtree.ClientLayout_$0;
/**
 * Formatting context.
 */
declare type FormattingContext_$0 = Vtree.FormattingContext_$0;
declare type NodePositionStep_$0 = Vtree.NodePositionStep_$0;
declare type NodePosition_$0 = Vtree.NodePosition_$0;
declare const ShadowType_$0: typeof Vtree.ShadowType_$0;
declare type ShadowType_$0 = Vtree.ShadowType_$0;
/**
 * Data about shadow tree instance.
 */
declare class ShadowContext_$0 implements Vtree.ShadowContext_$0 {
    readonly owner: Element;
    readonly root: Element;
    readonly xmldoc: XmlDoc.XMLDocHolder;
    readonly parentShadow: ShadowContext_$0;
    readonly type: ShadowType_$0;
    readonly styler: object;
    subShadow: ShadowContext_$0;
    constructor(owner: Element, root: Element, xmldoc: XmlDoc.XMLDocHolder, parentShadow: ShadowContext_$0, superShadow: ShadowContext_$0, type: ShadowType_$0, styler: object);
    equals(other: ShadowContext_$0): boolean;
}
/**
 * Information about :first-letter or :first-line pseudoelements
 * @param count 0 - first-letter, 1 or more - first line(s)
 */
declare class FirstPseudo_$0 implements Vtree.FirstPseudo_$0 {
    readonly outer: FirstPseudo_$0;
    readonly count: number;
    constructor(outer: FirstPseudo_$0, count: number);
}
/**
 * NodeContext represents a position in the document + layout-related
 * information attached to it. When after=false and offsetInNode=0, the
 * position is inside the element (node), but just before its first child.
 * When offsetInNode>0 it represents offset in the textual content of the
 * node. When after=true it represents position right after the last child
 * of the node. boxOffset is incremented by 1 for any valid node position.
 */
declare class NodeContext_$0 implements Vtree.NodeContext_$0 {
    sourceNode: Node;
    parent: NodeContext_$0;
    boxOffset: number;
    offsetInNode: number;
    after: boolean;
    shadowType: ShadowType_$0;
    shadowContext: ShadowContext_$0;
    nodeShadow: ShadowContext_$0;
    shadowSibling: NodeContext_$0;
    shared: boolean;
    inline: boolean;
    overflow: boolean;
    breakPenalty: number;
    display: string | null;
    floatReference: PageFloats.FloatReference;
    floatSide: string | null;
    clearSide: string | null;
    floatMinWrapBlock: Css.Numeric | null;
    columnSpan: Css.Val | null;
    verticalAlign: string;
    captionSide: string;
    inlineBorderSpacing: number;
    blockBorderSpacing: number;
    flexContainer: boolean;
    whitespace: Whitespace_$0;
    hyphenateCharacter: string | null;
    breakWord: boolean;
    establishesBFC: boolean;
    containingBlockForAbsolute: boolean;
    breakBefore: string | null;
    breakAfter: string | null;
    viewNode: Node;
    clearSpacer: Node;
    inheritedProps: {
        [key: string]: number | string | Css.Val;
    };
    vertical: boolean;
    direction: string;
    firstPseudo: FirstPseudo_$0;
    lang: string | null;
    preprocessedTextContent: Diff.Change[] | null;
    formattingContext: FormattingContext_$0;
    repeatOnBreak: string | null;
    pluginProps: {
        [key: string]: string | number | undefined | null | (number | null)[];
    };
    fragmentIndex: number;
    afterIfContinues: Selectors.AfterIfContinues;
    footnotePolicy: Css.Ident | null;
    constructor(sourceNode: Node, parent: NodeContext_$0, boxOffset: number);
    resetView(): void;
    private cloneItem;
    modify(): NodeContext_$0;
    copy(): NodeContext_$0;
    clone(): NodeContext_$0;
    toNodePositionStep(): NodePositionStep_$0;
    toNodePosition(): NodePosition_$0;
    isInsideBFC(): boolean;
    getContainingBlockForAbsolute(): NodeContext_$0;
    /**
     * Walk up NodeContext tree (starting from itself) and call the callback for
     * each block.
     */
    walkUpBlocks(callback: (p1: NodeContext_$0) => any): void;
    belongsTo(formattingContext: FormattingContext_$0): boolean;
}
declare class ChunkPosition_$0 implements Vtree.ChunkPosition_$0 {
    primary: NodePosition_$0;
    floats: NodePosition_$0[];
    constructor(primary: NodePosition_$0);
    clone(): ChunkPosition_$0;
    isSamePosition(other: ChunkPosition_$0): boolean;
}
declare class FlowChunkPosition {
    chunkPosition: ChunkPosition_$0;
    readonly flowChunk: FlowChunk;
    constructor(chunkPosition: ChunkPosition_$0, flowChunk: FlowChunk);
    clone(): FlowChunkPosition;
    isSamePosition(other: FlowChunkPosition): boolean;
}
declare class FlowPosition {
    positions: FlowChunkPosition[];
    startSide: string;
    breakAfter: string | null;
    clone(): FlowPosition;
    isSamePosition(other: FlowPosition): boolean;
    hasContent(offset: number): boolean;
}
declare class LayoutPosition {
    /**
     * One-based, incremented before layout.
     */
    page: number;
    flows: {
        [key: string]: Flow;
    };
    flowPositions: {
        [key: string]: FlowPosition;
    };
    /**
     * flowPositions is built up to this offset.
     */
    highestSeenOffset: number;
    highestSeenNode: Node;
    lookupPositionOffset: number;
    clone(): LayoutPosition;
    isSamePosition(other: LayoutPosition): boolean;
    /**
     * @param name flow name.
     */
    hasContent(name: string, offset: number): boolean;
    startSideOfFlow(name: string): string;
    firstFlowChunkOfFlow(name: string): FlowChunk | null;
}
declare class Container_$0 implements Vtree.Container_$0 {
    element: Element;
    left: number;
    top: number;
    marginLeft: number;
    marginRight: number;
    marginTop: number;
    marginBottom: number;
    borderLeft: number;
    borderRight: number;
    borderTop: number;
    borderBottom: number;
    paddingLeft: number;
    paddingRight: number;
    paddingTop: number;
    paddingBottom: number;
    width: number;
    height: number;
    originX: number;
    originY: number;
    exclusions: GeometryUtil.Shape[];
    innerShape: GeometryUtil.Shape;
    computedBlockSize: number;
    snapWidth: number;
    snapHeight: number;
    snapOffsetX: number;
    snapOffsetY: number;
    vertical: boolean;
    constructor(element: Element);
    getInsetTop(): number;
    getInsetBottom(): number;
    getInsetLeft(): number;
    getInsetRight(): number;
    getInsetBefore(): number;
    getInsetAfter(): number;
    getInsetStart(): number;
    getInsetEnd(): number;
    getBeforeEdge(box: ClientRect_$0): number;
    getAfterEdge(box: ClientRect_$0): number;
    getStartEdge(box: ClientRect_$0): number;
    getEndEdge(box: ClientRect_$0): number;
    getInlineSize(box: ClientRect_$0): number;
    getBoxSize(box: ClientRect_$0): number;
    getBoxDir(): number;
    getInlineDir(): number;
    copyFrom(other: Container_$0): void;
    setVerticalPosition(top: number, height: number): void;
    setHorizontalPosition(left: number, width: number): void;
    setBlockPosition(start: number, extent: number): void;
    setInlinePosition(start: number, extent: number): void;
    clear(): void;
    getInnerShape(): GeometryUtil.Shape;
    getInnerRect(): GeometryUtil.Rect;
    getPaddingRect(): GeometryUtil.Rect;
    getOuterShape(outerShapeProp: Css.Val, context: Exprs.Context): GeometryUtil.Shape;
    getOuterRect(): GeometryUtil.Rect;
}
declare type ExprContentListener_$0 = Vtree.ExprContentListener_$0;
/**
 * Potential breaking position.
 */
declare type BreakPosition_$0 = Layout.BreakPosition_$0;
declare abstract class AbstractBreakPosition_$0 implements Layout.AbstractBreakPosition_$0 {
    abstract findAcceptableBreak(column: Layout.Column, penalty: number): Vtree.NodeContext;
    abstract getMinBreakPenalty(): number;
    calculateOffset(column: any): {
        current: number;
        minimum: number;
    };
    /**
     * @override
     */
    breakPositionChosen(column: Layout.Column): void;
    getNodeContext(): Vtree.NodeContext;
}
/**
 * Processor doing some special layout (e.g. table layout)
 */
interface LayoutProcessor_$0 {
    /**
     * Do actual layout in the column starting from given NodeContext.
     */
    layout(nodeContext: Vtree.NodeContext, column: Layout.Column, leadingEdge: boolean): Task.Result<Vtree.NodeContext>;
    /**
     * Potential edge breaking position.
     */
    createEdgeBreakPosition(position: Vtree.NodeContext, breakOnEdge: string | null, overflows: boolean, columnBlockSize: number): Layout.BreakPosition;
    /**
     * process nodecontext at the start of a non inline element.
     * @return return true if you skip the subsequent nodes
     */
    startNonInlineElementNode(nodeContext: Vtree.NodeContext): boolean;
    /**
     * process nodecontext after a non inline element.
     * @return return true if you skip the subsequent nodes
     */
    afterNonInlineElementNode(nodeContext: Vtree.NodeContext, stopAtOverflow: boolean): boolean;
    /**
     * @return holing true
     */
    finishBreak(column: Layout.Column, nodeContext: Vtree.NodeContext, forceRemoveSelf: boolean, endOfColumn: boolean): Task.Result<boolean>;
    clearOverflownViewNodes(column: Layout.Column, parentNodeContext: Vtree.NodeContext, nodeContext: Vtree.NodeContext, removeSelf: boolean): any;
}
declare class BlockLayoutProcessor implements LayoutProcessor_$0 {
    /**
     * @override
     */
    layout(nodeContext: Vtree.NodeContext, column: Layout.Column, leadingEdge: boolean): Task.Result<Vtree.NodeContext>;
    /**
     * @override
     */
    createEdgeBreakPosition(position: Vtree.NodeContext, breakOnEdge: string | null, overflows: boolean, columnBlockSize: number): Layout.BreakPosition;
    /**
     * @override
     */
    startNonInlineElementNode(nodeContext: Vtree.NodeContext): boolean;
    /**
     * @override
     */
    afterNonInlineElementNode(nodeContext: Vtree.NodeContext, stopAtOverflow: boolean): boolean;
    /**
     * @override
     */
    clearOverflownViewNodes(column: Layout.Column, parentNodeContext: Vtree.NodeContext, nodeContext: Vtree.NodeContext, removeSelf: boolean): void;
    /**
     * @return holing true
     * @override
     */
    finishBreak(column: Layout.Column, nodeContext: Vtree.NodeContext, forceRemoveSelf: boolean, endOfColumn: boolean): Task.Result<boolean>;
}
/**
 * Type of implemented hooks.
 * @enum {string}
 */
declare enum HOOKS {
    /**
     * Called when a single property declaration is parsed.
     *
     * The hook is called with an object with the following properties:
     *   {string} name: Property name
     *   {!Css.Val} value: Property value
     *   {boolean} important: Whether '!important' flag is present or not
     * Functions called by this hook are expected to return a value with the same
     * type as the above. The declaration is then replaced by the returned value.
     *
     * Note that a shorthand declaration is not directly passed to this hook.
     * After the shorthand declaration is interpreted and broken into
     * non-shorthand declarations, the hook is called for each of the
     * non-shorthand declarations.
     */
    SIMPLE_PROPERTY = "SIMPLE_PROPERTY",
    /**
     * Called when a single document (i.e. a single spine item) has been fetched,
     * before parsing.
     *
     * The hook is called with the Document object.
     */
    PREPROCESS_SINGLE_DOCUMENT = "PREPROCESS_SINGLE_DOCUMENT",
    /**
     * Called before creating a text node for modifying a text content.
     *
     * The hook is called with an object with the following properties:
     *   {Vtree.NodeContext} nodeContext
     *   {string} sourceTextContent
     *
     * Functions called by this hook are expected to return a
     * Task.Result.<string>. The text content is then replaced by the
     * returned value.
     */
    PREPROCESS_TEXT_CONTENT = "PREPROCESS_TEXT_CONTENT",
    /**
     * Called before creating a element for modifying a element style.
     *
     * The hook is called with an object with the following properties:
     *   {Vtree.NodeContext} nodeContext
     *   {!Object} style
     */
    PREPROCESS_ELEMENT_STYLE = "PREPROCESS_ELEMENT_STYLE",
    /**
     * Called before geting CssCascade.polyfilledInheritedProps.
     *
     * The hook return a array of polyfilled inherited property name.
     */
    POLYFILLED_INHERITED_PROPS = "POLYFILLED_INHERITED_PROPS",
    /**
     * Called when a Viewer is configured.
     *
     * The hook is called with an object with the following properties:
     *  {Base.JSON} command
     */
    CONFIGURATION = "CONFIGURATION",
    /**
     * Called when resolving a text node breaker
     * which detects an acceptable breakpoint and break text node at this point.
     *
     * The hook is called with an object with the following properties:
     *  {Vtree.NodeContext} nodeContext
     *
     * Functions called by this hook are expected to
     * return an instnce of {Layout.TextNodeBreaker} or null.
     */
    RESOLVE_TEXT_NODE_BREAKER = "RESOLVE_TEXT_NODE_BREAKER",
    /**
     * Called when resolving a formatting context.
     *
     * The hook is called with the following parameters:
     *   nodeContext: a NodeContext object
     *   firstTime: a boolean flag representing whether this node is encountered
     * for the first time or not display: an Css.Ident value representing
     * 'display' value of the node position: an Css.Ident value representing
     * 'position' value of the node float: an Css.Ident value representing
     * 'float' value of the node isRoot: a boolean flag representing whether this
     * node is a root (of a flow) or not Functions called by this hook are
     * expected to return a formatting context for the NodeContext.
     */
    RESOLVE_FORMATTING_CONTEXT = "RESOLVE_FORMATTING_CONTEXT",
    /**
     * Called when resolving a layout processor (LayoutProcessor) for
     * a formatting context.
     *
     * The hook is called with a formatting context
     * (Vtree.FormattingContext). Functions called by this hook are expected
     * to return a layout processor corresponding to the formatting context.
     */
    RESOLVE_LAYOUT_PROCESSOR = "RESOLVE_LAYOUT_PROCESSOR",
    /**
     * Called after laid out a block contents.
     *
     * The hook is called with an object with the following properties:
     *  {Vtree.NodeContext} nodeContext
     *  {Array.<Vtree.NodeContext>} checkPoints
     *  {Layout.Column} column
     */
    POST_LAYOUT_BLOCK = "POST_LAYOUT_BLOCK"
}
declare type PreProcessSingleDocumentHook = (p1: Document) => any;
declare type PreProcessTextContentHook = (p1: Vtree.NodeContext, p2: string) => Task.Result<string>;
declare type PreProcessElementStyleHook = (p1: Vtree.NodeContext, p2: object) => void;
declare type PolyfilledInheritedPropsHook = () => string[];
declare type ConfigurationHook = (p1: Base.JSON) => {
    needResize: boolean | null | undefined;
    needRefresh: boolean | null | undefined;
};
declare type ResolveTextNodeBreakerHook = (p1: Vtree.NodeContext) => Layout.TextNodeBreaker;
declare type ResolveFormattingContextHook = (p1: Vtree.NodeContext, p2: boolean, p3: Css.Ident, p4: Css.Ident, p5: Css.Ident, p6: boolean) => Vtree.FormattingContext;
declare type ResolveLayoutProcessorHook = (p1: Vtree.FormattingContext) => LayoutProcessor_$0.LayoutProcessor_$0;
declare type PostLayoutBlockHook = (p1: Vtree.NodeContext, p2: Vtree.NodeContext[], p3: Layout.Column) => void;
/**
 * Register a function to a hook with the specified name.
 * The registered function is called at appropriate timings by the core code.
 * Arguments passed to the function depend on the hook.
 * When multiple functions are registered, they are called by the order in which
 * they are registered.
 * @param name Name of the hook.
 * @param fn Function to be registered to the hook.
 */
declare function registerHook(name: string, fn: (...p1: any[]) => any): void;
/**
 * Remove a function already registered to the specified name.
 * Note that even if the same function are registered multiple times, this
 * method removes only the first one.
 * @param name Name of the hook.
 * @param fn Function to be removed from the hook.
 */
declare function removeHook(name: string, fn: (...p1: any[]) => any): void;
/**
 * Get all hooks registered to the specified name.
 * This method is for internal use (from the core code).
 */
declare function getHooksForName(name: string): ((...p1: any[]) => any)[];
/**
 * Pubilc members of the bundled library.
 */
declare const plugin: {
    registerHook: typeof registerHook;
    removeHook: typeof removeHook;
};
/**
 * Performance profiler measuring execution time of the script.
 */
declare class Profiler {
    readonly performanceInstance: Performance;
    timestamps: {
        [key: string]: {
            [key: string]: number;
        };
    };
    private registerTiming;
    registerStartTiming: (name: string, timestamp?: number) => any;
    registerEndTiming: (name: string, timestamp?: number) => any;
    constructor(performanceInstance: Performance);
    /**
     * Registers start timing of some event, even if profile is disabled.
     * @param name Name of event
     * @param timestamp Used as the actual timestamp of the event if specified,
     *     instead of "now"
     */
    forceRegisterStartTiming(name: string, timestamp?: number): void;
    /**
     * Registers end timing of some event, even if profile is disabled.
     * @param name Name of event
     * @param timestamp Used as the actual timestamp of the event if specified,
     *     instead of "now"
     */
    forceRegisterEndTiming(name: string, timestamp?: number): void;
    /**
     * Log registered timings (start/end/duration).
     * All values are printed in ms unit.
     */
    printTimings(): void;
    /**
     * Disable profiling.
     */
    disable(): void;
    /**
     * Enable profiling.
     */
    enable(): void;
    /**
     * Returns if profiling is enabled or not.
     */
    isEnabled(): boolean;
}
declare const profiler: Profiler;
/**
 * Pubilc members of the bundled library.
 */
declare const profile: {
    profiler: {
        registerStartTiming: (name: string, timestamp?: number) => any;
        registerEndTiming: (name: string, timestamp?: number) => any;
        printTimings: () => void;
        disable: () => void;
        enable: () => void;
    };
};
declare type Position = {
    node: Node;
    offset: number;
    after: boolean;
    sideBias: string | null;
    ref: Fragment;
};
interface Step {
    appendTo(sb: Base.StringBuffer): void;
    applyTo(pos: Position): boolean;
}
declare class Fragment {
    steps: Step[];
    fromString(fragstr: string): void;
    navigate(doc: Document): Position;
    trim(text: string, after: boolean): string;
    /**
     * Initialize from a node and an offset.
     */
    prependPathFromNode(node: Node, offset: number, after: boolean, sideBias: string | null): void;
    toString(): string;
}
interface PropertyReceiver {
    unknownProperty(name: string, value: Css.Val): void;
    invalidPropertyValue(name: string, value: Css.Val): void;
    simpleProperty(name: string, value: Css.Val, important: any): void;
}
declare class Node {
    validator: PropertyValidator;
    success: Node;
    failure: Node;
    code: number;
    constructor(validator: PropertyValidator);
    isSpecial(): boolean;
    markAsStartGroup(): void;
    isStartGroup(): boolean;
    markAsEndGroup(): void;
    isEndGroup(): boolean;
    markAsStartAlternate(index: number): void;
    isStartAlternate(): boolean;
    markAsEndAlternate(index: number): void;
    isEndAlternate(): boolean;
    getAlternate(): number;
}
declare class Connection {
    where: number;
    success: boolean;
    what: number;
    constructor(where: number, success: boolean);
}
/**
 * @enum {number}
 */
declare enum Add_$0 {
    FOLLOW = 1,
    OPTIONAL = 2,
    REPEATED = 3,
    ALTERNATE = 4
}
/**
 * A class to build a list validator from other validators.
 */
declare class ValidatingGroup {
    nodes: Node[];
    connections: Connection[];
    match: number[];
    nomatch: number[];
    error: number[];
    emptyHead: boolean;
    connect(arr: number[], nodeIndex: number): void;
    clone(): ValidatingGroup;
    /**
     * Add "special" validation node to a given array (match, nomatch, or error).
     * @param start if this a start or the end of a clause/group
     * @param clause 0 indicates group start/end, otherwise clause index
     */
    private addSpecialToArr;
    endSpecialGroup(): void;
    startSpecialGroup(): void;
    endClause(clause: number): void;
    startClause(clause: number): void;
    addPrimitive(validator: PropertyValidator): void;
    isSimple(): boolean;
    isPrimitive(): boolean;
    addGroup(group: ValidatingGroup, how: Add_$0): void;
    /**
     * @return how
     */
    finish(successTerminal: Node, failTerminal: Node): Node;
}
declare type ValueMap = {
    [key: string]: Css.Val;
};
/**
 * Abstract class to validate simple CSS property value (not a shorthand)
 */
declare class PropertyValidator extends Css.Visitor {
    constructor();
    /**
     * Validate a subsequence of the given values from the given index. Return the
     * list of matched values or null if there is no match.
     */
    validateForShorthand(values: Css.Val[], index: number): Css.Val[];
}
/**
 * Validate a primitive CSS value (not a list or function).
 * @param allowed mask of ALLOW_*** constants.
 */
declare class PrimitiveValidator extends PropertyValidator {
    readonly allowed: number;
    readonly idents: ValueMap;
    readonly units: ValueMap;
    constructor(allowed: number, idents: ValueMap, units: ValueMap);
    /**
     * @override
     */
    visitEmpty(empty: Css.Val): Css.Val;
    /**
     * @override
     */
    visitSlash(slash: Css.Val): Css.Val;
    /**
     * @override
     */
    visitStr(str: Css.Str): Css.Val;
    /**
     * @override
     */
    visitIdent(ident: Css.Ident): Css.Val;
    /**
     * @override
     */
    visitNumeric(numeric: Css.Numeric): Css.Val;
    /**
     * @override
     */
    visitNum(num: Css.Num): Css.Val;
    /**
     * @override
     */
    visitInt(num: Css.Int): Css.Val;
    /**
     * @override
     */
    visitColor(color: Css.Color): Css.Val;
    /**
     * @override
     */
    visitURL(url: Css.URL): Css.Val;
    /**
     * @override
     */
    visitSpaceList(list: Css.SpaceList): Css.Val;
    /**
     * @override
     */
    visitCommaList(list: Css.CommaList): Css.Val;
    /**
     * @override
     */
    visitFunc(func: Css.Func): Css.Val;
    /**
     * @override
     */
    visitExpr(expr: Css.Expr): Css.Val;
    combine(other: PrimitiveValidator): PrimitiveValidator;
}
/**
 * Base class for list validation.
 */
declare class ListValidator extends PropertyValidator {
    successTerminal: Node;
    failureTerminal: Node;
    first: Node;
    constructor(group: ValidatingGroup);
    validateList(arr: Css.Val[], slice: boolean, startIndex: number): Css.Val[];
    validateSingle(inval: Css.Val): Css.Val;
    /**
     * @override
     */
    visitEmpty(empty: Css.Val): Css.Val;
    /**
     * @override
     */
    visitSlash(slash: Css.Val): Css.Val;
    /**
     * @override
     */
    visitStr(str: Css.Str): Css.Val;
    /**
     * @override
     */
    visitIdent(ident: Css.Ident): Css.Val;
    /**
     * @override
     */
    visitNumeric(numeric: Css.Numeric): Css.Val;
    /**
     * @override
     */
    visitNum(num: Css.Num): Css.Val;
    /**
     * @override
     */
    visitInt(num: Css.Int): Css.Val;
    /**
     * @override
     */
    visitColor(color: Css.Color): Css.Val;
    /**
     * @override
     */
    visitURL(url: Css.URL): Css.Val;
    /**
     * @override
     */
    visitSpaceList(list: Css.SpaceList): Css.Val;
    /**
     * @override
     */
    visitCommaList(list: Css.CommaList): Css.Val;
    /**
     * @override
     */
    visitFunc(func: Css.Func): Css.Val;
    /**
     * @override
     */
    visitExpr(expr: Css.Expr): Css.Val;
}
declare class ShorthandSyntaxNode {
    /**
     * @return new index.
     */
    tryParse(values: Css.Val[], index: number, shorthandValidator: ShorthandValidator): number;
    success(rval: Css.Val, shorthandValidator: ShorthandValidator): void;
}
declare class ShorthandSyntaxProperty extends ShorthandSyntaxNode {
    readonly name: string;
    validator: PropertyValidator;
    constructor(validatorSet: ValidatorSet, name: string);
    /**
     * @override
     */
    tryParse(values: Css.Val[], index: number, shorthandValidator: ShorthandValidator): number;
    /**
     * @override
     */
    success(rval: Css.Val, shorthandValidator: ShorthandValidator): void;
}
declare class ShorthandSyntaxPropertyN extends ShorthandSyntaxProperty {
    readonly names: string[];
    constructor(validatorSet: ValidatorSet, names: string[]);
    /**
     * @override
     */
    success(rval: Css.Val, shorthandValidator: ShorthandValidator): void;
}
declare class ShorthandValidator extends Css.Visitor {
    syntax: ShorthandSyntaxNode[];
    propList: string[];
    error: boolean;
    values: ValueMap;
    validatorSet: ValidatorSet;
    setOwner(validatorSet: ValidatorSet): void;
    syntaxNodeForProperty(name: string): ShorthandSyntaxNode;
    clone(): this;
    init(syntax: ShorthandSyntaxNode[], propList: string[]): void;
    finish(important: boolean, receiver: PropertyReceiver): boolean;
    propagateInherit(important: boolean, receiver: PropertyReceiver): void;
    validateList(list: Css.Val[]): number;
    validateSingle(val: Css.Val): Css.Val;
    /**
     * @override
     */
    visitEmpty(empty: Css.Val): Css.Val;
    /**
     * @override
     */
    visitStr(str: Css.Str): Css.Val;
    /**
     * @override
     */
    visitIdent(ident: Css.Ident): Css.Val;
    /**
     * @override
     */
    visitNumeric(numeric: Css.Numeric): Css.Val;
    /**
     * @override
     */
    visitNum(num: Css.Num): Css.Val;
    /**
     * @override
     */
    visitInt(num: Css.Int): Css.Val;
    /**
     * @override
     */
    visitColor(color: Css.Color): Css.Val;
    /**
     * @override
     */
    visitURL(url: Css.URL): Css.Val;
    /**
     * @override
     */
    visitSpaceList(list: Css.SpaceList): Css.Val;
    /**
     * @override
     */
    visitCommaList(list: Css.CommaList): Css.Val;
    /**
     * @override
     */
    visitFunc(func: Css.Func): Css.Val;
    /**
     * @override
     */
    visitExpr(expr: Css.Expr): Css.Val;
}
declare class SimpleShorthandValidator extends ShorthandValidator {
    constructor();
    /**
     * @override
     */
    validateList(list: Css.Val[]): number;
}
/**
 * Object that validates simple and shorthand properties, breaking up shorthand
 * properties into corresponding simple ones, also stripping property prefixes.
 */
declare class ValidatorSet {
    validators: {
        [key: string]: PropertyValidator;
    };
    prefixes: {
        [key: string]: {
            [key: string]: boolean;
        };
    };
    defaultValues: ValueMap;
    namedValidators: {
        [key: string]: ValidatingGroup;
    };
    systemFonts: {
        [key: string]: ValueMap;
    };
    shorthands: {
        [key: string]: ShorthandValidator;
    };
    layoutProps: ValueMap;
    backgroundProps: ValueMap;
    private addReplacement;
    private newGroup;
    private addCounts;
    private primitive;
    private newFunc;
    initBuiltInValidators(): void;
    private isBuiltIn;
    private readNameAndPrefixes;
    private parseValidators;
    private parseDefaults;
    private parseShorthands;
    parse(text: string): void;
    makePropSet(propList: string[]): ValueMap;
    validatePropertyAndHandleShorthand(name: string, value: Css.Val, important: boolean, receiver: PropertyReceiver): void;
}
interface Matcher {
    matches(): boolean;
}
interface ElementStyle_$0 extends CssCascade.ElementStyle_$0 {
}
declare class CascadeValue {
    readonly value: Css.Val;
    readonly priority: number;
    constructor(value: Css.Val, priority: number);
    getBaseValue(): CascadeValue;
    filterValue(visitor: Css.Visitor): CascadeValue;
    increaseSpecificity(specificity: number): CascadeValue;
    evaluate(context: Exprs.Context, propName: string): Css.Val;
    isEnabled(context: Exprs.Context): boolean;
}
declare type ElementStyleMap = {
    [key: string]: ElementStyle_$0;
};
declare type ActionTable = {
    [key: string]: CascadeAction;
};
declare class CascadeAction {
    apply(cascadeInstance: CascadeInstance): void;
    mergeWith(other: CascadeAction): CascadeAction;
    clone(): CascadeAction;
}
declare class ApplyRuleAction extends CascadeAction {
    readonly style: ElementStyle_$0;
    readonly specificity: number;
    readonly pseudoelement: string | null;
    readonly regionId: string | null;
    readonly viewConditionId: string | null;
    constructor(style: ElementStyle_$0, specificity: number, pseudoelement: string | null, regionId: string | null, viewConditionId: string | null);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
}
declare class ChainedAction extends CascadeAction {
    chained: CascadeAction;
    constructor();
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    getPriority(): number;
    makePrimary(cascade: Cascade): boolean;
}
declare class IsNthAction extends ChainedAction {
    readonly a: number;
    readonly b: number;
    constructor(a: number, b: number);
    /**
     * Checkes whether given order can be represented as an+b with a non-negative
     * interger n
     */
    protected matchANPlusB(order: number): boolean;
}
declare class CheckAppliedAction extends CascadeAction {
    applied: boolean;
    constructor();
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    clone(): CascadeAction;
}
/**
 * An object that is notified as elements are pushed and popped and typically
 * controls a "named condition" (which is a count associated with a name).
 */
interface ConditionItem {
    /**
     * Returns a "fresh" copy of this item. May be this if immutable.
     */
    fresh(cascadeInstance: CascadeInstance): ConditionItem;
    /**
     * Depth is 0 for element itself and its siblings, 1 for direct children and
     * -1 for the parent.
     */
    push(cascadeInstance: CascadeInstance, depth: number): boolean;
    /**
     * @return return true if no more notifications are desired
     */
    pop(cascadeInstance: CascadeInstance, depth: number): boolean;
}
declare class AbstractConditionItem {
    readonly condition: string;
    readonly viewConditionId: string | null;
    readonly viewCondition: Matchers.Matcher;
    constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
    increment(cascadeInstance: CascadeInstance): void;
    decrement(cascadeInstance: CascadeInstance): void;
    buildViewConditionMatcher(cascadeInstance: CascadeInstance): Matchers.Matcher;
}
declare type CounterValues = {
    [key: string]: number[];
};
interface CounterListener {
    countersOfId(id: string, counters: CounterValues): any;
    getExprContentListener(): Vtree_$0.ExprContentListener;
}
interface CounterResolver {
    /**
     * Returns an Exprs.Val, whose value is calculated at the layout time by
     * retrieving the innermost page-based counter (null if it does not exist) by
     * its name and formatting the value into a string.
     * @param name Name of the page-based counter to be retrieved
     * @param format A function that formats the counter value into a string
     */
    getPageCounterVal(name: string, format: (p1: number | null) => string): Exprs.Val;
    /**
     * Returns an Exprs.Val, whose value is calculated at the layout time by
     * retrieving the page-based counters by its name and formatting the values
     * into a string.
     * @param name Name of the page-based counters to be retrieved
     * @param format A function that formats the counter values (passed as an
     *     array ordered by the nesting depth with the outermost counter first and
     *     the innermost last) into a string
     */
    getPageCountersVal(name: string, format: (p1: number[]) => string): Exprs.Val;
    getTargetCounterVal(url: string, name: string, format: (p1: number | null) => string): Exprs.Val;
    getTargetCountersVal(url: string, name: string, format: (p1: number[]) => string): Exprs.Val;
    setStyler(styler: any): any;
}
declare type ChineseNumbering = {
    digits: string;
    markers: string;
    negative: string;
    formal: boolean;
};
declare class Cascade {
    nsCount: number;
    nsPrefix: {
        [key: string]: string;
    };
    tags: ActionTable;
    nstags: ActionTable;
    epubtypes: ActionTable;
    classes: ActionTable;
    ids: ActionTable;
    pagetypes: ActionTable;
    order: number;
    clone(): Cascade;
    insertInTable(table: ActionTable, key: string, action: CascadeAction): void;
    createInstance(context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: any): CascadeInstance;
    nextOrder(): number;
}
declare class CascadeInstance {
    readonly context: Exprs.Context;
    readonly counterListener: CounterListener;
    readonly counterResolver: CounterResolver;
    code: Cascade;
    stack: ConditionItem[][];
    conditions: {
        [key: string]: number;
    };
    currentElement: Element | null;
    currentElementOffset: number | null;
    currentStyle: ElementStyle_$0 | null;
    currentClassNames: string[] | null;
    currentLocalName: string;
    currentNamespace: string;
    currentId: string;
    currentXmlId: string;
    currentNSTag: string;
    currentEpubTypes: string[] | null;
    currentPageType: string | null;
    isFirst: boolean;
    isRoot: boolean;
    counters: {
        [key: string]: number[];
    };
    counterScoping: {
        [key: string]: boolean;
    }[];
    quotes: Css.Str[];
    quoteDepth: number;
    lang: string;
    siblingOrderStack: number[];
    currentSiblingOrder: number;
    siblingTypeCountsStack: {
        [key: string]: {
            [key: string]: number;
        };
    }[];
    currentSiblingTypeCounts: {
        [key: string]: {
            [key: string]: number;
        };
    };
    currentFollowingSiblingOrder: number | null;
    followingSiblingOrderStack: (number | null)[];
    followingSiblingTypeCountsStack: {
        [key: string]: {
            [key: string]: number;
        };
    }[];
    currentFollowingSiblingTypeCounts: {
        [key: string]: {
            [key: string]: number;
        };
    };
    viewConditions: {
        [key: string]: Matchers.Matcher[];
    };
    dependentConditions: string[];
    elementStack: Element[];
    currentDoc?: Document | null;
    constructor(cascade: Cascade, context: Exprs.Context, counterListener: CounterListener, counterResolver: CounterResolver, lang: string);
    pushConditionItem(item: ConditionItem): void;
    increment(condition: string, viewCondition: Matchers.Matcher): void;
    decrement(condition: string, viewCondition: Matchers.Matcher): void;
    buildViewConditionMatcher(viewConditionId: string | null): Matchers.Matcher;
    applyAction(table: ActionTable, key: string): void;
    pushRule(classes: string[], pageType: string | null, baseStyle: ElementStyle_$0): void;
    defineCounter(counterName: string, value: number): void;
    pushCounters(props: ElementStyle_$0): void;
    popCounters(): void;
    processPseudoelementProps(pseudoprops: ElementStyle_$0, element: Element): void;
    pushElement(element: Element, baseStyle: ElementStyle_$0, elementOffset: number): void;
    private applyAttrFilterInner;
    private applyAttrFilter;
    private applyActions;
    private pop;
    popRule(): void;
    popElement(element: Element): void;
}
/**
 * @enum {number}
 */
declare enum ParseState {
    TOP = 0,
    SELECTOR = 1,
    RULE = 2
}
declare class CascadeParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
    readonly condition: Exprs.Val;
    readonly regionId: string | null;
    readonly validatorSet: CssValidator.ValidatorSet;
    chain: ChainedAction[];
    specificity: number;
    elementStyle: ElementStyle_$0;
    conditionCount: number;
    pseudoelement: string | null;
    footnoteContent: boolean;
    cascade: Cascade;
    state: ParseState;
    viewConditionId: string | null;
    insideSelectorRule: ParseState;
    constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, condition: Exprs.Val, parent: CascadeParserHandler, regionId: string | null, validatorSet: CssValidator.ValidatorSet, topLevel: boolean);
    protected insertNonPrimary(action: CascadeAction): void;
    processChain(action: CascadeAction): void;
    isInsideSelectorRule(mnemonics: string): boolean;
    /**
     * @override
     */
    tagSelector(ns: string | null, name: string | null): void;
    /**
     * @override
     */
    classSelector(name: string): void;
    /**
     * @override
     */
    pseudoclassSelector(name: string, params: (number | string)[]): void;
    /**
     * @override
     */
    pseudoelementSelector(name: string, params: (number | string)[]): void;
    /**
     * @override
     */
    idSelector(id: string): void;
    /**
     * @override
     */
    attributeSelector(ns: string, name: string, op: CssTokenizer.TokenType, value: string | null): void;
    /**
     * @override
     */
    descendantSelector(): void;
    /**
     * @override
     */
    childSelector(): void;
    /**
     * @override
     */
    adjacentSiblingSelector(): void;
    /**
     * @override
     */
    followingSiblingSelector(): void;
    /**
     * @override
     */
    nextSelector(): void;
    /**
     * @override
     */
    startSelectorRule(): void;
    /**
     * @override
     */
    error(mnemonics: string, token: CssTokenizer.Token): void;
    /**
     * @override
     */
    startStylesheet(flavor: CssParser.StylesheetFlavor): void;
    /**
     * @override
     */
    startRuleBody(): void;
    /**
     * @override
     */
    endRule(): void;
    finishChain(): void;
    protected makeApplyRuleAction(specificity: number): ApplyRuleAction;
    special(name: string, value: Css.Val): void;
    /**
     * @override
     */
    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;
    finish(): Cascade;
    /**
     * @override
     */
    startFuncWithSelector(funcName: string): void;
}
declare class SlipRange {
    endStuckFixed: number;
    endFixed: number;
    endSlipped: number;
    constructor(endStuckFixed: any, endFixed: any, endSlipped: any);
}
/**
 * Maps all ints in a range ("fixed") to ints with slippage ("slipped")
 */
declare class SlipMap {
    map: SlipRange[];
    getMaxFixed(): number;
    getMaxSlipped(): number;
    addStuckRange(endFixed: number): void;
    addSlippedRange(endFixed: number): void;
    slippedByFixed(fixed: number): number;
    /**
     * Smallest fixed for a given slipped.
     */
    fixedBySlipped(slipped: number): number;
}
interface FlowListener {
    /**
     * @return void
     */
    encounteredFlowChunk(flowChunk: Vtree_$0.FlowChunk, flow: Vtree_$0.Flow): any;
}
interface AbstractStyler_$0 extends CssStyler.AbstractStyler_$0 {
}
/**
 * Represent a box generated by a (pseudo)element. When constructed, a box
 * corresponding to `::before` pseudoelement is also constructed and stored in
 * `beforeBox` property, whereas one corresponding `::after` pseudoelement is
 * not constructed and `afterBox` property is `null`. `afterBox` is constructed
 * by `buildAfterPseudoElementBox` method.
 * @param style Cascaded style values for the box.
 * @param offset The start offset of the box. It coincides with the start offset
 *     of the element if the box is generated by the element or the `::before`
 *     pseudoelement. When the box corresponds to the `::after` pseudoelement,
 *     the offset is just after the content before the `::after` pseudoelement.
 * @param isRoot True if the box is generated by the root element (not
 *     pseudoelement).
 * @param flowChunk FlowChunk to which the box belongs to.
 * @param atBlockStart True if the box is right after the block start edge.
 * @param atFlowStart True if the box is right after the flow start.
 * @param isParentBoxDisplayed True if the parent box has a displayed box.
 */
declare class Box {
    readonly context: Exprs.Context;
    readonly style: CssCascade_$0.ElementStyle;
    readonly offset: number;
    readonly isRoot: boolean;
    readonly flowChunk: Vtree_$0.FlowChunk;
    readonly atBlockStart: boolean;
    readonly atFlowStart: boolean;
    readonly isParentBoxDisplayed: boolean;
    flowName: string;
    isBlockValue: boolean | null;
    hasBoxValue: boolean | null;
    styleValues: {
        [key: string]: Css.Val;
    };
    beforeBox: Box;
    afterBox: Box;
    breakBefore: string | null;
    constructor(context: Exprs.Context, style: CssCascade_$0.ElementStyle, offset: number, isRoot: boolean, flowChunk: Vtree_$0.FlowChunk, atBlockStart: boolean, atFlowStart: boolean, isParentBoxDisplayed: boolean);
    /**
     * Build a box corresponding to `::after` pseudoelement and stores it in
     * `afterBox` property.
     * @param offset The start offset of the `::after` pseudoelement box, which is
     *     just after the content before the `::after` pseudoelement.
     * @param atBlockStart True if the box is right after the block start edge.
     * @param atFlowStart True if the box is right after the flow start.
     */
    buildAfterPseudoElementBox(offset: number, atBlockStart: boolean, atFlowStart: boolean): void;
    styleValue(name: string, defaultValue?: Css.Val): Css.Val | null;
    displayValue(): Css.Val;
    isBlock(): boolean;
    hasBox(): boolean;
    getBreakValue(edge: string): string | null;
}
/**
 * Manages boxes generated by elements as a stack.
 */
declare class BoxStack {
    readonly context: Exprs.Context;
    stack: Box[];
    atBlockStart: boolean;
    atFlowStart: boolean;
    atStartStack: {
        atBlockStart: boolean;
        atFlowStart: boolean;
    }[];
    constructor(context: Exprs.Context);
    /**
     * Returns if the stack is empty.
     */
    empty(): boolean;
    /**
     * Returns the last box in the stack.
     */
    lastBox(): Box | undefined;
    /**
     * Returns the flow name of the last box in the stack.
     */
    lastFlowName(): string | null;
    /**
     * Returns if the last box in the stack is displayed.
     */
    isCurrentBoxDisplayed(): boolean;
    /**
     * Create a new box and push it to the stack.
     * @param style Cascaded style values for the box.
     * @param offset The start offset of the box.
     * @param isRoot True if the box is generated by the root element
     * @param newFlowChunk Specify if the element is a flow element (i.e. the
     *     element is specified a new `flow-into` value)
     */
    push(style: CssCascade_$0.ElementStyle, offset: number, isRoot: boolean, newFlowChunk?: Vtree_$0.FlowChunk): Box;
    encounteredTextNode(node: Node): void;
    /**
     * Pop the last box.
     */
    pop(offset: number): Box;
    /**
     * Find the start offset of the nearest block start edge to which the
     * `break-before` value of the box should be propagated. This method can be
     * called when after pushing the box into the stack or after popping the box
     * out of the stack.
     */
    nearestBlockStartOffset(box: Box): number;
}
/**
 * A font declared in a font-face rule.
 */
declare class Face {
    readonly properties: {
        [key: string]: Css.Val;
    };
    fontTraitKey: string;
    src: string | null;
    blobURLs: string[];
    blobs: Blob[];
    family: string | null;
    constructor(properties: {
        [key: string]: Css.Val;
    });
    /**
     * Check if font traits are the same for two font faces
     */
    traitsEqual(other: Face): boolean;
    /**
     * Create "at" font-face rule.
     */
    makeAtRule(src: string, fontBytes: Blob): string;
}
/**
 * Set of the fonts declared in all stylesheets of a document.
 * @param deobfuscator function
 *     that takes url and returns data deobfuscator
 */
declare class DocumentFaces {
    readonly deobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null;
    /**
     * Maps source font family names to the family names used in the HTML view.
     */
    familyMap: {
        [key: string]: string;
    };
    constructor(deobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null);
    registerFamily(srcFace: Face, viewFace: Face): void;
    filterFontFamily(val: Css.Val): Css.Val;
}
declare const FloatReference_$0: typeof PageFloats.FloatReference_$0;
declare type FloatReference_$0 = PageFloats.FloatReference_$0;
declare type PageFloatID_$0 = PageFloats.PageFloatID_$0;
declare class PageFloat_$0 implements PageFloats.PageFloat_$0 {
    readonly nodePosition: Vtree.NodePosition;
    readonly floatReference: FloatReference_$0;
    readonly floatSide: string;
    readonly clearSide: string | null;
    readonly flowName: string;
    readonly floatMinWrapBlock: Css.Numeric | null;
    order: number | null;
    id: PageFloatID_$0 | null;
    constructor(nodePosition: Vtree.NodePosition, floatReference: FloatReference_$0, floatSide: string, clearSide: string | null, flowName: string, floatMinWrapBlock: Css.Numeric | null);
    getOrder(): number;
    getId(): PageFloatID_$0;
    isAllowedOnContext(pageFloatLayoutContext: PageFloatLayoutContext_$0): boolean;
    isAllowedToPrecede(other: PageFloat_$0): boolean;
}
/**
 * @param continues Represents whether the float is fragmented and continues
 *     after this fragment
 */
declare class PageFloatFragment_$0 implements PageFloats.PageFloatFragment_$0 {
    readonly floatReference: FloatReference_$0;
    readonly floatSide: string;
    readonly continuations: PageFloatContinuation_$0[];
    readonly area: Vtree.Container;
    readonly continues: boolean;
    constructor(floatReference: FloatReference_$0, floatSide: string, continuations: PageFloatContinuation_$0[], area: Vtree.Container, continues: boolean);
    hasFloat(float: PageFloat_$0): boolean;
    findNotAllowedFloat(context: PageFloatLayoutContext_$0): PageFloat_$0 | null;
    getOuterShape(): GeometryUtil.Shape;
    getOuterRect(): GeometryUtil.Rect;
    getOrder(): number;
    shouldBeStashedBefore(float: PageFloat_$0): boolean;
    addContinuations(continuations: PageFloatContinuation_$0[]): void;
    getFlowName(): string;
}
declare class PageFloatContinuation_$0 implements PageFloats.PageFloatContinuation_$0 {
    readonly float: PageFloat_$0;
    readonly nodePosition: Vtree.NodePosition;
    constructor(float: PageFloat_$0, nodePosition: Vtree.NodePosition);
    equals(other: PageFloatContinuation_$0 | null): boolean;
}
declare type PageFloatPlacementCondition_$0 = PageFloats.PageFloatPlacementCondition_$0;
/**
 * @param generatingNodePosition Source NodePosition generating the context.
 *     Specify when a column context is generated by a non-root element (for
 *     example page floats)
 */
declare class PageFloatLayoutContext_$0 implements PageFloats.PageFloatLayoutContext_$0 {
    readonly parent: PageFloatLayoutContext_$0;
    private readonly floatReference;
    private container;
    readonly flowName: string | null;
    readonly generatingNodePosition: Vtree.NodePosition | null;
    private children;
    writingMode: Css.Val;
    direction: Css.Val;
    private invalidated;
    private floatStore;
    private forbiddenFloats;
    floatFragments: PageFloatFragment_$0[];
    private stashedFloatFragments;
    private floatAnchors;
    private floatsDeferredToNext;
    private floatsDeferredFromPrevious;
    private layoutConstraints;
    private locked;
    constructor(parent: PageFloatLayoutContext_$0, floatReference: FloatReference_$0 | null, container: Vtree.Container, flowName: string | null, generatingNodePosition: Vtree.NodePosition | null, writingMode: Css.Val | null, direction: Css.Val | null);
    private getParent;
    private getPreviousSiblingOf;
    private getPreviousSibling;
    getContainer(floatReference?: FloatReference_$0): Vtree.Container;
    setContainer(container: Vtree.Container): void;
    addPageFloat(float: PageFloat_$0): void;
    getPageFloatLayoutContext(floatReference: FloatReference_$0): PageFloatLayoutContext_$0;
    findPageFloatByNodePosition(nodePosition: Vtree.NodePosition): PageFloat_$0 | null;
    private forbid;
    isForbidden(float: PageFloat_$0): boolean;
    addPageFloatFragment(floatFragment: PageFloatFragment_$0, dontInvalidate?: boolean): void;
    removePageFloatFragment(floatFragment: PageFloatFragment_$0, dontInvalidate?: boolean): void;
    findPageFloatFragment(float: PageFloat_$0): PageFloatFragment_$0 | null;
    hasFloatFragments(condition?: (p1: PageFloatFragment_$0) => boolean): boolean;
    hasContinuingFloatFragmentsInFlow(flowName: string): boolean;
    registerPageFloatAnchor(float: PageFloat_$0, anchorViewNode: Node): void;
    collectPageFloatAnchors(): any;
    isAnchorAlreadyAppeared(floatId: PageFloatID_$0): boolean;
    deferPageFloat(continuation: PageFloatContinuation_$0): void;
    hasPrecedingFloatsDeferredToNext(float: PageFloat_$0, ignoreReference?: boolean): boolean;
    getLastFollowingFloatInFragments(float: PageFloat_$0): PageFloat_$0 | null;
    getDeferredPageFloatContinuations(flowName?: string | null): PageFloatContinuation_$0[];
    getPageFloatContinuationsDeferredToNext(flowName?: string | null): PageFloatContinuation_$0[];
    getFloatsDeferredToNextInChildContexts(): PageFloat_$0[];
    checkAndForbidNotAllowedFloat(): boolean;
    checkAndForbidFloatFollowingDeferredFloat(): boolean;
    finish(): void;
    hasSameContainerAs(other: PageFloatLayoutContext_$0): boolean;
    invalidate(): void;
    detachChildren(): PageFloatLayoutContext_$0[];
    attachChildren(children: PageFloatLayoutContext_$0[]): void;
    isInvalidated(): any;
    validate(): void;
    private toLogical;
    private toPhysical;
    removeEndFloatFragments(floatSide: string): void;
    stashEndFloatFragments(float: PageFloat_$0): void;
    restoreStashedFragments(floatReference: FloatReference_$0): void;
    discardStashedFragments(floatReference: FloatReference_$0): void;
    getStashedFloatFragments(floatReference: FloatReference_$0): PageFloatFragment_$0[];
    private getLimitValue;
    private getLimitValueInner;
    private getLimitValuesInner;
    /**
     * @param anchorEdge Null indicates that the anchor is not in the current
     *     container.
     * @return Logical float side (snap-block is resolved when init=false). Null
     *     indicates that the float area does not fit inside the container
     */
    setFloatAreaDimensions(area: LayoutType.PageFloatArea, floatReference: FloatReference_$0, floatSide: string, anchorEdge: number | null, init: boolean, force: boolean, condition: PageFloatPlacementCondition_$0): string | null;
    getFloatFragmentExclusions(): GeometryUtil.Shape[];
    private reattachFloatFragments;
    getMaxReachedAfterEdge(): number;
    getBlockStartEdgeOfBlockEndFloats(): number;
    getPageFloatClearEdge(clear: string, column: LayoutType.Column): number;
    getPageFloatPlacementCondition(float: PageFloat_$0, floatSide: string, clearSide: string | null): PageFloatPlacementCondition_$0;
    getLayoutConstraints(): LayoutType.LayoutConstraint[];
    addLayoutConstraint(layoutConstraint: LayoutType.LayoutConstraint, floatReference: FloatReference_$0): void;
    isColumnFullWithPageFloats(column: LayoutType.Column): boolean;
    getMaxBlockSizeOfPageFloats(): number;
    lock(): void;
    unlock(): void;
    isLocked(): boolean;
}
interface PageFloatLayoutStrategy_$0 extends PageFloats.PageFloatLayoutStrategy_$0 {
}
declare type LayoutIteratorState = {
    nodeContext: Vtree.NodeContext;
    atUnforcedBreak: boolean;
    break: boolean;
    leadingEdge?: boolean;
    breakAtTheEdge?: string | null;
    onStartEdges?: boolean;
    leadingEdgeContexts?: Vtree.NodeContext[];
    lastAfterNodeContext?: Vtree.NodeContext | null;
};
declare class LayoutIteratorStrategy {
    initialState(initialNodeContext: Vtree.NodeContext): LayoutIteratorState;
    startNonDisplayableNode(state: LayoutIteratorState): void | Task.Result<boolean>;
    afterNonDisplayableNode(state: LayoutIteratorState): void | Task.Result<boolean>;
    startIgnoredTextNode(state: LayoutIteratorState): void | Task.Result<boolean>;
    afterIgnoredTextNode(state: LayoutIteratorState): void | Task.Result<boolean>;
    startNonElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
    afterNonElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
    startInlineElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
    afterInlineElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
    startNonInlineElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
    afterNonInlineElementNode(state: LayoutIteratorState): void | Task.Result<boolean>;
    finish(state: LayoutIteratorState): void | Task.Result<boolean>;
}
declare class AfterIfContinuesElementsOffset_$0 implements Selectors.AfterIfContinuesElementsOffset_$0 {
    nodeContext: any;
    pseudoElementHeight: any;
    constructor(nodeContext: any, pseudoElementHeight: any);
    /** @override */
    calculateOffset(nodeContext: Vtree.NodeContext): number;
    /** @override */
    calculateMinimumOffset(nodeContext: Vtree.NodeContext): number;
    affectTo(nodeContext: Vtree.NodeContext): boolean;
}
/**
 * Represents a constraint on layout
 */
declare type LayoutConstraint_$0 = Layout.LayoutConstraint_$0;
/**
 * Represents constraints on laying out fragments
 */
declare type FragmentLayoutConstraint_$0 = Layout.FragmentLayoutConstraint_$0;
declare type BreakPositionAndNodeContext_$0 = Layout.BreakPositionAndNodeContext_$0;
/**
 * Potential breaking position inside CSS box (between lines).
 * @param checkPoints array of breaking points for breakable block
 */
declare class BoxBreakPosition_$0 extends BreakPosition_$0.AbstractBreakPosition implements Layout.BoxBreakPosition_$0 {
    readonly checkPoints: Vtree.NodeContext[];
    readonly penalty: number;
    private alreadyEvaluated;
    breakNodeContext: Vtree.NodeContext;
    constructor(checkPoints: Vtree.NodeContext[], penalty: number);
    /**
     * @override
     */
    findAcceptableBreak(column: Column_$0, penalty: number): Vtree.NodeContext;
    /**
     * @override
     */
    getMinBreakPenalty(): number;
    /** @override */
    getNodeContext(): Vtree.NodeContext;
}
declare class Column_$0 extends VtreeImpl.Container implements Layout.Column_$0 {
    layoutContext: Vtree.LayoutContext;
    clientLayout: Vtree.ClientLayout;
    readonly layoutConstraint: LayoutConstraint_$0;
    readonly pageFloatLayoutContext: PageFloats_$0.PageFloatLayoutContext;
    last: Node;
    viewDocument: Document;
    flowRootFormattingContext: Vtree.FormattingContext;
    isFloat: boolean;
    isFootnote: boolean;
    startEdge: number;
    endEdge: number;
    beforeEdge: number;
    afterEdge: number;
    footnoteEdge: number;
    box: GeometryUtil.Rect;
    chunkPositions: Vtree.ChunkPosition[];
    bands: GeometryUtil.Band[];
    overflown: boolean;
    breakPositions: BreakPosition_$0.BreakPosition_$0[];
    pageBreakType: string | null;
    forceNonfitting: boolean;
    leftFloatEdge: number;
    rightFloatEdge: number;
    bottommostFloatTop: number;
    stopAtOverflow: boolean;
    lastAfterPosition: Vtree.NodePosition | null;
    fragmentLayoutConstraints: FragmentLayoutConstraint_$0[];
    pseudoParent: Column_$0;
    nodeContextOverflowingDueToRepetitiveElements: Vtree.NodeContext | null;
    blockDistanceToBlockEndFloats: number;
    computedBlockSize: number;
    constructor(element: Element, layoutContext: Vtree.LayoutContext, clientLayout: Vtree.ClientLayout, layoutConstraint: LayoutConstraint_$0, pageFloatLayoutContext: PageFloats_$0.PageFloatLayoutContext);
    getTopEdge(): number;
    getBottomEdge(): number;
    getLeftEdge(): number;
    getRightEdge(): number;
    isFloatNodeContext(nodeContext: Vtree.NodeContext): boolean;
    stopByOverflow(nodeContext: Vtree.NodeContext): boolean;
    isOverflown(edge: number): boolean;
    getExclusions(): GeometryUtil.Shape[];
    openAllViews(position: Vtree.NodePosition): Task.Result<Vtree.NodeContext>;
    calculateOffsetInNodeForNodeContext(position: Vtree.NodePosition): number;
    /**
     * @param count first-XXX nesting identifier
     */
    maybePeelOff(position: Vtree.NodeContext, count: number): Task.Result<Vtree.NodeContext>;
    /**
     * Builds the view until a CSS box edge is reached.
     * @param position start source position.
     * @param checkPoints array to append possible breaking points.
     * @return holding box edge position reached or null if the source is exhausted.
     */
    buildViewToNextBlockEdge(position: Vtree.NodeContext, checkPoints: Vtree.NodeContext[]): Task.Result<Vtree.NodeContext>;
    nextInTree(position: Vtree.NodeContext, atUnforcedBreak?: boolean): Task.Result<Vtree.NodeContext>;
    /**
     * Builds the view for a single unbreakable element.
     * @param position start source position.
     * @return holding box edge position reached or null if the source is exhausted.
     */
    buildDeepElementView(position: Vtree.NodeContext): Task.Result<Vtree.NodeContext>;
    /**
     * Create a single floating element (for exclusion areas).
     * @param ref container's child to insert float before (can be null).
     * @param side float side ("left" or "right").
     * @param width float inline dimension.
     * @param height float box progression dimension.
     * @return newly created float element.
     */
    createFloat(ref: Node, side: string, width: number, height: number): Element;
    /**
     * Remove all the exclusion floats.
     */
    killFloats(): void;
    /**
     * Create exclusion floats for a column.
     */
    createFloats(): void;
    /**
     * @param nodeContext position after the block
     * @param checkPoints array of possible breaking points.
     * @param index index of the breaking point
     * @param boxOffset box offset
     * @return edge position
     */
    calculateEdge(nodeContext: Vtree.NodeContext, checkPoints: Vtree.NodeContext[], index: number, boxOffset: number): number;
    /**
     * Parse CSS computed length (in pixels)
     * @param val CSS length in "px" units or a number.
     * @return value in pixels or 0 if not parsable
     */
    parseComputedLength(val: string | number): number;
    /**
     * Reads element's computed CSS margin.
     */
    getComputedMargin(element: Element): GeometryUtil.Insets;
    /**
     * Reads element's computed padding + borders.
     */
    getComputedPaddingBorder(element: Element): GeometryUtil.Insets;
    /**
     * Reads element's computed CSS insets(margins + border + padding or margins :
     * depends on box-sizing)
     */
    getComputedInsets(element: Element): GeometryUtil.Insets;
    /**
     * Set element's computed CSS insets to Column Container
     */
    setComputedInsets(element: Element, container: Column_$0): void;
    /**
     * Set element's computed width and height to Column Container
     */
    setComputedWidthAndHeight(element: Element, container: Column_$0): void;
    /**
     * Layout a single unbreakable element.
     */
    layoutUnbreakable(nodeContextIn: Vtree.NodeContext): Task.Result<Vtree.NodeContext>;
    /**
     * Layout a single float element.
     */
    layoutFloat(nodeContext: Vtree.NodeContext): Task.Result<Vtree.NodeContext>;
    setupFloatArea(area: PageFloatArea_$0, floatReference: PageFloats_$0.FloatReference, floatSide: string, anchorEdge: number | null, strategy: PageFloats_$0.PageFloatLayoutStrategy, condition: PageFloats_$0.PageFloatPlacementCondition): boolean;
    createPageFloatArea(float: PageFloats_$0.PageFloat | null, floatSide: string, anchorEdge: number | null, strategy: PageFloats_$0.PageFloatLayoutStrategy, condition: PageFloats_$0.PageFloatPlacementCondition): PageFloatArea_$0 | null;
    layoutSinglePageFloatFragment(continuations: PageFloats_$0.PageFloatContinuation[], floatSide: string, clearSide: string | null, allowFragmented: boolean, strategy: PageFloats_$0.PageFloatLayoutStrategy, anchorEdge: number | null, pageFloatFragment?: PageFloats_$0.PageFloatFragment | null): Task.Result<SinglePageFloatLayoutResult_$0>;
    layoutPageFloatInner(continuation: PageFloats_$0.PageFloatContinuation, strategy: PageFloats_$0.PageFloatLayoutStrategy, anchorEdge: number | null, pageFloatFragment?: PageFloats_$0.PageFloatFragment): Task.Result<boolean>;
    /**
     * @returns Represents if the layout was succeeded or not
     */
    private layoutStashedPageFloats;
    setFloatAnchorViewNode(nodeContext: Vtree.NodeContext): Vtree.NodeContext;
    resolveFloatReferenceFromColumnSpan(floatReference: PageFloats_$0.FloatReference, columnSpan: Css.Val, nodeContext: Vtree.NodeContext): Task.Result<PageFloats_$0.FloatReference>;
    layoutPageFloat(nodeContext: Vtree.NodeContext): Task.Result<Vtree.NodeContext>;
    createJustificationAdjustmentElement(insertionPoint: Node, doc: Document, parentNode: Node, vertical: boolean): HTMLElement;
    addAndAdjustJustificationElement(nodeContext: Vtree.NodeContext, insertAfter: boolean, node: Node, insertionPoint: Node, doc: Document, parentNode: Node): HTMLElement;
    compensateJustificationLineHeight(span: Element, br: Element, nodeContext: Vtree.NodeContext): void;
    /**
     * Fix justification of the last line of text broken across pages (if
     * needed).
     */
    fixJustificationIfNeeded(nodeContext: Vtree.NodeContext, endOfColumn: boolean): void;
    processLineStyling(nodeContext: Vtree.NodeContext, resNodeContext: Vtree.NodeContext, checkPoints: Vtree.NodeContext[]): Task.Result<Vtree.NodeContext>;
    isLoneImage(checkPoints: Vtree.NodeContext[]): boolean;
    getTrailingMarginEdgeAdjustment(trailingEdgeContexts: Vtree.NodeContext[]): number;
    /**
     * Layout a single CSS box.
     */
    layoutBreakableBlock(nodeContext: Vtree.NodeContext): Task.Result<Vtree.NodeContext>;
    postLayoutBlock(nodeContext: Vtree.NodeContext, checkPoints: Vtree.NodeContext[]): void;
    findEndOfLine(linePosition: number, checkPoints: Vtree.NodeContext[], isUpdateMaxReachedAfterEdge: boolean): {
        nodeContext: Vtree.NodeContext;
        index: number;
        checkPointIndex: number;
    };
    findAcceptableBreakInside(checkPoints: Vtree.NodeContext[], edgePosition: number, force: boolean): Vtree.NodeContext;
    resolveTextNodeBreaker(nodeContext: Vtree.NodeContext): TextNodeBreaker_$0;
    /**
     * Read ranges skipping special elments
     */
    getRangeBoxes(start: Node, end: Node): Vtree.ClientRect[];
    /**
     * Give block's initial and final nodes, find positions of the line bottoms.
     * This is, of course, somewhat hacky implementation.
     * @return position of line breaks
     */
    findLinePositions(checkPoints: Vtree.NodeContext[]): number[];
    calculateClonedPaddingBorder(nodeContext: Vtree.NodeContext): number;
    private getOffsetByRepetitiveElements;
    findBoxBreakPosition(bp: BoxBreakPosition_$0, force: boolean): Vtree.NodeContext;
    getAfterEdgeOfBlockContainer(nodeContext: Vtree.NodeContext): number;
    findFirstOverflowingEdgeAndCheckPoint(checkPoints: Vtree.NodeContext[]): {
        edge: number;
        checkPoint: Vtree.NodeContext | null;
    };
    findEdgeBreakPosition(bp: BreakPosition_$0.EdgeBreakPosition): Vtree.NodeContext;
    /**
     * Finalize a line break.
     * @return holing true
     */
    finishBreak(nodeContext: Vtree.NodeContext, forceRemoveSelf: boolean, endOfColumn: boolean): Task.Result<boolean>;
    findAcceptableBreakPosition(): BreakPositionAndNodeContext_$0;
    doFinishBreak(nodeContext: Vtree.NodeContext, overflownNodeContext: Vtree.NodeContext, initialNodeContext: Vtree.NodeContext, initialComputedBlockSize: number): Task.Result<Vtree.NodeContext>;
    /**
     * 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
     */
    checkOverflowAndSaveEdge(nodeContext: Vtree.NodeContext, trailingEdgeContexts: Vtree.NodeContext[]): boolean;
    /**
     * Save a possible page break position on a CSS block edge. Check if it
     * overflows.
     * @return true if overflows
     */
    checkOverflowAndSaveEdgeAndBreakPosition(nodeContext: Vtree.NodeContext, trailingEdgeContexts: Vtree.NodeContext[], saveEvenOverflown: boolean, breakAtTheEdge: string | null): boolean;
    applyClearance(nodeContext: Vtree.NodeContext): boolean;
    isBFC(formattingContext: Vtree.FormattingContext): boolean;
    /**
     * Skips positions until either the start of unbreakable block or inline
     * content. Also sets breakBefore on the result combining break-before and
     * break-after properties from all elements that meet at the edge.
     */
    skipEdges(nodeContext: Vtree.NodeContext, leadingEdge: boolean, forcedBreakValue: string | null): Task.Result<Vtree.NodeContext>;
    /**
     * Skips non-renderable positions until it hits the end of the flow or some
     * renderable content. Returns the nodeContext that was passed in if some
     * content remains and null if all content could be skipped.
     */
    skipTailEdges(nodeContext: Vtree.NodeContext): Task.Result<Vtree.NodeContext>;
    layoutFloatOrFootnote(nodeContext: Vtree.NodeContext): Task.Result<Vtree.NodeContext>;
    /**
     * Layout next portion of the source.
     */
    layoutNext(nodeContext: Vtree.NodeContext, leadingEdge: boolean, forcedBreakValue?: string | null): Task.Result<Vtree.NodeContext>;
    clearOverflownViewNodes(nodeContext: Vtree.NodeContext, removeSelf: boolean): void;
    initGeom(): void;
    init(): void;
    /**
     * Save the potential breaking position at the edge. Should, in general, save
     * "after" position but only after skipping all of the "before" ones and
     * getting to the non-empty content (to get breakAtEdge right).
     */
    saveEdgeBreakPosition(position: Vtree.NodeContext, breakAtEdge: string | null, overflows: boolean): void;
    /**
     * @param checkPoints array of breaking points for breakable block
     */
    saveBoxBreakPosition(checkPoints: Vtree.NodeContext[]): void;
    updateMaxReachedAfterEdge(afterEdge: number): void;
    /**
     * @param chunkPosition starting position.
     * @return holding end position.
     */
    layout(chunkPosition: Vtree.ChunkPosition, leadingEdge: boolean, breakAfter?: string | null): Task.Result<Vtree.ChunkPosition>;
    isFullWithPageFloats(): boolean;
    getMaxBlockSizeOfPageFloats(): number;
    doFinishBreakOfFragmentLayoutConstraints(nodeContext: Vtree.NodeContext): Task.Result<boolean>;
    /**
     * @param nodeContext starting position.
     * @return holding end position.
     */
    doLayout(nodeContext: Vtree.NodeContext, leadingEdge: boolean, breakAfter?: string | null): Task.Result<{
        nodeContext: Vtree.NodeContext;
        overflownNodeContext: Vtree.NodeContext;
    }>;
    /**
     * Re-layout already laid-out chunks. Return the position of the last flow if
     * there is an overflow.
     * TODO: deal with chunks that did not fit at all.
     * @return holding end position.
     */
    redoLayout(): Task.Result<Vtree.ChunkPosition>;
    saveDistanceToBlockEndFloats(): void;
    collectElementsOffset(): RepetitiveElement.ElementsOffset[];
}
declare type SinglePageFloatLayoutResult_$0 = Layout.SinglePageFloatLayoutResult_$0;
/**
 * breaking point resolver for Text Node.
 */
declare class TextNodeBreaker_$0 implements Layout.TextNodeBreaker_$0 {
    breakTextNode(textNode: Text, nodeContext: Vtree.NodeContext, low: number, checkPoints: Vtree.NodeContext[], checkpointIndex: number, force: boolean): Vtree.NodeContext;
    breakAfterSoftHyphen(textNode: Text, text: string, viewIndex: number, nodeContext: Vtree.NodeContext): number;
    breakAfterOtherCharacter(textNode: Text, text: string, viewIndex: number, nodeContext: Vtree.NodeContext): number;
    updateNodeContext(nodeContext: Vtree.NodeContext, viewIndex: number, textNode: Text): Vtree.NodeContext;
    static instance: TextNodeBreaker_$0;
}
declare class PageFloatArea_$0 extends Column_$0 implements Layout.PageFloatArea_$0 {
    readonly floatSide: string;
    readonly parentContainer: Vtree.Container;
    private rootViewNodes;
    private floatMargins;
    adjustContentRelativeSize: boolean;
    constructor(floatSide: string, element: Element, layoutContext: Vtree.LayoutContext, clientLayout: Vtree.ClientLayout, layoutConstraint: LayoutConstraint_$0, pageFloatLayoutContext: PageFloats_$0.PageFloatLayoutContext, parentContainer: Vtree.Container);
    /**
     * @override
     */
    openAllViews(position: Vtree.NodePosition): Task.Result<Vtree.NodeContext>;
    convertPercentageSizesToPx(target: Element): void;
    fixFloatSizeAndPosition(nodeContext: Vtree.NodeContext): void;
    getContentInlineSize(): number;
}
declare class RepetitiveElementsOwnerFormattingContext_$0 implements RepetitiveElement.RepetitiveElementsOwnerFormattingContext_$0 {
    readonly parent: Vtree.FormattingContext;
    readonly rootSourceNode: Element;
    formattingContextType: FormattingContextType;
    isRoot: boolean;
    repetitiveElements: RepetitiveElement.RepetitiveElements_$0;
    constructor(parent: Vtree.FormattingContext, rootSourceNode: Element);
    /**
     * @override
     */
    getName(): string;
    /**
     * @override
     */
    isFirstTime(nodeContext: Vtree.NodeContext, firstTime: boolean): boolean;
    /**
     * @override
     */
    getParent(): Vtree.FormattingContext;
    getRepetitiveElements(): RepetitiveElement.RepetitiveElements_$0;
    getRootViewNode(position: Vtree.NodeContext): Element | null;
    getRootNodeContext(nodeContext: Vtree.NodeContext): Vtree.NodeContext | null;
    initializeRepetitiveElements(vertical: boolean): void;
    /** @override */
    saveState(): any;
    /** @override */
    restoreState(state: any): void;
}
/**
 * @abstract
 */
declare abstract class LayoutEntireBlock implements LayoutType.LayoutMode {
    formattingContext: RepetitiveElement.RepetitiveElementsOwnerFormattingContext_$0;
    constructor(formattingContext: RepetitiveElement.RepetitiveElementsOwnerFormattingContext_$0);
    /**
     * @override
     */
    abstract doLayout(nodeContext: Vtree.NodeContext, column: LayoutType.Column): Task.Result<Vtree.NodeContext>;
    /**
     * @override
     */
    accept(nodeContext: Vtree.NodeContext, column: LayoutType.Column): boolean;
    /**
     * @override
     */
    postLayout(positionAfter: Vtree.NodeContext, initialPosition: Vtree.NodeContext, column: LayoutType.Column, accepted: boolean): boolean;
}
/**
 * @abstract
 */
declare abstract class LayoutFragmentedBlock implements LayoutType.LayoutMode {
    formattingContext: RepetitiveElement.RepetitiveElementsOwnerFormattingContext_$0;
    constructor(formattingContext: RepetitiveElement.RepetitiveElementsOwnerFormattingContext_$0);
    /**
     * @override
     */
    abstract doLayout(nodeContext: Vtree.NodeContext, column: LayoutType.Column): Task.Result<Vtree.NodeContext>;
    /**
     * @override
     */
    accept(nodeContext: Vtree.NodeContext, column: LayoutType.Column): boolean;
    /**
     * @override
     */
    postLayout(positionAfter: Vtree.NodeContext, initialPosition: Vtree.NodeContext, column: LayoutType.Column, accepted: boolean): boolean;
}
declare class RepetitiveElementsOwnerLayoutProcessor extends LayoutProcessor.BlockLayoutProcessor implements LayoutProcessor.LayoutProcessor {
    layout(nodeContext: Vtree.NodeContext, column: LayoutType.Column, leadingEdge: boolean): Task.Result<Vtree.NodeContext>;
    startNonInlineElementNode(nodeContext: Vtree.NodeContext): boolean;
    doInitialLayout(nodeContext: Vtree.NodeContext, column: LayoutType.Column): Task.Result<Vtree.NodeContext>;
    private layoutEntireBlock;
    doLayout(nodeContext: Vtree.NodeContext, column: LayoutType.Column): Task.Result<Vtree.NodeContext>;
    /**
     * @override
     */
    finishBreak(column: LayoutType.Column, nodeContext: Vtree.NodeContext, forceRemoveSelf: boolean, endOfColumn: boolean): Task.Result<boolean> | null;
    /**
     * @override
     */
    clearOverflownViewNodes(column: LayoutType.Column, parentNodeContext: Vtree.NodeContext, nodeContext: Vtree.NodeContext, removeSelf: boolean): void;
}
declare type CustomRenderer = (p1: Element, p2: Element, p3: {
    [key: string]: Css.Val;
}) => Task.Result<Element>;
interface StylerProducer {
    getStylerForDoc(xmldoc: XmlDoc.XMLDocHolder): CssStyler_$0.AbstractStyler;
}
declare class Viewport {
    readonly window: Window;
    readonly fontSize: number;
    document: Document;
    root: HTMLElement;
    private outerZoomBox;
    contentContainer: HTMLElement;
    layoutBox: Element;
    width: number;
    height: number;
    constructor(window: Window, fontSize: number, opt_root?: HTMLElement, opt_width?: number, opt_height?: number);
    /**
     * Reset zoom.
     */
    resetZoom(): void;
    /**
     * Zoom viewport.
     * @param width Overall width of contents before scaling (px)
     * @param height Overall height of contents before scaling (px)
     * @param scale Factor to which the viewport will be scaled.
     */
    zoom(width: number, height: number, scale: number): void;
    /**
     * Remove all pages inside the viewport.
     */
    clear(): void;
}
/**
 * Class representing a reference by target-counter(s).
 * @param targetId ID of the referenced element (transformed by
 *     DocumentURLTransformer to handle a reference across multiple source
 *     documents)
 * @param resolved If the reference is already resolved or not
 */
declare class TargetCounterReference {
    readonly targetId: string;
    resolved: boolean;
    pageCounters: CssCascade_$0.CounterValues;
    spineIndex: number;
    pageIndex: number;
    constructor(targetId: string, resolved: boolean);
    equals(other: TargetCounterReference): boolean;
    /**
     * Returns if the reference is resolved or not.
     */
    isResolved(): boolean;
    /**
     * Marks that this reference is resolved.
     */
    resolve(): void;
    /**
     * Marks that this reference is unresolved.
     */
    unresolve(): void;
}
declare const PageFloatFragment_$0: typeof PageFloats_$0.PageFloatFragment_$0;
declare class TableCell {
    readonly rowIndex: number;
    readonly columnIndex: number;
    viewElement: Element | null;
    colSpan: number;
    rowSpan: number;
    height: number;
    anchorSlot: TableSlot;
    constructor(rowIndex: number, columnIndex: number, viewElement: Element);
    setHeight(height: number): void;
    setAnchorSlot(slot: TableSlot): void;
}
declare class TableSlot {
    readonly rowIndex: number;
    readonly columnIndex: number;
    readonly cell: TableCell;
    constructor(rowIndex: number, columnIndex: number, cell: TableCell);
}
/**
 * Represent an at-rule which creates a page-level CSS box (page-master,
 * partition, and partition-group).
 */
declare abstract class PageBox<I extends PageBoxInstance = PageBoxInstance<any>> {
    readonly name: string | null;
    readonly pseudoName: string | null;
    readonly classes: string[];
    readonly parent: PageBox;
    specified: CssCascade.ElementStyle;
    children: PageBox[];
    pageMaster: PageMaster;
    index: number;
    key: string;
    protected _scope: Exprs.LexicalScope;
    get scope(): Exprs.LexicalScope;
    constructor(scope: Exprs.LexicalScope, name: string | null, pseudoName: string | null, classes: string[], parent: PageBox);
    createInstance(parentInstance: PageBoxInstance): PageBoxInstance;
    /**
     * Clone the PageBox.
     * @param param parent: The parent of the cloned PageBox.
     *     pseudoName: Assign this value as the pseudoName of the cloned PageBox.
     */
    clone(param: {
        parent?: PageBox;
        pseudoName?: string;
    }): PageBox<I>;
    /**
     * Copy 'specified' properties to another instance.
     * @param dest The PageBox into which 'specified' properties are copied
     */
    protected copySpecified(dest: PageBox): void;
    /**
     * Clone children with the specified PageBox as their parent.
     */
    protected cloneChildren(parent: PageBox): void;
}
/**
 * Parent of all page masters
 */
declare class RootPageBox extends PageBox<RootPageBoxInstance> {
    constructor(scope: Exprs.LexicalScope);
}
/**
 * Represent a page-master rule
 */
declare class PageMaster<I extends PageMasterInstance = PageMasterInstance<any>> extends PageBox<I> {
    readonly condition: Exprs.Val;
    readonly specificity: number;
    pageMaster: PageMaster;
    keyMap: {
        [key: string]: string;
    };
    constructor(scope: Exprs.LexicalScope, name: string | null, pseudoName: string | null, classes: string[], parent: RootPageBox, condition: Exprs.Val, specificity: number);
    /**
     * @override
     */
    createInstance(parentInstance: any): PageBoxInstance;
    /**
     * @override
     */
    clone(param: any): PageMaster;
    /**
     * Point the pageMaster reference in the PageMasterScope to the current page
     * master. This is needed when a page master is cloned and shares a common
     * scope with the original page master. Since every Exprs.Val which the
     * page master holds has a reference to the scope and uses it for variable
     * resolution, this reference must be updated properly before the page master
     * instance is used.
     */
    resetScope(): void;
}
/**
 * Represent a partition-group rule
 */
declare class PartitionGroup extends PageBox<PartitionGroupInstance> {
    pageMaster: PageMaster;
    constructor(scope: Exprs.LexicalScope, name: string | null, pseudoName: string | null, classes: string[], parent: PageBox);
    /**
     * @override
     */
    createInstance(parentInstance: PageBoxInstance): PageBoxInstance;
    /**
     * @override
     */
    clone(param: any): PartitionGroup;
}
/**
 * Represent a partition rule
 */
declare class Partition<I extends PartitionInstance = PartitionInstance> extends PageBox<I> {
    pageMaster: PageMaster;
    constructor(scope: Exprs.LexicalScope, name: string | null, pseudoName: string | null, classes: string[], parent: PageBox);
    /**
     * @override
     */
    createInstance(parentInstance: any): PageBoxInstance;
    /**
     * @override
     */
    clone(param: any): Partition;
}
declare class PageBoxInstance<P extends PageBox = PageBox<any>> {
    readonly parentInstance: PageBoxInstance;
    readonly pageBox: P;
    /**
     * cascaded styles, geometric ones converted to Css.Expr
     */
    protected cascaded: CssCascade.ElementStyle;
    style: {
        [key: string]: Css.Val;
    };
    private autoWidth;
    private autoHeight;
    children: PageBoxInstance[];
    isAutoWidth: boolean;
    isAutoHeight: boolean;
    isTopDependentOnAutoHeight: boolean;
    isRightDependentOnAutoWidth: boolean;
    private calculatedWidth;
    private calculatedHeight;
    pageMasterInstance: PageMasterInstance;
    namedValues: {
        [key: string]: Exprs.Val;
    };
    namedFuncs: {
        [key: string]: Exprs.Val;
    };
    vertical: boolean;
    rtl: boolean;
    suppressEmptyBoxGeneration: boolean;
    constructor(parentInstance: PageBoxInstance, pageBox: P);
    /**
     * Reset information related to layout.
     */
    reset(): void;
    private addNamedValues;
    resolveName(name: string): Exprs.Val;
    resolveFunc(name: any): Exprs.Val;
    private initEnabled;
    protected boxSpecificEnabled(enabled: Exprs.Val): Exprs.Val;
    protected initHorizontal(): void;
    protected initVertical(): void;
    private initColumns;
    private depends;
    private init;
    getProp(context: Exprs.Context, name: string): Css.Val;
    getPropAsNumber(context: Exprs.Context, name: string): number;
    getSpecial(context: Exprs.Context, name: string): Css.Val[];
    getActiveRegions(context: Exprs.Context): string[];
    propagateProperty(context: Exprs.Context, container: Vtree_$0.Container, name: string, docFaces: Font.DocumentFaces): void;
    propagatePropertyToElement(context: Exprs.Context, element: Element, name: string, docFaces: Font.DocumentFaces): void;
    propagateDelayedProperty(context: Exprs.Context, container: Vtree_$0.Container, name: string, delayedItems: Vtree_$0.DelayedItem[]): void;
    assignLeftPosition(context: Exprs.Context, container: Vtree_$0.Container): void;
    assignRightPosition(context: Exprs.Context, container: Vtree_$0.Container): void;
    assignTopPosition(context: Exprs.Context, container: Vtree_$0.Container): void;
    assignBottomPosition(context: Exprs.Context, container: Vtree_$0.Container): void;
    assignBeforePosition(context: Exprs.Context, container: Vtree_$0.Container): void;
    assignAfterPosition(context: Exprs.Context, container: Vtree_$0.Container): void;
    assignStartEndPosition(context: Exprs.Context, container: Vtree_$0.Container): void;
    sizeWithMaxHeight(context: Exprs.Context, container: Vtree_$0.Container): void;
    sizeWithMaxWidth(context: Exprs.Context, container: Vtree_$0.Container): void;
    prepareContainer(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, docFaces: Font.DocumentFaces, clientLayout: Vtree_$0.ClientLayout): void;
    transferContentProps(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, docFaces: Font.DocumentFaces): void;
    transferSinglUriContentProps(context: Exprs.Context, element: Element, docFaces: Font.DocumentFaces): void;
    /**
     * @param column (null when content comes from the content property)
     */
    finishContainer(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, column: Vtree_$0.Container, columnCount: number, clientLayout: Vtree_$0.ClientLayout, docFaces: Font.DocumentFaces): void;
    applyCascadeAndInit(cascade: CssCascade.CascadeInstance, docElementStyle: CssCascade.ElementStyle): void;
    resolveAutoSizing(context: Exprs.Context): void;
}
declare class RootPageBoxInstance extends PageBoxInstance<RootPageBox> {
    constructor(pageBox: RootPageBox);
    /**
     * @override
     */
    applyCascadeAndInit(cascade: CssCascade.CascadeInstance, docElementStyle: CssCascade.ElementStyle): void;
}
declare class PageMasterInstance<P extends PageMaster = PageMaster<PageMasterInstance<any>>> extends PageBoxInstance<P> {
    pageMasterInstance: PageMasterInstance;
    constructor(parentInstance: PageBoxInstance, pageBox: P);
    /**
     * @override
     */
    boxSpecificEnabled(enabled: Exprs.Val): Exprs.Val;
    /**
     * Called after layout of contents of the page has done to adjust the overall
     * page layout. Override in subclasses.
     */
    adjustPageLayout(context: Exprs.Context, page: Vtree_$0.Page, clientLayout: Vtree_$0.ClientLayout): void;
}
declare class PartitionGroupInstance extends PageBoxInstance<PartitionGroup> {
    pageMasterInstance: PageMasterInstance;
    constructor(parentInstance: PageBoxInstance, pageBox: PageBox);
}
declare class PartitionInstance<P extends Partition = Partition<PartitionInstance<any>>> extends PageBoxInstance<P> {
    pageMasterInstance: PageMasterInstance;
    constructor(parentInstance: PageBoxInstance, pageBox: P);
    processPartitionList(enabled: Exprs.Val, listVal: Css.Val, conflicting: boolean): Exprs.Val;
    /**
     * @override
     */
    boxSpecificEnabled(enabled: Exprs.Val): Exprs.Val;
    /**
     * @override
     */
    prepareContainer(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, docFaces: Font.DocumentFaces, clientLayout: Vtree_$0.ClientLayout): void;
}
declare class PageBoxParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
    readonly target: PageBox;
    readonly validatorSet: CssValidator.ValidatorSet;
    constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, target: PageBox, validatorSet: CssValidator.ValidatorSet);
    /**
     * @override
     */
    property(name: string, value: Css.Val, important: boolean): void;
    /**
     * @override
     */
    unknownProperty(name: string, value: Css.Val): void;
    /**
     * @override
     */
    invalidPropertyValue(name: string, value: Css.Val): void;
    /**
     * @override
     */
    simpleProperty(name: string, value: Css.Val, important: any): void;
}
declare type PageSize = {
    width: Css.Numeric;
    height: Css.Numeric;
};
declare type PageSizeAndBleed = {
    width: Css.Numeric;
    height: Css.Numeric;
    bleed: Css.Numeric;
    bleedOffset: Css.Numeric;
};
declare type EvaluatedPageSizeAndBleed = {
    pageWidth: number;
    pageHeight: number;
    bleed: number;
    bleedOffset: number;
    cropOffset: number;
};
/**
 * Position of a corner mark
 * @enum {string}
 */
declare enum CornerMarkPosition {
    TOP_LEFT = "top left",
    TOP_RIGHT = "top right",
    BOTTOM_LEFT = "bottom left",
    BOTTOM_RIGHT = "bottom right"
}
/**
 * Position of a cross mark
 * @enum {string}
 */
declare enum CrossMarkPosition {
    TOP = "top",
    BOTTOM = "bottom",
    LEFT = "left",
    RIGHT = "right"
}
/**
 * Represents position of a margin box along the variable dimension of the page.
 * START and END can be interpreted as 'inline-start' and 'inline-end' in
 * horizontal and vertical writing modes. For example, for top margin boxes
 * (@top-left-corner, @top-left, @top-center, @top-right, @top-right-corner),
 * @top-left corresponds to START, @top-center to CENTER, and @top-right to END.
 * The corner boxes (@top-left-corner and @top-right-corner) have a 'null'
 * position.
 * @enum {string}
 */
declare enum MarginBoxPositionAlongVariableDimension {
    START = "start",
    CENTER = "center",
    END = "end"
}
declare type PageMarginBoxInformation = {
    order: number;
    isInTopRow: boolean;
    isInBottomRow: boolean;
    isInLeftColumn: boolean;
    isInRightColumn: boolean;
    positionAlongVariableDimension: MarginBoxPositionAlongVariableDimension;
};
/**
 * Represent a page master generated for `@page` rules
 * @param style Cascaded style for `@page` rules
 */
declare class PageRuleMaster extends PageMaster.PageMaster<PageRuleMasterInstance> {
    private bodyPartitionKey;
    private pageMarginBoxes;
    constructor(scope: Exprs.LexicalScope, parent: PageMaster.RootPageBox, style: CssCascade.ElementStyle);
    /**
     * Create page-margin boxes
     */
    createPageMarginBoxes(style: CssCascade.ElementStyle): void;
    /**
     * Transfer cascaded style for `@page` rules to 'specified' style of this
     * PageBox
     */
    private applySpecified;
    /**
     * @override
     */
    createInstance(parentInstance: any): PageRuleMasterInstance;
}
/**
 * Represent a partition placed in a PageRuleMaster
 * @param style Cascaded style for `@page` rules
 */
declare class PageRulePartition extends PageMaster.Partition<PageRulePartitionInstance> {
    readonly pageSize: PageSize;
    constructor(scope: Exprs.LexicalScope, parent: PageRuleMaster, style: CssCascade.ElementStyle, pageSize: PageSize);
    /**
     * Transfer cascaded style for `@page` rules to 'specified' style of this
     * PageBox
     */
    private applySpecified;
    /**
     * @override
     */
    createInstance(parentInstance: any): PageMaster.PageBoxInstance;
}
/**
 * Represent a partition for a page-margin box
 */
declare class PageMarginBoxPartition extends PageMaster.Partition<PageMarginBoxPartitionInstance> {
    readonly marginBoxName: string;
    constructor(scope: Exprs.LexicalScope, parent: PageRuleMaster, marginBoxName: string, style: CssCascade.ElementStyle);
    /**
     * Transfer cascaded style for `@page` rules to 'specified' style of this
     * PageMarginBox
     */
    applySpecified(style: CssCascade.ElementStyle): void;
    /**
     * @override
     */
    createInstance(parentInstance: any): PageMaster.PageBoxInstance;
}
declare type PageAreaDimension = {
    borderBoxWidth: Exprs.Val;
    borderBoxHeight: Exprs.Val;
    marginTop: Exprs.Val;
    marginBottom: Exprs.Val;
    marginLeft: Exprs.Val;
    marginRight: Exprs.Val;
};
declare class PageRuleMasterInstance extends PageMaster.PageMasterInstance<PageRuleMaster> {
    pageAreaDimension: PageAreaDimension | null;
    pageMarginBoxInstances: {
        [key: string]: PageMarginBoxPartitionInstance;
    };
    constructor(parentInstance: PageMaster.PageBoxInstance, pageRuleMaster: PageRuleMaster);
    /**
     * @override
     */
    applyCascadeAndInit(cascade: CssCascade.CascadeInstance, docElementStyle: CssCascade.ElementStyle): void;
    /**
     * @override
     */
    initHorizontal(): void;
    /**
     * @override
     */
    initVertical(): void;
    setPageAreaDimension(dim: PageAreaDimension): void;
    /**
     * @override
     */
    adjustPageLayout(context: Exprs.Context, page: Vtree_$0.Page, clientLayout: Vtree_$0.ClientLayout): void;
    /**
     * Determine and set margin boxes' sizes along variable dimension using an
     * algorithm specified in CSS Paged Media spec.
     * @param marginBoxContainers Containers corresponding to the target margin
     *     boxes in one page edge (top, bottom, left, right)
     * @param isHorizontal Indicates if the target margin boxes are on the
     *     horizontal edge (top or bottom) or not (left or right).
     * @param dimensions Page dimensions. start: margin-left or margin-top. end:
     *     margin-right or margin-bottom. extent: border-box width or height of
     *     the page area (= available width or height for the target margin boxes)
     */
    private sizeMarginBoxesAlongVariableDimension;
    private getSizesOfMarginBoxesAlongVariableDimension;
    /**
     * Distribute auto margin sizes among two margin boxes using an algorithm
     * specified in CSS Paged Media spec.
     * @param x Parameter for the first margin box. null if the box is not
     *     generated.
     * @param y Parameter for the second margin box. null if the box is not
     *     generated.
     * @param availableSize Available size for the margin boxes.
     * @returns Determined sizes for the two boxes. Each value is present only
     *     when the size of the corresponding box is 'auto'.
     */
    private distributeAutoMarginBoxSizes;
    /**
     * @override
     */
    prepareContainer(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, docFaces: Font.DocumentFaces, clientLayout: Vtree_$0.ClientLayout): void;
}
declare class PageRulePartitionInstance extends PageMaster.PartitionInstance<PageRulePartition> {
    borderBoxWidth: Exprs.Val;
    borderBoxHeight: Exprs.Val;
    marginTop: Exprs.Val;
    marginRight: Exprs.Val;
    marginBottom: Exprs.Val;
    marginLeft: Exprs.Val;
    constructor(parentInstance: PageMaster.PageBoxInstance, pageRulePartition: PageRulePartition);
    /**
     * @override
     */
    applyCascadeAndInit(cascade: CssCascade.CascadeInstance, docElementStyle: CssCascade.ElementStyle): void;
    /**
     * @override
     */
    initHorizontal(): void;
    /**
     * @override
     */
    initVertical(): void;
    /**
     * Calculate page dimensions as specified in CSS Paged Media
     * (http://dev.w3.org/csswg/css-page/#page-model) Page border box extent and
     * margins. Since the containing block can be resized in the over-constrained
     * case, the sum of these values is not necessarily same to the original page
     * dimension specified in the page at-rules.
     */
    private resolvePageBoxDimensions;
    /**
     * @override
     */
    prepareContainer(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, docFaces: Font.DocumentFaces, clientLayout: Vtree_$0.ClientLayout): void;
}
declare class PageMarginBoxPartitionInstance extends PageMaster.PartitionInstance<PageMarginBoxPartition> {
    boxInfo: PageMarginBoxInformation;
    suppressEmptyBoxGeneration: boolean;
    constructor(parentInstance: PageMaster.PageBoxInstance, pageMarginBoxPartition: PageMarginBoxPartition);
    /**
     * @override
     */
    prepareContainer(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, docFaces: Font.DocumentFaces, clientLayout: Vtree_$0.ClientLayout): void;
    private applyVerticalAlign;
    /**
     * Calculate page-margin boxes positions along the variable dimension of the
     * page. For CENTER and END margin boxes, the position is calculated only if
     * the dimension (width or height) is non-auto, so that it can be resolved at
     * this point. If the dimension is auto, the calculation is deffered.
     */
    private positionAlongVariableDimension;
    /**
     * Calculate page-margin boxes positions along the fixed dimension of the
     * page.
     */
    private positionAndSizeAlongFixedDimension;
    /**
     * @override
     */
    initHorizontal(): void;
    /**
     * @override
     */
    initVertical(): void;
    /**
     * @override
     */
    finishContainer(context: Exprs.Context, container: Vtree_$0.Container, page: Vtree_$0.Page, column: Vtree_$0.Container, columnCount: number, clientLayout: Vtree_$0.ClientLayout, docFaces: Font.DocumentFaces): void;
}
declare type XMLDocStore_$0 = XmlDoc.XMLDocStore_$0;
declare class Predicate_$0 implements XmlDoc.Predicate_$0 {
    readonly fn: (p1: Node) => boolean;
    constructor(fn: (p1: Node) => boolean);
    check(node: Node): boolean;
    withAttribute(name: string, value: string): Predicate_$0;
    withChild(name: string, opt_childPredicate?: Predicate_$0): Predicate_$0;
}
declare class NodeList_$0 implements XmlDoc.NodeList_$0 {
    readonly nodes: Node[];
    constructor(nodes: Node[]);
    asArray(): Node[];
    size(): number;
    /**
     * Filter with predicate
     */
    predicate(pr: Predicate_$0): NodeList_$0;
    forEachNode(fn: (p1: Node, p2: (p1: Node) => void) => void): NodeList_$0;
    /**
     * @template T
     */
    forEach<T>(fn: (p1: Node) => T): T[];
    /**
     * @template T
     */
    forEachNonNull<T>(fn: (p1: Node) => T): T[];
    child(tag: string): NodeList_$0;
    childElements(): NodeList_$0;
    attribute(name: string): (string | null)[];
    textContent(): (string | null)[];
}
declare type FontFace = {
    properties: CssCascade.ElementStyle;
    condition: Exprs.Val;
};
declare class Style {
    readonly store: OPSDocStore;
    readonly rootScope: Exprs.LexicalScope;
    readonly pageScope: Exprs.LexicalScope;
    readonly cascade: CssCascade.Cascade;
    readonly rootBox: PageMaster.RootPageBox;
    readonly fontFaces: FontFace[];
    readonly footnoteProps: CssCascade.ElementStyle;
    readonly flowProps: {
        [key: string]: CssCascade.ElementStyle;
    };
    readonly viewportProps: CssCascade.ElementStyle[];
    readonly pageProps: {
        [key: string]: CssCascade.ElementStyle;
    };
    fontDeobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null;
    validatorSet: CssValidator.ValidatorSet;
    constructor(store: OPSDocStore, rootScope: Exprs.LexicalScope, pageScope: Exprs.LexicalScope, cascade: CssCascade.Cascade, rootBox: PageMaster.RootPageBox, fontFaces: FontFace[], footnoteProps: CssCascade.ElementStyle, flowProps: {
        [key: string]: CssCascade.ElementStyle;
    }, viewportProps: CssCascade.ElementStyle[], pageProps: {
        [key: string]: CssCascade.ElementStyle;
    });
    sizeViewport(viewportWidth: number, viewportHeight: number, fontSize: number, pref?: Exprs.Preferences): {
        width: number;
        height: number;
        fontSize: number;
    };
}
declare class BaseParserHandler extends CssCascade.CascadeParserHandler {
    masterHandler: StyleParserHandler;
    insideRegion: boolean;
    constructor(masterHandler: StyleParserHandler, condition: Exprs.Val, parent: BaseParserHandler, regionId: string | null);
    /**
     * @override
     */
    startPageTemplateRule(): void;
    /**
     * @override
     */
    startPageMasterRule(name: string | null, pseudoName: string | null, classes: string[]): void;
    /**
     * @override
     */
    startWhenRule(expr: Css.Expr): void;
    /**
     * @override
     */
    startDefineRule(): void;
    /**
     * @override
     */
    startFontFaceRule(): void;
    /**
     * @override
     */
    startFlowRule(flowName: string): void;
    /**
     * @override
     */
    startViewportRule(): void;
    /**
     * @override
     */
    startFootnoteRule(pseudoelem: string | null): void;
    /**
     * @override
     */
    startRegionRule(): void;
    /**
     * @override
     */
    startPageRule(): void;
    /**
     * @override
     */
    startRuleBody(): void;
}
declare class StyleParserHandler extends CssParser.DispatchParserHandler {
    readonly validatorSet: CssValidator.ValidatorSet;
    rootScope: Exprs.LexicalScope;
    pageScope: Exprs.LexicalScope;
    rootBox: PageMaster.RootPageBox;
    cascadeParserHandler: BaseParserHandler;
    regionCount: number;
    fontFaces: FontFace[];
    footnoteProps: CssCascade.ElementStyle;
    flowProps: {
        [key: string]: CssCascade.ElementStyle;
    };
    viewportProps: CssCascade.ElementStyle[];
    pageProps: {
        [key: string]: CssCascade.ElementStyle;
    };
    slave: BaseParserHandler;
    constructor(validatorSet: CssValidator.ValidatorSet);
    /**
     * @override
     */
    error(mnemonics: string, token: CssTokenizer.Token): void;
}
declare class OPSDocStore extends Net_$0.ResourceStore<XmlDoc_$0.XMLDocHolder> {
    fontDeobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null;
    styleByKey: {
        [key: string]: Style;
    };
    styleFetcherByKey: {
        [key: string]: TaskUtil.Fetcher<Style>;
    };
    styleByDocURL: {
        [key: string]: Style;
    };
    triggersByDocURL: {
        [key: string]: Vtree_$0.Trigger[];
    };
    validatorSet: CssValidator.ValidatorSet;
    private styleSheets;
    private triggerSingleDocumentPreprocessing;
    constructor(fontDeobfuscator: ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null);
    init(authorStyleSheets: {
        url: string | null;
        text: string | null;
    }[] | null, userStyleSheets: {
        url: string | null;
        text: string | null;
    }[] | null): Task.Result<boolean>;
    getStyleForDoc(xmldoc: XmlDoc_$0.XMLDocHolder): Style;
    getTriggersForDoc(xmldoc: XmlDoc_$0.XMLDocHolder): Vtree_$0.Trigger[];
    /**
     * Set author stylesheets and user stylesheets. Existing style sheets are
     * removed.
     */
    private setStyleSheets;
    private clearStyleSheets;
    private addAuthorStyleSheet;
    private addUserStyleSheet;
    parseOPSResource(response: Net_$0.Response): Task.Result<XmlDoc_$0.XMLDocHolder>;
}
declare type Position_$0 = {
    spineIndex: number;
    pageIndex: number;
    offsetInItem: number;
};
declare class EPUBDocStore extends OPS.OPSDocStore {
    plainXMLStore: XmlDoc_$0.XMLDocStore;
    jsonStore: Net_$0.JSONStore;
    opfByURL: {
        [key: string]: OPFDoc;
    };
    primaryOPFByEPubURL: {
        [key: string]: OPFDoc;
    };
    deobfuscators: {
        [key: string]: (p1: Blob) => Task.Result<Blob>;
    };
    documents: {
        [key: string]: Task.Result<XmlDoc_$0.XMLDocHolder>;
    };
    constructor();
    makeDeobfuscatorFactory(): ((p1: string) => ((p1: Blob) => Task.Result<Blob>) | null) | null;
    loadAsPlainXML(url: string, opt_required?: boolean, opt_message?: string): Task.Result<XmlDoc_$0.XMLDocHolder>;
    startLoadingAsPlainXML(url: string): void;
    loadAsJSON(url: string, opt_required?: boolean, opt_message?: string): Task.Result<Base.JSON>;
    startLoadingAsJSON(url: string): void;
    loadPubDoc(url: string, haveZipMetadata: boolean): Task.Result<OPFDoc>;
    loadEPUBDoc(url: string, haveZipMetadata: boolean): Task.Result<OPFDoc>;
    loadOPF(pubURL: string, root: string, haveZipMetadata: boolean): Task.Result<OPFDoc>;
    loadWebPub(url: string): Task.Result<OPFDoc>;
    addDocument(url: string, doc: Document): Task.Result<XmlDoc_$0.XMLDocHolder>;
    /**
     * @override
     */
    load(url: string): Task.Result<XmlDoc_$0.XMLDocHolder>;
}
declare type OPFItemParam = {
    url: string;
    index: number;
    startPage: number | null;
    skipPagesBefore: number | null;
};
declare class OPFItem {
    id: string | null;
    src: string;
    mediaType: string | null;
    title: string | null;
    itemRefElement: Element | null;
    spineIndex: number;
    compressedSize: number;
    compressed: boolean | null;
    epage: number;
    epageCount: number;
    startPage: number | null;
    skipPagesBefore: number | null;
    itemProperties: {
        [key: string]: boolean;
    };
    constructor();
    initWithElement(itemElem: Element, opfURL: string): void;
    initWithParam(param: OPFItemParam): void;
}
declare class OPFDoc {
    readonly store: EPUBDocStore;
    readonly pubURL: string;
    opfXML: XmlDoc_$0.XMLDocHolder;
    encXML: XmlDoc_$0.XMLDocHolder;
    items: OPFItem[];
    spine: OPFItem[];
    itemMap: {
        [key: string]: OPFItem;
    };
    itemMapByPath: {
        [key: string]: OPFItem;
    };
    uid: string | null;
    bindings: {
        [key: string]: string;
    };
    lang: string | null;
    epageCount: number;
    prePaginated: boolean;
    epageIsRenderedPage: boolean;
    epageCountCallback: (p1: number) => void | null;
    metadata: Base.JSON;
    ncxToc: OPFItem;
    xhtmlToc: OPFItem;
    cover: OPFItem;
    fallbackMap: {
        [key: string]: string;
    };
    pageProgression: Constants.PageProgression | null;
    documentURLTransformer: Base.DocumentURLTransformer;
    constructor(store: EPUBDocStore, pubURL: string);
    createDocumentURLTransformer(): Base.DocumentURLTransformer;
    /**
     * Metadata is organized in the following way: fully-expanded property names
     * (with IRI prefixes prepended) point to an array of values. Array contains
     * at least one element. First element is primary and should be used by
     * default. Element values are objects have the following keys:
     * - "v" - item value as string,
     * - "s" - scheme,
     * - "o" - index in the order of appearing in the source,
     * - "r" - refinement submetadata (organized just like the top-level
     * metadata).
     */
    getMetadata(): Base.JSON;
    getPathFromURL(url: string): string | null;
    initWithXMLDoc(opfXML: XmlDoc_$0.XMLDocHolder, encXML: XmlDoc_$0.XMLDocHolder, zipMetadata: Base.JSON, manifestURL: string): Task.Result<any>;
    assignAutoPages(): void;
    setEPageCountMode(epageIsRenderedPage: boolean): void;
    countEPages(epageCountCallback: ((p1: number) => void) | null): Task.Result<boolean>;
    /**
     * Creates a fake OPF "document" that contains OPS chapters.
     */
    initWithChapters(params: OPFItemParam[], doc?: Document | null): Task.Result<any>;
    initWithWebPubManifest(manifestObj: Base.JSON, doc?: Document): Task.Result<boolean>;
    /**
     * @return cfi
     */
    getCFI(spineIndex: number, offsetInItem: number): Task.Result<string | null>;
    resolveFragment(fragstr: string | null): Task.Result<Position_$0 | null>;
    resolveEPage(epage: number): Task.Result<Position_$0 | null>;
    getEPageFromPosition(position: Position_$0): Task.Result<number>;
}
declare type PageAndPosition = {
    page: Vtree_$0.Page;
    position: Position_$0;
};
declare type OPFViewItem = {
    item: OPFItem;
    xmldoc: XmlDoc_$0.XMLDocHolder;
    instance: OPS.StyleInstance;
    layoutPositions: Vtree_$0.LayoutPosition[];
    pages: Vtree_$0.Page[];
    complete: boolean;
};
declare type Action_$0 = (p1: Base.JSON) => Task.Result<boolean>;
declare type ViewportSize = {
    marginLeft: number;
    marginRight: number;
    marginTop: number;
    marginBottom: number;
    width: number;
    height: number;
};
/**
 * @enum {string}
 */
declare enum PageViewMode {
    SINGLE_PAGE = "singlePage",
    SPREAD = "spread",
    AUTO_SPREAD = "autoSpread"
}
declare class AdaptiveViewer {
    readonly window: Window;
    readonly viewportElement: HTMLElement;
    readonly instanceId: string;
    readonly callbackFn: (p1: Base.JSON) => void;
    fontMapper: Font.Mapper;
    kick: () => void;
    sendCommand: (p1: Base.JSON | string) => void;
    resizeListener: () => void;
    hyperlinkListener: Base.EventListener;
    pageRuleStyleElement: HTMLElement;
    pageSheetSizeAlreadySet: boolean;
    renderTask: Task.Task | null;
    actions: {
        [key: string]: Action_$0;
    };
    readyState: Constants.ReadyState;
    packageURL: string[];
    opf: Epub.OPFDoc;
    haveZipMetadata: boolean;
    touchActive: boolean;
    touchX: number;
    touchY: number;
    needResize: boolean;
    needRefresh: boolean;
    viewportSize: ViewportSize | null;
    currentPage: Vtree_$0.Page;
    currentSpread: Vtree_$0.Spread | null;
    pagePosition: Epub.Position | null;
    fontSize: number;
    zoom: number;
    fitToScreen: boolean;
    pageViewMode: PageViewMode;
    waitForLoading: boolean;
    renderAllPages: boolean;
    pref: Exprs.Preferences;
    pageSizes: {
        width: number;
        height: number;
    }[];
    viewport: Vgen.Viewport | null;
    opfView: Epub.OPFView;
    constructor(window: Window, viewportElement: HTMLElement, instanceId: string, callbackFn: (p1: Base.JSON) => void);
    private init;
    addLogListeners(): void;
    private callback;
    /**
     * Set readyState and notify to listeners
     */
    setReadyState(readyState: Constants.ReadyState): void;
    loadPublication(command: Base.JSON): Task.Result<boolean>;
    loadXML(command: Base.JSON): Task.Result<boolean>;
    private render;
    private resolveLength;
    configure(command: Base.JSON): Task.Result<boolean>;
    configurePlugins(command: Base.JSON): void;
    /**
     * Refresh view when a currently displayed page is replaced (by re-layout
     * caused by cross reference resolutions)
     */
    pageReplacedListener(evt: Base.Event): void;
    /**
     * Iterate through currently displayed pages and do something
     */
    private forCurrentPages;
    private removePageListeners;
    /**
     * Hide current pages (this.currentPage, this.currentSpread)
     */
    private hidePages;
    private showSinglePage;
    private showPage;
    private showSpread;
    private reportPosition;
    private createViewport;
    private resolveSpreadView;
    private updateSpreadView;
    private sizeIsGood;
    private setPageSize;
    private setPageSizePageRules;
    removePageSizePageRules(): void;
    private reset;
    /**
     * Show current page or spread depending on the setting
     * (this.pref.spreadView).
     * @param sync If true, get the necessary page synchronously (not waiting
     *     another rendering task)
     */
    private showCurrent;
    setPageZoom(page: Vtree_$0.Page): void;
    setSpreadZoom(spread: Vtree_$0.Spread): void;
    /**
     * @returns adjusted zoom factor
     */
    getAdjustedZoomFactor(pageDimension: {
        width: number;
        height: number;
    }): number;
    /**
     * Returns width and height of the spread, including the margin between pages.
     */
    getSpreadDimensions(spread: Vtree_$0.Spread): {
        width: number;
        height: number;
    };
    /**
     * Returns zoom factor corresponding to the specified zoom type.
     */
    queryZoomFactor(type: ZoomType): number;
    /**
     * @returns zoom factor to fit inside viewport
     */
    calculateZoomFactorToFitInsideViewPort(pageDimension: {
        width: number;
        height: number;
    }): number;
    private cancelRenderingTask;
    resize(): Task.Result<boolean>;
    private sendLocationNotification;
    getCurrentPageProgression(): Constants.PageProgression | null;
    moveTo(command: Base.JSON): Task.Result<boolean>;
    showTOC(command: Base.JSON): Task.Result<boolean>;
    runCommand(command: Base.JSON): Task.Result<boolean>;
    initEmbed(cmd: Base.JSON | string): void;
}
/**
 * @enum {string}
 */
declare enum ZoomType {
    FIT_INSIDE_VIEWPORT = "fit inside viewport"
}
interface Payload {
    type: string;
    internal: boolean;
    href: string;
    content: string;
    cfi: string;
    first: boolean;
    last: boolean;
    epage: unknown;
    epageCount: number;
    metadata: unknown;
    docTitle: string;
}
/**
 * Viewer settings that must be passed to Viewer's constructor.
 * - userAgentRootURL: URL of a directory from which viewer resource files
 *   (under resources/ directory in the source repository) are served.
 * - viewportElement: An element used as the viewport of the displayed contents.
 * - window: Window object. If omitted, current `window` is used.
 * - debug: Debug flag.
 */
declare type CoreViewerSettings = {
    userAgentRootURL?: string;
    viewportElement: HTMLElement;
    window?: Window;
    debug?: boolean;
};
/**
 * Viewer options that can be set after the Viewer object is constructed.
 * - autoResize: Run layout again when the window is resized. default: true
 * - fontSize: Default font size (px). default: 16
 * - pageBorderWidth: Width of a border between two pages in a single
 *   spread (px). Effective only in spread view mode. default: 1
 * - renderAllPages: Render all pages at the document load time. default: true
 * - pageViewMode: Page view mode (singlePage / spread / autoSpread).
 *   default: singlePage
 * - zoom: Zoom factor with which pages are displayed. default: 1
 * - fitToScreen: Auto adjust zoom factor to fit the screen. default: false
 * - defaultPaperSize: Default paper size in px. Effective when `@page` size
 *   is set to auto. default: undefined (means the windows size is used as
 *   paper size).
 */
declare type CoreViewerOptions = {
    autoResize?: boolean;
    fontSize?: number;
    pageBorderWidth?: number;
    renderAllPages?: boolean;
    pageViewMode?: AdaptiveViewer.PageViewMode_$0;
    zoom?: number;
    fitToScreen?: boolean;
    defaultPaperSize?: {
        width: number;
        height: number;
    };
};
/**
 * Options for the displayed document.
 * - documentObject: Document object for the document. If provided, it is used
 *   directly without parsing the source again.
 * - fragment: Fragmentation identifier (EPUB CFI) of the location in the
 *   document which is to be displayed.
 * - authorStyleSheet: An array of author style sheets to be injected after all
 *   author style sheets referenced from the document. A single stylesheet may
 *   be a URL of the style sheet or a text content of the style sheet.
 * - userStyleSheet: An array of user style sheets to be injected.
 *   A single stylesheet may be a URL of the style sheet or a text content of
 *   the style sheet.
 */
declare type DocumentOptions = {
    documentObject?: Document;
    fragment?: string;
    authorStyleSheet?: {
        url?: string;
        text?: string;
    }[];
    userStyleSheet?: {
        url?: string;
        text?: string;
    }[];
};
/**
 * Options for a single source document.
 * - url: URL of the document.
 * - startPage: If specified, the `page` page-based counter is set to the
 *   specified value on the first page of the document. It is equivalent to
 *   specifying `counter-reset: page [specified value - 1]` on that page.
 * - skipPagesBefore: If specified, the `page` page-based counter is
 *   incremented by the specified value *before* updating page-based counters
 *   on the first page of the document.
 *   This option is ignored if `startPageNumber` option is also specified.
 */
declare type SingleDocumentOptions = string | {
    url: string;
    startPage?: number;
    skipPagesBefore?: number;
};
/**
 * Vivliostyle Viewer class.
 */
declare class CoreViewer {
    private readonly settings;
    private initialized;
    private adaptViewer_;
    private options;
    private eventTarget;
    readyState: Constants.ReadyState;
    constructor(settings: CoreViewerSettings, opt_options?: CoreViewerOptions);
    /**
     * Set ViewerOptions to the viewer.
     */
    setOptions(options: CoreViewerOptions): void;
    private dispatcher;
    /**
     * Add a listener function, which is invoked when the specified type of event
     * is dispatched.
     * @param type Event type.
     * @param listener Listener function.
     */
    addListener(type: string, listener: (payload: Payload) => void): void;
    /**
     * Remove an event listener.
     * @param type Event type.
     * @param listener Listener function.
     */
    removeListener(type: string, listener: (payload: Payload) => void): void;
    /**
     * Load an HTML or XML document(s).
     */
    loadDocument(singleDocumentOptions: SingleDocumentOptions | SingleDocumentOptions[], opt_documentOptions?: DocumentOptions, opt_viewerOptions?: CoreViewerOptions): void;
    /**
     * Load an EPUB/WebPub publication.
     */
    loadPublication(pubUrl: string, opt_documentOptions?: DocumentOptions, opt_viewerOptions?: CoreViewerOptions): void;
    /**
     * Load an HTML or XML document, or an EPUB/WebPub publication.
     */
    private loadDocumentOrPublication;
    /**
     * Returns the current page progression of the viewer. If no document is
     * loaded, returns null.
     */
    getCurrentPageProgression(): Constants.PageProgression | null;
    private resolveNavigation;
    /**
     * Navigate to the specified page.
     */
    navigateToPage(nav: Navigation, opt_epage?: number): void;
    /**
     * Navigate to the specified internal URL.
     */
    navigateToInternalUrl(url: string): void;
    /**
     * @returns True if TOC is visible, false if hidden, null if TOC is unavailable
     */
    isTOCVisible(): boolean | null;
    /**
     * Show or hide TOC box
     * @param opt_autohide If true, automatically hide when click TOC item
     * @param opt_show If true show TOC, false hide TOC. If null or undefined toggle TOC.
     */
    showTOC(opt_show?: boolean | null, opt_autohide?: boolean): void;
    /**
     * Returns zoom factor corresponding to the specified zoom type.
     */
    queryZoomFactor(type: AdaptiveViewer.ZoomType_$0): number;
    getPageSizes(): {
        width: number;
        height: number;
    }[];
}
/**
 * @enum {string}
 */
declare enum Navigation {
    PREVIOUS = "previous",
    NEXT = "next",
    LEFT = "left",
    RIGHT = "right",
    FIRST = "first",
    LAST = "last",
    EPAGE = "epage"
}
declare type ZoomType_$0 = AdaptiveViewer.ZoomType_$0;
declare const ZoomType_$0: typeof AdaptiveViewer.ZoomType_$0;
declare type PageViewMode_$0 = AdaptiveViewer.PageViewMode_$0;
declare const PageViewMode_$0: typeof AdaptiveViewer.PageViewMode_$0;
declare const viewer: {
    CoreViewer: typeof CoreViewer;
    PageViewMode: typeof AdaptiveViewer.PageViewMode_$0;
    ZoomType: typeof AdaptiveViewer.ZoomType_$0;
};
interface PrintConfig {
    title: string;
    printCallback: (iframeWin: Window) => void;
    hideIframe: boolean;
    removeIframe: boolean;
}
declare function printHTML(htmlDoc: string, config: PrintConfig): void;
export { isDebug, setDebug, PageProgression, pageProgressionOf, PageSide, ReadyState, constants, HOOKS, PreProcessSingleDocumentHook, PreProcessTextContentHook, PreProcessElementStyleHook, PolyfilledInheritedPropsHook, ConfigurationHook, ResolveTextNodeBreakerHook, ResolveFormattingContextHook, ResolveLayoutProcessorHook, PostLayoutBlockHook, registerHook, removeHook, getHooksForName, plugin, Profiler, profiler, profile, Payload, CoreViewerSettings, CoreViewerOptions, DocumentOptions, SingleDocumentOptions, CoreViewer, Navigation, ZoomType_$0 as ZoomType, PageViewMode_$0 as PageViewMode, viewer, PrintConfig, printHTML };