import * as Css from "./css";
import * as CssParser from "./css-parser";
import * as CssTokenizer from "./css-tokenizer";
import * as CssValidator from "./css-validator";
import * as Exprs from "./exprs";
import * as Matchers from "./matchers";
import * as Vtree from "./vtree";
import { CssCascade } from "./types";
export interface ElementStyle extends CssCascade.ElementStyle {
}
export declare 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;
};
export declare const polyfilledInheritedProps: string[];
export declare function getPolyfilledInheritedProps(): string[];
export declare const supportedNamespaces: {
    "http://www.idpf.org/2007/ops": boolean;
    "http://www.w3.org/1999/xhtml": boolean;
    "http://www.w3.org/2000/svg": boolean;
};
export declare const coupledPatterns: string[];
export declare const coupledExtentPatterns: string[];
export declare const geomNames: {
    [key: string]: boolean;
};
export declare function buildCouplingMap(sideMap: {
    [key: string]: string;
}, extentMap: {
    [key: string]: string;
}): {
    [key: string]: string;
};
export declare const couplingMapVert: {
    [key: string]: string;
};
export declare const couplingMapHor: {
    [key: string]: string;
};
export declare const couplingMapVertRtl: {
    [key: string]: string;
};
export declare const couplingMapHorRtl: {
    [key: string]: string;
};
export 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;
}
/**
 * Internal subclass of CascadeValue. Should never be seen outside of the
 * cascade engine.
 */
export declare class ConditionalCascadeValue extends CascadeValue {
    readonly condition: Exprs.Val;
    constructor(value: Css.Val, priority: number, condition: Exprs.Val);
    /**
     * @override
     */
    getBaseValue(): CascadeValue;
    /**
     * @override
     */
    filterValue(visitor: Css.Visitor): CascadeValue;
    /**
     * @override
     */
    increaseSpecificity(specificity: number): CascadeValue;
    isEnabled(context: Exprs.Context): boolean;
}
/**
 * @param tv current value (cannot be conditional)
 * @param av cascaded value (can be conditional)
 */
export declare function cascadeValues(context: Exprs.Context, tv: CascadeValue, av: CascadeValue): CascadeValue;
export declare type ElementStyleMap = {
    [key: string]: ElementStyle;
};
export declare const SPECIALS: {
    "region-id": boolean;
    "fragment-selector-id": boolean;
};
export declare function isSpecialName(name: string): boolean;
export declare function isMapName(name: string): boolean;
export declare function isPropName(name: string): boolean;
export declare function isInherited(name: string): boolean;
export declare function getProp(style: ElementStyle, name: string): CascadeValue;
/**
 * @return void
 */
export declare function setProp(style: ElementStyle, name: string, value: CascadeValue): any;
export declare function getStyleMap(style: ElementStyle, name: string): ElementStyleMap;
export declare function getMutableStyleMap(style: ElementStyle, name: string): ElementStyleMap;
export declare const getViewConditionalStyleMap: (style: ElementStyle) => {
    matcher: Matchers.Matcher;
    styles: ElementStyleMap;
}[];
export declare function getSpecial(style: ElementStyle, name: string): CascadeValue[];
export declare function getMutableSpecial(style: ElementStyle, name: string): CascadeValue[];
export declare function mergeIn(context: Exprs.Context, target: ElementStyle, style: ElementStyle, specificity: number, pseudoelement: string | null, regionId: string | null, viewConditionMatcher: Matchers.Matcher | null): void;
export declare function mergeAll(context: Exprs.Context, styles: ElementStyle[]): ElementStyle;
export declare function chainActions(chain: ChainedAction[], action: CascadeAction): CascadeAction;
export declare class InheritanceVisitor extends Css.FilterVisitor {
    readonly props: ElementStyle;
    readonly context: Exprs.Context;
    propName: string;
    constructor(props: ElementStyle, context: Exprs.Context);
    setPropName(name: string): void;
    private getFontSize;
    /**
     * @override
     */
    visitNumeric(numeric: Css.Numeric): Css.Val;
    /**
     * @override
     */
    visitExpr(expr: Css.Expr): Css.Val;
}
export declare function convertFontRelativeLengthToPx(numeric: Css.Numeric, baseFontSize: number, context: Exprs.Context): Css.Numeric;
export declare function convertFontSizeToPx(numeric: Css.Numeric, parentFontSize: number, context: Exprs.Context): Css.Numeric;
export declare type ActionTable = {
    [key: string]: CascadeAction;
};
export declare class CascadeAction {
    apply(cascadeInstance: CascadeInstance): void;
    mergeWith(other: CascadeAction): CascadeAction;
    clone(): CascadeAction;
}
export declare class ConditionItemAction extends CascadeAction {
    readonly conditionItem: ConditionItem;
    constructor(conditionItem: ConditionItem);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
}
export declare class CompoundAction extends CascadeAction {
    readonly list: CascadeAction[];
    constructor(list: CascadeAction[]);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    mergeWith(other: CascadeAction): CascadeAction;
    /**
     * @override
     */
    clone(): CascadeAction;
}
export declare class ApplyRuleAction extends CascadeAction {
    readonly style: ElementStyle;
    readonly specificity: number;
    readonly pseudoelement: string | null;
    readonly regionId: string | null;
    readonly viewConditionId: string | null;
    constructor(style: ElementStyle, specificity: number, pseudoelement: string | null, regionId: string | null, viewConditionId: string | null);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
}
export declare class ChainedAction extends CascadeAction {
    chained: CascadeAction;
    constructor();
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    getPriority(): number;
    makePrimary(cascade: Cascade): boolean;
}
export declare class CheckClassAction extends ChainedAction {
    readonly className: string;
    constructor(className: string);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    getPriority(): number;
    /**
     * @override
     */
    makePrimary(cascade: Cascade): boolean;
}
export declare class CheckIdAction extends ChainedAction {
    readonly id: string;
    constructor(id: string);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    getPriority(): number;
    /**
     * @override
     */
    makePrimary(cascade: Cascade): boolean;
}
export declare class CheckLocalNameAction extends ChainedAction {
    readonly localName: string;
    constructor(localName: string);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    getPriority(): number;
    /**
     * @override
     */
    makePrimary(cascade: Cascade): boolean;
}
export declare class CheckNSTagAction extends ChainedAction {
    readonly ns: string;
    readonly localName: string;
    constructor(ns: string, localName: string);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    getPriority(): number;
    /**
     * @override
     */
    makePrimary(cascade: Cascade): boolean;
}
export declare class CheckTargetEpubTypeAction extends ChainedAction {
    readonly epubTypePatt: RegExp;
    constructor(epubTypePatt: RegExp);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
}
export declare class CheckNamespaceAction extends ChainedAction {
    readonly ns: string;
    constructor(ns: string);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
}
export declare class CheckAttributePresentAction extends ChainedAction {
    readonly ns: string;
    readonly name: string;
    constructor(ns: string, name: string);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
}
export declare class CheckAttributeEqAction extends ChainedAction {
    readonly ns: string;
    readonly name: string;
    readonly value: string;
    constructor(ns: string, name: string, value: string);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    getPriority(): number;
    /**
     * @override
     */
    makePrimary(cascade: Cascade): boolean;
}
export declare class CheckNamespaceSupportedAction extends ChainedAction {
    readonly ns: string;
    readonly name: string;
    constructor(ns: string, name: string);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    getPriority(): number;
    /**
     * @override
     */
    makePrimary(cascade: Cascade): boolean;
}
export declare class CheckAttributeRegExpAction extends ChainedAction {
    readonly ns: string;
    readonly name: string;
    readonly regexp: RegExp;
    constructor(ns: string, name: string, regexp: RegExp);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
}
export declare class CheckLangAction extends ChainedAction {
    readonly langRegExp: RegExp;
    constructor(langRegExp: RegExp);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
}
export declare class IsFirstAction extends ChainedAction {
    constructor();
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    getPriority(): number;
}
export declare class IsRootAction extends ChainedAction {
    constructor();
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    getPriority(): number;
}
export 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;
}
export declare class IsNthSiblingAction extends IsNthAction {
    constructor(a: number, b: number);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    getPriority(): number;
}
export declare class IsNthSiblingOfTypeAction extends IsNthAction {
    constructor(a: number, b: number);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    getPriority(): number;
}
export declare class IsNthLastSiblingAction extends IsNthAction {
    constructor(a: number, b: number);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    getPriority(): number;
}
export declare class IsNthLastSiblingOfTypeAction extends IsNthAction {
    constructor(a: number, b: number);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    getPriority(): number;
}
export declare class IsEmptyAction extends ChainedAction {
    constructor();
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    getPriority(): number;
}
export declare class IsEnabledAction extends ChainedAction {
    constructor();
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    getPriority(): number;
}
export declare class IsDisabledAction extends ChainedAction {
    constructor();
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    getPriority(): number;
}
export declare class IsCheckedAction extends ChainedAction {
    constructor();
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    getPriority(): number;
}
export declare class CheckConditionAction extends ChainedAction {
    readonly condition: string;
    constructor(condition: string);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    getPriority(): number;
}
export declare class CheckAppliedAction extends CascadeAction {
    applied: boolean;
    constructor();
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    clone(): CascadeAction;
}
export declare class NegateActionsSet extends ChainedAction {
    checkAppliedAction: CheckAppliedAction;
    firstAction: CascadeAction;
    constructor(list: ChainedAction[]);
    /**
     * @override
     */
    apply(cascadeInstance: CascadeInstance): void;
    /**
     * @override
     */
    getPriority(): number;
}
/**
 * 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).
 */
export 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;
}
export 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;
}
export declare class DescendantConditionItem extends AbstractConditionItem implements ConditionItem {
    constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
    /**
     * @override
     */
    fresh(cascadeInstance: CascadeInstance): ConditionItem;
    /**
     * @override
     */
    push(cascadeInstance: CascadeInstance, depth: number): boolean;
    /**
     * @override
     */
    pop(cascadeInstance: CascadeInstance, depth: number): boolean;
}
export declare class ChildConditionItem extends AbstractConditionItem implements ConditionItem {
    constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
    /**
     * @override
     */
    fresh(cascadeInstance: CascadeInstance): ConditionItem;
    /**
     * @override
     */
    push(cascadeInstance: CascadeInstance, depth: number): boolean;
    /**
     * @override
     */
    pop(cascadeInstance: CascadeInstance, depth: number): boolean;
}
export declare class AdjacentSiblingConditionItem extends AbstractConditionItem implements ConditionItem {
    fired: boolean;
    constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
    /**
     * @override
     */
    fresh(cascadeInstance: CascadeInstance): ConditionItem;
    /**
     * @override
     */
    push(cascadeInstance: CascadeInstance, depth: number): boolean;
    /**
     * @override
     */
    pop(cascadeInstance: CascadeInstance, depth: number): boolean;
}
export declare class FollowingSiblingConditionItem extends AbstractConditionItem implements ConditionItem {
    fired: boolean;
    constructor(condition: string, viewConditionId: string | null, viewCondition: Matchers.Matcher);
    /**
     * @override
     */
    fresh(cascadeInstance: CascadeInstance): ConditionItem;
    /**
     * @override
     */
    push(cascadeInstance: CascadeInstance, depth: number): boolean;
    /**
     * @override
     */
    pop(cascadeInstance: CascadeInstance, depth: number): boolean;
}
/**
 * Not a true condition item, this class manages proper handling of "after"
 * pseudoelement.
 */
export declare class AfterPseudoelementItem implements ConditionItem {
    readonly afterprop: ElementStyle;
    readonly element: Element;
    constructor(afterprop: ElementStyle, element: Element);
    /**
     * @override
     */
    fresh(cascadeInstance: CascadeInstance): ConditionItem;
    /**
     * @override
     */
    push(cascadeInstance: CascadeInstance, depth: number): boolean;
    /**
     * @override
     */
    pop(cascadeInstance: CascadeInstance, depth: number): boolean;
}
/**
 * Not a true condition item, this class restores current language.
 */
export declare class RestoreLangItem implements ConditionItem {
    readonly lang: string;
    constructor(lang: string);
    /**
     * @override
     */
    fresh(cascadeInstance: CascadeInstance): ConditionItem;
    /**
     * @override
     */
    push(cascadeInstance: CascadeInstance, depth: number): boolean;
    /**
     * @override
     */
    pop(cascadeInstance: CascadeInstance, depth: number): boolean;
}
/**
 * Not a true condition item, this class manages inheritance of quotes property
 */
export declare class QuotesScopeItem implements ConditionItem {
    readonly oldQuotes: Css.Str[];
    constructor(oldQuotes: Css.Str[]);
    /**
     * @override
     */
    fresh(cascadeInstance: CascadeInstance): ConditionItem;
    /**
     * @override
     */
    push(cascadeInstance: CascadeInstance, depth: number): boolean;
    /**
     * @override
     */
    pop(cascadeInstance: CascadeInstance, depth: number): boolean;
}
export declare type CounterValues = {
    [key: string]: number[];
};
export interface CounterListener {
    countersOfId(id: string, counters: CounterValues): any;
    getExprContentListener(): Vtree.ExprContentListener;
}
export 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;
}
export declare class AttrValueFilterVisitor extends Css.FilterVisitor {
    element: Element;
    constructor(element: Element);
    private createValueFromString;
    /**
     * @override
     */
    visitFunc(func: Css.Func): Css.Val;
}
export declare class ContentPropVisitor extends Css.FilterVisitor {
    cascade: CascadeInstance;
    element: Element;
    readonly counterResolver: CounterResolver;
    constructor(cascade: CascadeInstance, element: Element, counterResolver: CounterResolver);
    /**
     * @override
     */
    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;
    /**
     * @override
     */
    visitFunc(func: Css.Func): Css.Val;
}
export declare function roman(num: number): string;
export declare const additiveNumbering: {
    roman: (string | number)[];
    armenian: (string | number)[];
    georgian: (string | number)[];
    hebrew: (string | number)[];
};
export declare const alphabeticNumbering: {
    latin: string;
    alpha: string;
    greek: string;
    russian: string;
};
export declare const fixed: {
    square: string;
    disc: string;
    circle: string;
    none: string;
};
export declare function additiveFormat(entries: any[], num: number): string;
export declare function expandAlphabet(str: string): string[] | null;
export declare function alphabeticFormat(alphabetStr: string, num: number): string;
export declare type ChineseNumbering = {
    digits: string;
    markers: string;
    negative: string;
    formal: boolean;
};
/**
 * From http://www.w3.org/TR/css3-lists/
 */
export declare const chineseTradInformal: ChineseNumbering;
export declare function chineseCounter(num: number, numbering: ChineseNumbering): string;
/**
 * Fitting order and specificity in the same number. Order is recorded in the
 * fractional part. Select value so that
 *
 *   0x7FFFFFFF != 0x7FFFFFFF + ORDER_INCREMENT
 *
 */
export declare const ORDER_INCREMENT: number;
export declare function copyTable(src: ActionTable, dst: ActionTable): void;
export 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;
}
export 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 | 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): void;
    defineCounter(counterName: string, value: number): void;
    pushCounters(props: ElementStyle): void;
    popCounters(): void;
    processPseudoelementProps(pseudoprops: ElementStyle, element: Element): void;
    pushElement(element: Element, baseStyle: ElementStyle, elementOffset: number): void;
    private applyAttrFilterInner;
    private applyAttrFilter;
    private applyActions;
    private pop;
    popRule(): void;
    popElement(element: Element): void;
}
export declare const EMPTY: any[];
/**
 * Pseudoelement names in the order they should be processed, empty string is
 * the place where the element's DOM children are processed.
 */
export declare const pseudoNames: string[];
/**
 * @enum {number}
 */
export declare enum ParseState {
    TOP = 0,
    SELECTOR = 1,
    RULE = 2
}
/**
 * Cascade for base User Agent stylesheet.
 */
export declare let uaBaseCascade: Cascade;
export declare function setUABaseCascade(value: Cascade): void;
export 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;
    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;
}
export declare const nthSelectorActionClasses: {
    [key: string]: typeof IsNthAction;
};
export declare let conditionCount: number;
export declare class NotParameterParserHandler extends CascadeParserHandler {
    readonly parent: CascadeParserHandler;
    parentChain: ChainedAction[];
    constructor(parent: CascadeParserHandler);
    /**
     * @override
     */
    startFuncWithSelector(funcName: string): void;
    /**
     * @override
     */
    startRuleBody(): void;
    /**
     * @override
     */
    nextSelector(): void;
    /**
     * @override
     */
    endFuncWithSelector(): void;
    /**
     * @override
     */
    error(mnemonics: string, token: CssTokenizer.Token): void;
}
/**
 * @override
 */
export declare class DefineParserHandler extends CssParser.SlaveParserHandler {
    constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler);
    /**
     * @override
     */
    property(name: string, value: Css.Val, important: boolean): void;
}
export declare class PropSetParserHandler extends CssParser.SlaveParserHandler implements CssValidator.PropertyReceiver {
    readonly condition: Exprs.Val;
    readonly elementStyle: ElementStyle;
    readonly validatorSet: CssValidator.ValidatorSet;
    order: number;
    constructor(scope: Exprs.LexicalScope, owner: CssParser.DispatchParserHandler, condition: Exprs.Val, elementStyle: ElementStyle, validatorSet: CssValidator.ValidatorSet);
    /**
     * @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;
}
export declare class PropertyParserHandler extends CssParser.ErrorHandler implements CssValidator.PropertyReceiver {
    readonly validatorSet: CssValidator.ValidatorSet;
    elementStyle: ElementStyle;
    order: number;
    constructor(scope: Exprs.LexicalScope, validatorSet: CssValidator.ValidatorSet);
    /**
     * @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;
}
export declare function forEachViewConditionalStyles(style: ElementStyle, callback: (p1: ElementStyle) => any): void;
export declare function mergeViewConditionalStyles(cascMap: {
    [key: string]: CascadeValue;
}, context: Exprs.Context, style: ElementStyle): void;
export declare function parseStyleAttribute(scope: Exprs.LexicalScope, validatorSet: CssValidator.ValidatorSet, baseURL: string, styleAttrValue: string): ElementStyle;
export declare function isVertical(cascaded: {
    [key: string]: CascadeValue;
}, context: Exprs.Context, vertical: boolean): boolean;
export declare function isRtl(cascaded: {
    [key: string]: CascadeValue;
}, context: Exprs.Context, rtl: boolean): boolean;
export declare function flattenCascadedStyle(style: ElementStyle, context: Exprs.Context, regionIds: string[], isFootnote: boolean, nodeContext: Vtree.NodeContext): {
    [key: string]: CascadeValue;
};
export declare function forEachStylesInRegion(style: ElementStyle, regionIds: string[], isFootnote: boolean, callback: (p1: string, p2: ElementStyle) => any): void;
export declare function mergeStyle(to: {
    [key: string]: CascadeValue;
}, from: ElementStyle, context: Exprs.Context): void;
/**
 * Convert logical properties to physical ones, taking specificity into account.
 * @param src Source properties map
 * @param dest Destination map
 * @param transform If supplied, property values are transformed by this
 *     function before inserted into the destination map. The first parameter is
 *     the property name and the second one is the property value.
 * @template T
 */
export declare const convertToPhysical: <T>(src: {
    [key: string]: CascadeValue;
}, dest: {
    [key: string]: T;
}, vertical: boolean, rtl: boolean, transform: (p1: string, p2: CascadeValue) => T) => void;