diff --git a/src/dlangui/core/css.d b/src/dlangui/core/css.d
deleted file mode 100644
index 581e8b9b..00000000
--- a/src/dlangui/core/css.d
+++ /dev/null
@@ -1,662 +0,0 @@
-// Written in the D programming language.
-
-/**
-This module contains implementation of CSS support - Cascading Style Sheets.
-
-Port of CoolReader Engine written in C++.
-
-Supports subset of CSS standards.
-
-
-Synopsis:
-
-----
-import dlangui.core.css;
-
-----
-
-Copyright: Vadim Lopatin, 2015
-License:   Boost License 1.0
-Authors:   Vadim Lopatin, coolreader.org@gmail.com
-*/
-module dlangui.core.css;
-
-import std.traits;
-import std.conv : to;
-import std.string;
-import std.array : empty;
-import std.algorithm : equal;
-import std.ascii : isAlpha;
-
-import dlangui.core.dom;
-
-/// display property values
-enum CssDisplay : ubyte {
-    inherit,
-    inline,
-    block,
-    list_item,
-    run_in,
-    compact,
-    marker,
-    table,
-    inline_table,
-    table_row_group,
-    table_header_group,
-    table_footer_group,
-    table_row,
-    table_column_group,
-    table_column,
-    table_cell,
-    table_caption,
-    none
-}
-
-/// white-space property values
-enum CssWhiteSpace : ubyte {
-    inherit,
-    normal,
-    pre,
-    nowrap
-}
-
-/// text-align property values
-enum CssTextAlign : ubyte {
-    inherit,
-    left,
-    right,
-    center,
-    justify
-}
-
-/// vertical-align property values
-enum CssVerticalAlign : ubyte {
-    inherit,
-    baseline,
-    sub,
-    super_,
-    top,
-    text_top,
-    middle,
-    bottom,
-    text_bottom
-}
-
-/// text-decoration property values
-enum CssTextDecoration : ubyte {
-    // TODO: support multiple flags
-    inherit = 0,
-    none = 1,
-    underline = 2,
-    overline = 3,
-    line_through = 4,
-    blink = 5
-}
-
-/// hyphenate property values
-enum CssHyphenate : ubyte {
-    inherit = 0,
-    none = 1,
-    auto_ = 2
-}
-
-/// font-style property values
-enum CssFontStyle : ubyte {
-    inherit,
-    normal,
-    italic,
-    oblique
-}
-
-/// font-weight property values
-enum CssFontWeight : ubyte {
-    inherit,
-    normal,
-    bold,
-    bolder,
-    lighter,
-    fw_100,
-    fw_200,
-    fw_300,
-    fw_400,
-    fw_500,
-    fw_600,
-    fw_700,
-    fw_800,
-    fw_900
-}
-
-/// font-family property values
-enum CssFontFamily : ubyte {
-    inherit,
-    serif,
-    sans_serif,
-    cursive,
-    fantasy,
-    monospace
-}
-
-/// page split property values
-enum CssPageBreak : ubyte {
-    inherit,
-    auto_,
-    always,
-    avoid,
-    left,
-    right
-}
-
-/// list-style-type property values
-enum CssListStyleType : ubyte {
-    inherit,
-    disc,
-    circle,
-    square,
-    decimal,
-    lower_roman,
-    upper_roman,
-    lower_alpha,
-    upper_alpha,
-    none
-}
-
-/// list-style-position property values
-enum CssListStylePosition : ubyte {
-    inherit,
-    inside,
-    outside
-}
-
-/// css length value types
-enum CssValueType : ubyte {
-    inherited,
-    unspecified,
-    px,
-    em,
-    ex,
-    in_, // 2.54 cm
-    cm,
-    mm,
-    pt, // 1/72 in
-    pc, // 12 pt
-    percent,
-    color
-}
-
-/// css length value
-struct CssValue {
-
-    int value = 0;      ///< value (*256 for all types except % and px)
-    CssValueType type = CssValueType.px;  ///< type of value
-
-    this(int px_value ) {
-        value = px_value;
-    }
-    this(CssValueType n_type, int n_value) {
-        type = n_type;
-        value = n_value;
-    }
-    bool opEqual(CssValue v) const
-    {
-        return type == v.type
-            && value == v.value;
-    }
-
-    static const CssValue inherited = CssValue(CssValueType.inherited, 0);
-}
-
-enum CssDeclType : ubyte {
-    unknown,
-    display,
-    white_space,
-    text_align,
-    text_align_last,
-    text_decoration,
-    hyphenate, // hyphenate
-    _webkit_hyphens, // -webkit-hyphens
-    adobe_hyphenate, // adobe-hyphenate
-    adobe_text_layout, // adobe-text-layout
-    color,
-    background_color,
-    vertical_align,
-    font_family, // id families like serif, sans-serif
-    //font_names,   // string font name like Arial, Courier
-    font_size,
-    font_style,
-    font_weight,
-    text_indent,
-    line_height,
-    letter_spacing,
-    width,
-    height,
-    margin_left,
-    margin_right,
-    margin_top,
-    margin_bottom,
-    margin,
-    padding_left,
-    padding_right,
-    padding_top,
-    padding_bottom,
-    padding,
-    page_break_before,
-    page_break_after,
-    page_break_inside,
-    list_style,
-    list_style_type,
-    list_style_position,
-    list_style_image
-}
-
-class CssStyle {
-    CssDisplay display = CssDisplay.block;
-    CssWhiteSpace whiteSpace = CssWhiteSpace.inherit;
-    CssTextAlign textAlign = CssTextAlign.inherit;
-    CssTextAlign textAlignLast = CssTextAlign.inherit;
-    CssTextDecoration textDecoration = CssTextDecoration.inherit;
-    CssHyphenate hyphenate = CssHyphenate.inherit;
-    CssVerticalAlign verticalAlign = CssVerticalAlign.inherit;
-    CssFontFamily fontFamily = CssFontFamily.inherit;
-    CssFontStyle fontStyle = CssFontStyle.inherit;
-    CssPageBreak pageBreakBefore = CssPageBreak.inherit;
-    CssPageBreak pageBreakInside = CssPageBreak.inherit;
-    CssPageBreak pageBreakAfter = CssPageBreak.inherit;
-    CssListStyleType listStyleType = CssListStyleType.inherit;
-    CssListStylePosition listStylePosition = CssListStylePosition.inherit;
-    CssFontWeight fontWeight = CssFontWeight.inherit;
-    string fontFaces;
-    CssValue color = CssValue.inherited;
-    CssValue backgroundColor = CssValue.inherited;
-    CssValue lineHeight = CssValue.inherited;
-    CssValue letterSpacing = CssValue.inherited;
-    CssValue width = CssValue.inherited;
-    CssValue height = CssValue.inherited;
-    CssValue marginLeft = CssValue.inherited;
-    CssValue marginRight = CssValue.inherited;
-    CssValue marginTop = CssValue.inherited;
-    CssValue marginBottom = CssValue.inherited;
-    CssValue paddingLeft = CssValue.inherited;
-    CssValue paddingRight = CssValue.inherited;
-    CssValue paddingTop = CssValue.inherited;
-    CssValue paddingBottom = CssValue.inherited;
-    CssValue fontSize = CssValue.inherited;
-    CssValue textIndent = CssValue.inherited;
-}
-
-/// selector rule type
-enum CssSelectorRuleType : ubyte {
-    universal,     // *
-    parent,        // E > F
-    ancessor,      // E F
-    predecessor,   // E + F
-    attrset,       // E[foo]
-    attreq,        // E[foo="value"]
-    attrhas,       // E[foo~="value"]
-    attrstarts,    // E[foo|="value"]
-    id,            // E#id
-    class_          // E.class
-}
-
-class CssSelectorRule
-{
-private:
-    CssSelectorRuleType _type;
-    elem_id _id;
-    attr_id _attrid;
-    CssSelectorRule _next;
-    string _value;
-public:
-    this(CssSelectorRuleType type) {
-        _type = type;
-    }
-    this(const CssSelectorRule v) {
-        _type = v._type;
-        _id = v._id;
-        _attrid = v._attrid;
-        _value = v._value;
-    }
-    ~this() {
-        //if (_next)
-        //    destroy(_next);
-    }
-
-    @property elem_id id() { return _id; }
-    @property void id(elem_id newid) { _id = newid; }
-    @property attr_id attrid() { return _attrid; }
-    @property void setAttr(attr_id newid, string value) { _attrid = newid; _value = value; }
-    @property CssSelectorRule next() { return _next; }
-    @property void next(CssSelectorRule v) { _next = v; }
-    /// check condition for node
-    bool check(ref Node node) const {
-        if (!node || !node.parent)
-            return false;
-        switch (_type) with (CssSelectorRuleType) {
-            case parent:        // E > F
-                node = node.parent;
-                if (!node)
-                    return false;
-                return node.id == _id;
-
-            case ancessor:      // E F
-                for (;;) {
-                    node = node.parent;
-                    if (!node)
-                        return false;
-                    if (node.id == _id)
-                        return true;
-                }
-
-            case predecessor:   // E + F
-                int index = node.index;
-                // while
-                if (index > 0) {
-                    Node elem = node.parent.childElement(index-1, _id);
-                    if ( elem ) {
-                        node = elem;
-                        //CRLog::trace("+ selector: found pred element");
-                        return true;
-                    }
-                    //index--;
-                }
-                return false;
-
-            case attrset:       // E[foo]
-                return node.hasAttr(_attrid);
-
-            case attreq:        // E[foo="value"]
-                string val = node.attrValue(Ns.any, _attrid);
-                return (val == _value);
-
-            case attrhas:       // E[foo~="value"]
-                // one of space separated values
-                string val = node.attrValue(Ns.any, _attrid);
-                int p = cast(int)val.indexOf(_value);
-                if (p < 0)
-                    return false;
-                if ( (p > 0 && val[p - 1] != ' ')
-                        || ( p + _value.length < val.length && val[p + _value.length] != ' '))
-                    return false;
-                return true;
-
-            case attrstarts:    // E[foo|="value"]
-                string val = node.attrValue(Ns.any, _attrid);
-                if (_value.length > val.length)
-                    return false;
-                return val[0 .. _value.length] == _value;
-
-            case id:            // E#id
-                string val = node.attrValue(Ns.any, Attr.id);
-                return val == _value;
-
-            case class_:         // E.class
-                string val = node.attrValue(Ns.any, Attr.class_);
-                return !val.icmp(_value);
-
-            case universal:     // *
-                return true;
-
-            default:
-                return true;
-        }
-    }
-}
-
-import dlangui.core.cssparser;
-
-/** simple CSS selector
-
-Currently supports only element name and universal selector.
-
-- * { } - universal selector
-- element-name { } - selector by element name
-- element1, element2 { } - several selectors delimited by comma
-*/
-class CssSelector {
-private:
-    uint _id;
-    CssDeclaration _decl;
-    int _specificity;
-    CssSelector _next;
-    CssSelectorRule _rules;
-public:
-    /// get element tag id (0 - any tag)
-    @property elem_id id() { return _id; }
-    /// set element tag id (0 - any tag)
-    @property void id(elem_id id) { _id = id; }
-
-    this() { }
-
-    ~this() {
-        //if (_next)
-        //    destroy(_next);
-    }
-
-    void insertRuleStart(CssSelectorRule rule) {
-        rule.next = _rules;
-        _rules = rule;
-    }
-
-    void insertRuleAfterStart(CssSelectorRule rule) {
-        if (!_rules) {
-            _rules = rule;
-        } else {
-            rule.next = _rules.next;
-            _rules.next = rule;
-        }
-    }
-
-    /// check if selector rules match this node
-    bool check(Node node) const {
-        CssSelectorRule rule = cast(CssSelectorRule)_rules;
-        while (rule && node) {
-            if (!rule.check(node))
-                return false;
-            rule = rule.next;
-        }
-        return true;
-    }
-
-    /// apply to style if selector matches
-    void apply(Node node, CssStyle style) const {
-        if (check(node))
-            _decl.apply(style);
-    }
-
-    void setDeclaration(CssDeclaration decl) {
-        _decl = decl;
-    }
-}
-
-struct CssDeclItem {
-    CssDeclType type = CssDeclType.unknown;
-    union {
-        int value;
-        CssValue length;
-    }
-    string str;
-
-    void apply(CssStyle style) const {
-        switch (type) with (CssDeclType) {
-            case display: style.display = cast(CssDisplay)value; break;
-            case white_space: style.whiteSpace = cast(CssWhiteSpace)value; break;
-            case text_align: style.textAlign = cast(CssTextAlign)value; break;
-            case text_align_last: style.textAlignLast = cast(CssTextAlign)value; break;
-            case text_decoration: style.textDecoration = cast(CssTextDecoration)value; break;
-
-            case _webkit_hyphens: // -webkit-hyphens
-            case adobe_hyphenate: // adobe-hyphenate
-            case adobe_text_layout: // adobe-text-layout
-            case hyphenate:
-                style.hyphenate = cast(CssHyphenate)value;
-                break; // hyphenate
-
-            case color: style.color = length; break;
-            case background_color: style.backgroundColor = length; break;
-            case vertical_align: style.verticalAlign = cast(CssVerticalAlign)value; break;
-            case font_family:
-                if (value >= 0)
-                    style.fontFamily = cast(CssFontFamily)value;
-                if (!str.empty)
-                    style.fontFaces = str;
-                break; // id families like serif, sans-serif
-            //case font_names: break;   // string font name like Arial, Courier
-            case font_style: style.fontStyle = cast(CssFontStyle)value; break;
-            case font_weight: style.fontWeight = cast(CssFontWeight)value; break;
-            case text_indent: style.textIndent = length; break;
-            case font_size: style.fontSize = length; break;
-            case line_height: style.lineHeight = length; break;
-            case letter_spacing: style.letterSpacing = length; break;
-            case width: style.width = length; break;
-            case height: style.height = length; break;
-            case margin_left: style.marginLeft = length; break;
-            case margin_right: style.marginRight = length; break;
-            case margin_top: style.marginTop = length; break;
-            case margin_bottom: style.marginBottom = length; break;
-            case padding_left: style.paddingLeft = length; break;
-            case padding_right: style.paddingRight = length; break;
-            case padding_top: style.paddingTop = length; break;
-            case padding_bottom: style.paddingBottom = length; break;
-            case page_break_before: style.pageBreakBefore = cast(CssPageBreak)value; break;
-            case page_break_after: style.pageBreakAfter = cast(CssPageBreak)value; break;
-            case page_break_inside: style.pageBreakInside = cast(CssPageBreak)value; break;
-            case list_style: break; // TODO
-            case list_style_type: style.listStyleType = cast(CssListStyleType)value; break;
-            case list_style_position: style.listStylePosition = cast(CssListStylePosition)value; break;
-            case list_style_image: break; // TODO
-            default:
-                break;
-        }
-    }
-}
-
-/// css declaration like { display: block; margin-top: 10px }
-class CssDeclaration {
-    private CssDeclItem[] _list;
-
-    @property bool empty() {
-        return _list.length == 0;
-    }
-
-    void addLengthDecl(CssDeclType type, CssValue len) {
-        CssDeclItem item;
-        item.type = type;
-        item.length = len;
-        _list ~= item;
-    }
-
-    void addDecl(CssDeclType type, int value, string str) {
-        CssDeclItem item;
-        item.type = type;
-        item.value = value;
-        item.str = str;
-        _list ~= item;
-    }
-
-    void apply(CssStyle style) const {
-        foreach(item; _list)
-            item.apply(style);
-    }
-}
-
-/// CSS Style Sheet
-class StyleSheet {
-private:
-    CssSelector[elem_id] _selectorMap;
-    int _len;
-public:
-    /// clears stylesheet
-    void clear() {
-        _selectorMap = null;
-        _len = 0;
-    }
-
-    /// count of selectors in stylesheet
-    @property int length() { return _len; }
-
-    /// add selector to stylesheet
-    void add(CssSelector selector) {
-        elem_id id = selector.id;
-        if (auto p = id in _selectorMap) {
-            for (;;) {
-                if (!(*p) || (*p)._specificity < selector._specificity) {
-                    selector._next = (*p);
-                    (*p) = selector;
-                    _len++;
-                    break;
-                }
-                p = &((*p)._next);
-            }
-        } else {
-            // first selector for this id
-            _selectorMap[id] = selector;
-            _len++;
-        }
-    }
-
-    /// apply stylesheet to node style
-    void apply(Node node, CssStyle style) {
-        elem_id id = node.id;
-        CssSelector selector_0, selector_id;
-        if (auto p = 0 in _selectorMap)
-            selector_0 = *p;
-        if (id) {
-            if (auto p = id in _selectorMap)
-                selector_id = *p;
-        }
-        for (;;) {
-            if (selector_0) {
-                if (!selector_id || selector_id._specificity < selector_0._specificity) {
-                    selector_0.apply(node, style);
-                    selector_0 = selector_0._next;
-                } else {
-                    selector_id.apply(node, style);
-                    selector_id = selector_id._next;
-                }
-            } else if (selector_id) {
-                selector_id.apply(node, style);
-                selector_id = selector_id._next;
-            } else {
-                // end of lists
-                break;
-            }
-        }
-    }
-}
-
-unittest {
-    CssStyle style = new CssStyle();
-    CssWhiteSpace whiteSpace = CssWhiteSpace.inherit;
-    CssTextAlign textAlign = CssTextAlign.inherit;
-    CssTextAlign textAlignLast = CssTextAlign.inherit;
-    CssTextDecoration textDecoration = CssTextDecoration.inherit;
-    CssHyphenate hyphenate = CssHyphenate.inherit;
-    string src = "{ display: inline; text-decoration: underline; white-space: pre; text-align: right; text-align-last: left; " ~
-        "hyphenate: auto; width: 70%; height: 1.5pt; margin-left: 2.0em; " ~
-        "font-family: Arial, 'Times New Roman', sans-serif; font-size: 18pt; line-height: 120%; letter-spacing: 2px; font-weight: 300; " ~
-        " }tail";
-    CssDeclaration decl = parseCssDeclaration(src, true);
-    assert(decl !is null);
-    assert(!src.empty && src[0] == 't');
-    assert(style.display == CssDisplay.block);
-    assert(style.textDecoration == CssTextDecoration.inherit);
-    assert(style.whiteSpace == CssWhiteSpace.inherit);
-    assert(style.textAlign == CssTextAlign.inherit);
-    assert(style.textAlignLast == CssTextAlign.inherit);
-    assert(style.hyphenate == CssHyphenate.inherit);
-    assert(style.width == CssValue.inherited);
-    decl.apply(style);
-    assert(style.display == CssDisplay.inline);
-    assert(style.textDecoration == CssTextDecoration.underline);
-    assert(style.whiteSpace == CssWhiteSpace.pre);
-    assert(style.textAlign == CssTextAlign.right);
-    assert(style.textAlignLast == CssTextAlign.left);
-    assert(style.hyphenate == CssHyphenate.auto_);
-    assert(style.width == CssValue(CssValueType.percent, 70));
-    assert(style.height == CssValue(CssValueType.pt, 1*256 + 5*256/10)); // 1.5
-    assert(style.marginLeft == CssValue(CssValueType.em, 2*256 + 0*256/10)); // 2.0
-    assert(style.lineHeight == CssValue(CssValueType.percent, 120)); // 120%
-    assert(style.letterSpacing == CssValue(CssValueType.px, 2)); // 2px
-    assert(style.fontFamily == CssFontFamily.sans_serif);
-    assert(style.fontFaces == "\"Arial\", \"Times New Roman\"");
-    assert(style.fontWeight == CssFontWeight.fw_300);
-}
diff --git a/src/dlangui/core/cssparser.d b/src/dlangui/core/cssparser.d
deleted file mode 100644
index aac5ef1f..00000000
--- a/src/dlangui/core/cssparser.d
+++ /dev/null
@@ -1,858 +0,0 @@
-module dlangui.core.cssparser;
-
-import std.traits;
-import std.conv : to;
-import std.string;
-import std.array : empty;
-import std.algorithm : equal;
-import std.ascii : isAlpha, isWhite;
-
-import dlangui.core.dom;
-import dlangui.core.css;
-import dlangui.core.types : parseHexDigit;
-
-/// skip specified count of chars of string, returns next available character, or 0 if end of string reached
-private char skip(ref string src, int count = 1) {
-    if (count >= src.length) {
-        src = null;
-        return 0;
-    }
-    src = src[count .. $];
-    return src[0];
-}
-
-/// returns char of string at specified position (first by default) or 0 if end of string reached
-private char peek(string str, int offset = 0) {
-    return offset >= str.length ? 0 : str[offset];
-}
-
-/// skip spaces, move to new location, return first character in string, 0 if end of string reached
-private char skipSpaces(ref string str)
-{
-    string oldpos = str;
-    for (;;) {
-        char ch = str.peek;
-        if (!ch)
-            return 0;
-        while (isWhite(ch))
-            ch = str.skip;
-        if (str.peek == '/' && str.peek(1) == '*') {
-            // comment found
-            str.skip(2);
-            while (str.peek && (str.peek(0) != '*' || str.peek(1) != '/'))
-                str.skip;
-            if (str.peek == '*' && str.peek(1) == '/' )
-                str.skip(2);
-        }
-        ch = str.peek;
-        while (isWhite(ch))
-            ch = str.skip;
-        if (oldpos.ptr is str.ptr)
-            break;
-        if (str.empty)
-            return 0;
-        oldpos = str;
-    }
-    return str.peek;
-}
-
-
-private bool isIdentChar(char ch) {
-    return isAlpha(ch) || (ch == '-') || (ch == '_');
-}
-
-/// parse css identifier
-private string parseIdent(ref string src) {
-    int pos = 0;
-    for ( ; pos < src.length; pos++) {
-        if (!src[pos].isIdentChar)
-            break;
-    }
-    if (!pos)
-        return null;
-    string res = src[0 .. pos];
-    src.skip(pos);
-    src.skipSpaces;
-    return res;
-}
-
-private bool skipChar(ref string src, char ch) {
-    src.skipSpaces;
-    if (src.peek == ch) {
-        src.skip;
-        src.skipSpaces;
-        return true;
-    }
-    return false;
-}
-
-private string replaceChar(string s, char from, char to) {
-    foreach(ch; s) {
-        if (ch == from) {
-            char[] buf;
-            foreach(c; s)
-                if (c == from)
-                    buf ~= to;
-                else
-                    buf ~= c;
-            return buf.dup;
-        }
-    }
-    return s;
-}
-
-/// remove trailing _ from string, e.g. "body_" -> "body"
-private string removeTrailingUnderscore(string s) {
-    if (s.endsWith("_"))
-        return s[0..$-1];
-    return s;
-}
-
-private int parseEnumItem(E)(ref string src, int defValue = -1) if (is(E == enum)) {
-    string ident = replaceChar(parseIdent(src), '-', '_');
-    foreach(member; EnumMembers!E) {
-        if (ident == removeTrailingUnderscore(member.to!string)) {
-            return member.to!int;
-        }
-    }
-    return defValue;
-}
-
-private CssDeclType parseCssDeclType(ref string src) {
-    int n = parseEnumItem!CssDeclType(src, -1);
-    if (n < 0)
-        return CssDeclType.unknown;
-    if (!skipChar(src, ':')) // no : after identifier
-        return CssDeclType.unknown;
-    return cast(CssDeclType)n;
-}
-
-private bool nextProperty(ref string str) {
-    int pos = 0;
-    for (; pos < str.length; pos++) {
-        char ch = str[pos];
-        if (ch == '}')
-            break;
-        if (ch == ';') {
-            pos++;
-            break;
-        }
-    }
-    str.skip(pos);
-    str.skipSpaces;
-    return !str.empty && str[0] != '}';
-}
-
-
-private int parseStandardColor(string ident) {
-    switch(ident) {
-        case "black": return 0x000000;
-        case "green": return 0x008000;
-        case "silver": return 0xC0C0C0;
-        case "lime": return 0x00FF00;
-        case "gray": return 0x808080;
-        case "olive": return 0x808000;
-        case "white": return 0xFFFFFF;
-        case "yellow": return 0xFFFF00;
-        case "maroon": return 0x800000;
-        case "navy": return 0x000080;
-        case "red": return 0xFF0000;
-        case "blue": return 0x0000FF;
-        case "purple": return 0x800080;
-        case "teal": return 0x008080;
-        case "fuchsia": return 0xFF00FF;
-        case "aqua": return 0x00FFFF;
-        default: return -1;
-    }
-}
-
-private bool parseColor(ref string src, ref CssValue value)
-{
-    value.type = CssValueType.unspecified;
-    value.value = 0;
-    if (!src.skipSpaces)
-        return false;
-    string ident = parseIdent(src);
-    if (!ident.empty) {
-        switch(ident) {
-            case "inherited":
-                value.type = CssValueType.inherited;
-                return true;
-            case "none":
-                return true;
-            default:
-                int v = parseStandardColor(ident);
-                if (v >= 0) {
-                    value.value = v;
-                    value.type = CssValueType.color;
-                    return true;
-                }
-                return false;
-        }
-    }
-    char ch = src[0];
-    if (ch == '#') {
-        // #rgb or #rrggbb colors
-        ch = src.skip;
-        int nDigits = 0;
-        for ( ; nDigits < src.length && parseHexDigit(src[nDigits]) != uint.max; nDigits++ ) {
-        }
-        if ( nDigits==3 ) {
-            int r = parseHexDigit( src[0] );
-            int g = parseHexDigit( src[1] );
-            int b = parseHexDigit( src[2] );
-            value.type = CssValueType.color;
-            value.value = (((r + r*16) * 256) | (g + g*16)) * 256 | (b + b*16);
-            src.skip(3);
-            return true;
-        } else if ( nDigits==6 ) {
-            int r = parseHexDigit( src[0] ) * 16;
-            r += parseHexDigit( src[1] );
-            int g = parseHexDigit( src[2] ) * 16;
-            g += parseHexDigit( src[3] );
-            int b = parseHexDigit( src[4] ) * 16;
-            b += parseHexDigit( src[5] );
-            value.type = CssValueType.color;
-            value.value = ((r * 256) | g) * 256 | b;
-            src.skip(6);
-            return true;
-        }
-    }
-    return false;
-}
-
-private bool parseLength(ref string src, ref CssValue value)
-{
-    value.type = CssValueType.unspecified;
-    value.value = 0;
-    src.skipSpaces;
-    string ident = parseIdent(src);
-    if (!ident.empty) {
-        switch(ident) {
-            case "inherited":
-                value.type = CssValueType.inherited;
-                return true;
-            default:
-                return false;
-        }
-    }
-    if (src.empty)
-        return false;
-    int n = 0;
-    char ch = src[0];
-    if (ch != '.') {
-        if (ch < '0' || ch > '9') {
-            return false; // not a number
-        }
-        while (ch >= '0' && ch <= '9') {
-            n = n*10 + (ch - '0');
-            ch = src.skip;
-            if (!ch)
-                break;
-        }
-    }
-    int frac = 0;
-    int frac_div = 1;
-    if (ch == '.') {
-        src.skip;
-        if (!src.empty) {
-            ch = src[0];
-            while (ch >= '0' && ch <= '9') {
-                frac = frac*10 + (ch - '0');
-                frac_div *= 10;
-                ch = src.skip;
-                if (!ch)
-                    break;
-            }
-        }
-    }
-    if (ch == '%') {
-        value.type = CssValueType.percent;
-        src.skip;
-    } else {
-        ident = parseIdent(src);
-        if (!ident.empty) {
-            switch(ident) {
-                case "em":
-                case "m": // for DML - cannot add suffix which starts from 'e'
-                    value.type = CssValueType.em; break;
-                case "pt": value.type = CssValueType.pt; break;
-                case "ex": value.type = CssValueType.ex; break;
-                case "px": value.type = CssValueType.px; break;
-                case "in": value.type = CssValueType.in_; break;
-                case "cm": value.type = CssValueType.cm; break;
-                case "mm": value.type = CssValueType.mm; break;
-                case "pc": value.type = CssValueType.pc; break;
-                default:
-                    return false;
-            }
-        } else {
-            value.type = CssValueType.px;
-        }
-    }
-    if ( value.type == CssValueType.px || value.type == CssValueType.percent )
-        value.value = n;                               // normal
-    else
-        value.value = n * 256 + 256 * frac / frac_div; // *256
-    return true;
-}
-
-private void appendItem(ref string[] list, ref char[] item) {
-    if (!item.empty) {
-        list ~= item.dup;
-        item.length = 0;
-    }
-}
-
-/// splits string like "Arial", Times New Roman, Courier;  into list, stops on ; and }
-/// returns true if at least one item added to list; moves str to new position
-bool splitPropertyValueList(ref string str, ref string[] list)
-{
-    int i=0;
-    char quote_char = 0;
-    char[] name;
-    bool last_space = false;
-    for (i=0; i < str.length; i++) {
-        char ch = str[i];
-        switch(ch) {
-            case '\'':
-            case '\"':
-                if (quote_char == 0) {
-                    if (!name.empty)
-                        appendItem(list, name);
-                    quote_char = ch;
-                } else if (quote_char == ch) {
-                    if (!name.empty)
-                        appendItem(list, name);
-                    quote_char = 0;
-                } else {
-                    // append char
-                    name ~= ch;
-                }
-                last_space = false;
-                break;
-            case ',':
-                {
-                    if (quote_char==0) {
-                        if (!name.empty)
-                            appendItem(list, name);
-                    } else {
-                        // inside quotation: append char
-                        name ~= ch;
-                    }
-                    last_space = false;
-                }
-                break;
-            case '\t':
-            case ' ':
-                {
-                    if (quote_char != 0)
-                        name ~= ch;
-                    last_space = true;
-                }
-                break;
-            case ';':
-            case '}':
-                if (quote_char==0) {
-                    if (!name.empty)
-                        appendItem(list, name);
-                    str = i < str.length ? str[i .. $] : null;
-                    return list.length > 0;
-                } else {
-                    // inside quotation: append char
-                    name ~= ch;
-                    last_space = false;
-                }
-                break;
-            default:
-                if (last_space && !name.empty && quote_char == 0)
-                    name ~= ' ';
-                name ~= ch;
-                last_space = false;
-                break;
-        }
-    }
-    if (!name.empty)
-        appendItem(list, name);
-    str = i < str.length ? str[i .. $] : null;
-    return list.length > 0;
-}
-
-unittest {
-    string src = "Arial, 'Times New Roman', \"Arial Black\", sans-serif; next-property: }";
-    string[] list;
-    assert(splitPropertyValueList(src, list));
-    assert(list.length == 4);
-    assert(list[0] == "Arial");
-    assert(list[1] == "Times New Roman");
-    assert(list[2] == "Arial Black");
-    assert(list[3] == "sans-serif");
-}
-
-/// joins list of items into comma separated string, each item in quotation marks
-string joinPropertyValueList(string[] list) {
-    if (list.empty)
-        return null;
-    char[] res;
-
-    for (int i = 0; i < list.length; i++) {
-        if (i > 0)
-            res ~= ", ";
-        res ~= "\"";
-        res ~= list[i];
-        res ~= "\"";
-    }
-
-    return res.dup;
-}
-
-unittest {
-    assert(joinPropertyValueList(["item1", "item 2"]) == "\"item1\", \"item 2\"");
-}
-
-
-private bool parseAttrValue(ref string str, ref string attrvalue)
-{
-    char[] buf;
-    int pos = 0;
-    if (!str.skipSpaces)
-        return false;
-    char ch = str[0];
-    if (ch == '\"') {
-        str.skip;
-        for ( ; pos < str.length && str[pos] != '\"'; pos++) {
-            if (pos >= 1000)
-                return false;
-        }
-        if (pos >= str.length || str[pos] != '\"')
-            return false;
-        buf ~= str[0 .. pos];
-        str.skip(pos + 1);
-        if (!str.skipSpaces)
-            return false;
-        if (str[0] != ']')
-            return false;
-        str.skip;
-        attrvalue = buf.dup;
-        return true;
-    } else {
-        for ( ; pos < str.length && str[pos] != ' ' && str[pos] != '\t' && str[pos] != ']'; pos++) {
-            if (pos >= 1000)
-                return false;
-        }
-        if (pos >= str.length || str[pos] != ']')
-            return false;
-        buf ~= str[0 .. pos];
-        str.skip(pos + 1);
-        attrvalue = buf.dup;
-        return true;
-    }
-}
-
-private CssSelectorRule parseAttr(ref string str, Document doc)
-{
-    CssSelectorRuleType st = CssSelectorRuleType.universal;
-    char ch = str[0];
-    if (ch == '.') {
-        // E.class
-        str.skip;
-        str.skipSpaces;
-        string attrvalue = parseIdent(str);
-        if (attrvalue.empty)
-            return null;
-        CssSelectorRule rule = new CssSelectorRule(CssSelectorRuleType.class_);
-        rule.setAttr(Attr.class_, attrvalue.toLower);
-        return rule;
-    } else if (ch == '#') {
-        // E#id
-        str.skip;
-        str.skipSpaces;
-        string attrvalue = parseIdent(str);
-        if (attrvalue.empty)
-            return null;
-        CssSelectorRule rule = new CssSelectorRule(CssSelectorRuleType.id);
-        rule.setAttr(Attr.id, attrvalue.toLower);
-        return rule;
-    } else if (ch != '[')
-        return null;
-    // [.....] rule
-    str.skip; // skip [
-    str.skipSpaces;
-    string attrname = parseIdent(str);
-    if (attrname.empty)
-        return null;
-    if (!str.skipSpaces)
-        return null;
-    string attrvalue = null;
-    ch = str[0];
-    if (ch == ']') {
-        // empty []
-        st = CssSelectorRuleType.attrset;
-        str.skip; // skip ]
-    } else if (ch == '=') {
-        str.skip; // skip =
-        if (!parseAttrValue(str, attrvalue))
-            return null;
-        st = CssSelectorRuleType.attreq;
-    } else if (ch == '~' && str.length > 1 && str[1] == '=') {
-        str.skip(2); // skip ~=
-        if (!parseAttrValue(str, attrvalue))
-            return null;
-        st = CssSelectorRuleType.attrhas;
-    } else if (ch == '|' && str.length > 1 && str[1] == '=') {
-        str.skip(2); // skip |=
-        if (!parseAttrValue(str, attrvalue))
-            return null;
-        st = CssSelectorRuleType.attrstarts;
-    } else {
-        return null;
-    }
-    CssSelectorRule rule = new CssSelectorRule(st);
-    attr_id id = doc.attrId(attrname);
-    rule.setAttr(id, attrvalue);
-    return rule;
-}
-
-/// Parse css properties declaration either in {} or w/o {} - e.g.  { width: 40%; margin-top: 3px } -- returns null if parse error occured or property list is empty
-CssDeclaration parseCssDeclaration(ref string src, bool mustBeInBrackets = true) {
-    if (!src.skipSpaces)
-        return null;
-    if (mustBeInBrackets && !skipChar(src, '{'))
-        return null; // decl must start with {
-    CssDeclaration res = new CssDeclaration();
-    for (;;) {
-        CssDeclType propId = parseCssDeclType(src);
-        if (src.empty)
-            break;
-        if (propId != CssDeclType.unknown) {
-            int n = -1;
-            string s = null;
-            switch(propId) with(CssDeclType) {
-                case display: n = parseEnumItem!CssDisplay(src, -1); break;
-                case white_space: n = parseEnumItem!CssWhiteSpace(src, -1); break;
-                case text_align: n = parseEnumItem!CssTextAlign(src, -1); break;
-                case text_align_last: n = parseEnumItem!CssTextAlign(src, -1); break;
-                case text_decoration: n = parseEnumItem!CssTextDecoration(src, -1); break;
-                case hyphenate:
-                case _webkit_hyphens: // -webkit-hyphens
-                case adobe_hyphenate: // adobe-hyphenate
-                case adobe_text_layout: // adobe-text-layout
-                    n = parseEnumItem!CssHyphenate(src, -1);
-                    break; // hyphenate
-                case color:
-                case background_color:
-                    CssValue v;
-                    if (parseColor(src, v)) {
-                        res.addLengthDecl(propId, v);
-                    }
-                    break;
-                case vertical_align: n = parseEnumItem!CssVerticalAlign(src, -1); break;
-                case font_family: // id families like serif, sans-serif
-                    string[] list;
-                    string[] faceList;
-                    if (splitPropertyValueList(src, list)) {
-                        foreach(item; list) {
-                            string name = item;
-                            int family = parseEnumItem!CssFontFamily(name, -1);
-                            if (family != -1) {
-                                // family name, e.g. sans-serif
-                                n = family;
-                            } else {
-                                faceList ~= item;
-                            }
-                        }
-                    }
-                    s = joinPropertyValueList(faceList);
-                    break;
-                case font_style: n = parseEnumItem!CssFontStyle(src, -1); break;
-                case font_weight:
-                    n = parseEnumItem!CssFontWeight(src, -1);
-                    if (n < 0) {
-                        CssValue value;
-                        if (parseLength(src, value)) {
-                            if (value.type == CssValueType.px) {
-                                if (value.value < 150)
-                                    n = CssFontWeight.fw_100;
-                                else if (value.value < 250)
-                                    n = CssFontWeight.fw_200;
-                                else if (value.value < 350)
-                                    n = CssFontWeight.fw_300;
-                                else if (value.value < 450)
-                                    n = CssFontWeight.fw_400;
-                                else if (value.value < 550)
-                                    n = CssFontWeight.fw_500;
-                                else if (value.value < 650)
-                                    n = CssFontWeight.fw_600;
-                                else if (value.value < 750)
-                                    n = CssFontWeight.fw_700;
-                                else if (value.value < 850)
-                                    n = CssFontWeight.fw_800;
-                                else
-                                    n = CssFontWeight.fw_900;
-                            }
-                        }
-                    }
-
-                    //n = parseEnumItem!Css(src, -1);
-                    break;
-                case text_indent:
-                    {
-                        // read length
-                        CssValue len;
-                        bool negative = false;
-                        if (src[0] == '-') {
-                            src.skip;
-                            negative = true;
-                        }
-                        if (parseLength(src, len)) {
-                            // read optional "hanging" flag
-                            src.skipSpaces;
-                            string attr = parseIdent(src);
-                            if (attr == "hanging")
-                                len.value = -len.value;
-                            res.addLengthDecl(propId, len);
-                        }
-                    }
-                    break;
-                case line_height:
-                case letter_spacing:
-                case font_size:
-                case width:
-                case height:
-                case margin_left:
-                case margin_right:
-                case margin_top:
-                case margin_bottom:
-                case padding_left:
-                case padding_right:
-                case padding_top:
-                case padding_bottom:
-                    // parse length
-                    CssValue value;
-                    if (parseLength(src, value))
-                        res.addLengthDecl(propId, value);
-                    break;
-                case margin:
-                case padding:
-                    //n = parseEnumItem!Css(src, -1);
-                    CssValue[4] len;
-                    int i;
-                    for (i = 0; i < 4; ++i)
-                        if (!parseLength(src, len[i]))
-                            break;
-                    if (i) {
-                        switch (i) {
-                            case 1:
-                                len[1] = len[0];
-                                goto case; /* fall through */
-                            case 2:
-                                len[2] = len[0];
-                                goto case; /* fall through */
-                            case 3:
-                                len[3] = len[1];
-                                break;
-                            default:
-                                break;
-                        }
-                        if (propId == margin) {
-                            res.addLengthDecl(margin_left, len[0]);
-                            res.addLengthDecl(margin_top, len[1]);
-                            res.addLengthDecl(margin_right, len[2]);
-                            res.addLengthDecl(margin_bottom, len[3]);
-                        } else {
-                            res.addLengthDecl(padding_left, len[0]);
-                            res.addLengthDecl(padding_top, len[1]);
-                            res.addLengthDecl(padding_right, len[2]);
-                            res.addLengthDecl(padding_bottom, len[3]);
-                        }
-                    }
-                    break;
-                case page_break_before:
-                case page_break_inside:
-                case page_break_after:
-                    n = parseEnumItem!CssPageBreak(src, -1);
-                    break;
-                case list_style:
-                    //n = parseEnumItem!Css(src, -1);
-                    break;
-                case list_style_type: n = parseEnumItem!CssListStyleType(src, -1); break;
-                case list_style_position: n = parseEnumItem!CssListStylePosition(src, -1); break;
-                case list_style_image:
-                    //n = parseEnumItem!CssListStyleImage(src, -1);
-                    break;
-                default:
-                    break;
-            }
-            if (n >= 0 || !s.empty)
-                res.addDecl(propId, n, s);
-        }
-        if (!nextProperty(src))
-            break;
-    }
-    if (mustBeInBrackets && !skipChar(src, '}'))
-        return null;
-    if (res.empty)
-        return null;
-    return res;
-}
-
-/// parse Css selector, return selector object if parsed ok, null if error occured
-CssSelector parseCssSelector(ref string str, Document doc) {
-    if (str.empty)
-        return null;
-    CssSelector res = new CssSelector();
-    for (;;) {
-        if (!str.skipSpaces)
-            return null;
-        char ch = str[0];
-        string ident = parseIdent(str);
-        if (ch == '*') { // universal selector
-            str.skip;
-            str.skipSpaces;
-            res.id = 0;
-        }  else if (ch == '.') { // classname follows
-            res.id = 0;
-            // will be parsed as attribute
-        }  else if (!ident.empty) {
-            // ident
-            res.id = doc.tagId(ident);
-        } else {
-            return null;
-        }
-        if (!str.skipSpaces)
-            return null;
-        ch = str[0];
-        if (ch == ',' || ch == '{')
-            return res;
-        // one or more attribute rules
-        bool attr_rule = false;
-        while (ch == '[' || ch == '.' || ch == '#') {
-            CssSelectorRule rule = parseAttr(str, doc);
-            if (!rule)
-                return null;
-            res.insertRuleStart(rule); //insertRuleAfterStart
-            ch = str.skipSpaces;
-            attr_rule = true;
-            //continue;
-        }
-        // element relation
-        if (ch == '>') {
-            str.skip;
-            CssSelectorRule rule = new CssSelectorRule(CssSelectorRuleType.parent);
-            rule.id = res.id;
-            res.insertRuleStart(rule);
-            res.id = 0;
-            continue;
-        } else if (ch == '+') {
-            str.skip;
-            CssSelectorRule rule = new CssSelectorRule(CssSelectorRuleType.predecessor);
-            rule.id = res.id;
-            res.insertRuleStart(rule);
-            res.id = 0;
-            continue;
-        } else if (ch.isAlpha) {
-            CssSelectorRule rule = new CssSelectorRule(CssSelectorRuleType.ancessor);
-            rule.id = res.id;
-            res.insertRuleStart(rule);
-            res.id = 0;
-            continue;
-        }
-        if (!attr_rule)
-            return null;
-        else if (str.length > 0 && (str[0] == ',' || str[0] == '{'))
-            return res;
-    }
-}
-
-/// skips until } or end of string, returns true if some characters left in string
-private bool skipUntilEndOfRule(ref string str)
-{
-    while (str.length && str[0] != '}')
-        str.skip;
-    if (str.peek == '}')
-        str.skip;
-    return !str.empty;
-}
-
-
-unittest {
-    Document doc = new Document();
-    string str;
-    str = "body { width: 50% }";
-    assert(parseCssSelector(str, doc) !is null);
-    assert(parseCssDeclaration(str, true) !is null);
-    str = "body > p { font-family: sans-serif }";
-    assert(parseCssSelector(str, doc) !is null);
-    assert(parseCssDeclaration(str, true) !is null);
-    str = ".myclass + div { }";
-    assert(parseCssSelector(str, doc) !is null);
-    assert(parseCssDeclaration(str, true) is null); // empty property decl
-    destroy(doc);
-}
-
-/// parse stylesheet text
-bool parseStyleSheet(StyleSheet sheet, Document doc, string str) {
-    bool res = false;
-    for(;;) {
-        if (!str.skipSpaces)
-            break;
-        CssSelector[] selectors;
-        for(;;) {
-            CssSelector selector = parseCssSelector(str, doc);
-            if (!selector)
-                break;
-            selectors ~= selector;
-            str.skipChar(',');
-        }
-        if (selectors.length) {
-            if (CssDeclaration decl = parseCssDeclaration(str, true)) {
-                foreach(item; selectors) {
-                    item.setDeclaration(decl);
-                    sheet.add(item);
-                    res = true;
-                }
-            }
-        }
-        if (!skipUntilEndOfRule(str))
-            break;
-    }
-    return res;
-}
-
-unittest {
-    string src = q{
-        body { width: 50%; color: blue }
-        body > div, body > section {
-            /* some comment
-               goes here */
-            font-family: serif;
-            background-color: yellow;
-        }
-        section {
-            margin-top: 5px
-        }
-    };
-    Document doc = new Document();
-    StyleSheet sheet = new StyleSheet();
-    assert(parseStyleSheet(sheet, doc, src));
-    assert(sheet.length == 2);
-    // check appending of additional source text
-    assert(parseStyleSheet(sheet, doc, "pre { white-space: pre }"));
-    assert(sheet.length == 3);
-    destroy(doc);
-}
-
-unittest {
-    Document doc = new Document();
-    StyleSheet sheet = new StyleSheet();
-    assert(parseStyleSheet(sheet, doc, "* { color: #aaa }"));
-    assert(sheet.length == 1);
-    assert(parseStyleSheet(sheet, doc, "div, p { display: block }"));
-    assert(sheet.length == 3);
-    // check appending of additional source text
-    assert(parseStyleSheet(sheet, doc, "pre { white-space: pre }"));
-    assert(sheet.length == 4);
-    assert(parseStyleSheet(sheet, doc, "pre { font-size: 120% }"));
-    assert(sheet.length == 5);
-    destroy(doc);
-}
diff --git a/src/dlangui/core/dom.d b/src/dlangui/core/dom.d
deleted file mode 100644
index 5ab667c2..00000000
--- a/src/dlangui/core/dom.d
+++ /dev/null
@@ -1,456 +0,0 @@
-// Written in the D programming language.
-
-/**
-This module contains implementation DOM - document object model.
-
-Port of CoolReader Engine written in C++.
-
-Synopsis:
-
-----
-import dlangui.core.dom;
-
-----
-
-Copyright: Vadim Lopatin, 2015
-License:   Boost License 1.0
-Authors:   Vadim Lopatin, coolreader.org@gmail.com
-*/
-module dlangui.core.dom;
-
-import dlangui.core.collections;
-
-import std.traits;
-import std.conv : to;
-import std.string : startsWith, endsWith;
-import std.array : empty;
-import std.algorithm : equal;
-
-// Namespace, element tag and attribute names are stored as numeric ids for better performance and lesser memory consumption.
-
-/// id type for interning namespaces
-alias ns_id = short;
-/// id type for interning element names
-alias elem_id = int;
-/// id type for interning attribute names
-alias attr_id = short;
-
-
-/// Base class for DOM nodes
-class Node {
-private:
-    Node _parent;
-    Document _document;
-public:
-    /// returns parent node
-    @property Node parent() { return _parent; }
-    /// returns document node
-    @property Document document() { return _document; }
-
-    /// return element tag id
-    @property elem_id id() { return 0; }
-    /// return element namespace id
-    @property ns_id nsid() { return 0; }
-    /// return element tag name
-    @property string name() { return document.tagName(id); }
-    /// return element namespace name
-    @property string nsname() { return document.nsName(nsid); }
-
-    // node properties
-
-    /// returns true if node is text
-    @property bool isText() { return false; }
-    /// returns true if node is element
-    @property bool isElement() { return false; }
-    /// returns true if node has child nodes
-    @property bool hasChildren() { return false; }
-
-    // attributes
-
-    /// returns attribute count
-    @property int attrCount() { return 0; }
-
-    /// get attribute by index
-    Attribute attr(int index) { return null; }
-    /// get attribute by namespace and attribute ids
-    Attribute attr(ns_id nsid, attr_id attrid) { return null; }
-    /// get attribute by namespace and attribute names
-    Attribute attr(string nsname, string attrname) { return attr(_document.nsId(nsname), _document.attrId(attrname)); }
-
-    /// set attribute value by namespace and attribute ids
-    Attribute setAttr(ns_id nsid, attr_id attrid, string value) { assert(false); }
-    /// set attribute value by namespace and attribute names
-    Attribute setAttr(string nsname, string attrname, string value) { return setAttr(_document.nsId(nsname), _document.attrId(attrname), value); }
-    /// get attribute value by namespace and attribute ids
-    string attrValue(ns_id nsid, attr_id attrid) { return null; }
-    /// get attribute value by namespace and attribute ids
-    string attrValue(string nsname, string attrname) { return attrValue(_document.nsId(nsname), _document.attrId(attrname)); }
-    /// returns true if node has attribute with specified name
-    bool hasAttr(string attrname) {
-        return hasAttr(document.attrId(attrname));
-    }
-    /// returns true if node has attribute with specified id
-    bool hasAttr(attr_id attrid) {
-        if (Attribute a = attr(Ns.any, attrid))
-            return true;
-        return false;
-    }
-
-    // child nodes
-
-    /// returns child node count
-    @property int childCount() { return 0; }
-    /// returns child node by index
-    @property Node child(int index) { return null; }
-    /// returns first child node
-    @property Node firstChild() { return null; }
-    /// returns last child node
-    @property Node lastChild() { return null; }
-
-    /// find child node, return its index if found, -1 if not found or not child of this node
-    int childIndex(Node child) { return -1; }
-    /// return node index in parent's child node collection, -1 if not found
-    @property int index() { return _parent ? _parent.childIndex(this) : -1; }
-
-    /// returns child node by index and optionally compares its tag id, returns null if child with this index is not an element or id does not match
-    Element childElement(int index, elem_id id = 0) {
-        Element res = cast(Element)child(index);
-        if (res && (id == 0 || res.id == id))
-            return res;
-        return null;
-    }
-
-    /// append text child
-    Node appendText(dstring s, int index = -1) { assert(false); }
-    /// append element child - by namespace and tag names
-    Node appendElement(string ns, string tag, int index = -1) { return appendElement(_document.nsId(ns), _document.tagId(tag), index); }
-    /// append element child - by namespace and tag ids
-    Node appendElement(ns_id ns, elem_id tag, int index = -1) { assert(false); }
-
-    // Text methods
-
-    /// node text
-    @property dstring text() { return null; }
-    /// ditto
-    @property void text(dstring s) { }
-
-}
-
-/// Text node
-class Text : Node {
-private:
-    dstring _text;
-    this(Document doc, dstring text = null) {
-        _document = doc;
-        _text = text;
-    }
-public:
-    /// node text
-    override @property dstring text() { return _text; }
-    /// ditto
-    override @property void text(dstring s) { _text = s; }
-}
-
-/// Element node
-class Element : Node {
-private:
-    Collection!Node _children;
-    Collection!Attribute _attrs;
-    elem_id _id; // element tag id
-    ns_id _ns; // element namespace id
-
-    this(Document doc, ns_id ns, elem_id id) {
-        _document = doc;
-        _ns = ns;
-        _id = id;
-    }
-public:
-
-    /// return element tag id
-    override @property elem_id id() { return _id; }
-    /// return element namespace id
-    override @property ns_id nsid() { return _ns; }
-
-    // Attributes
-
-    /// returns attribute count
-    override @property int attrCount() { return cast(int)_attrs.length; }
-
-    /// get attribute by index
-    override Attribute attr(int index) { return index >= 0 && index < _attrs.length ? _attrs[index] : null; }
-    /// get attribute by namespace and attribute ids
-    override Attribute attr(ns_id nsid, attr_id attrid) {
-        foreach (a; _attrs)
-            if ((nsid == Ns.any || nsid == a.nsid) && attrid == a.id)
-                return a;
-        return null;
-    }
-    /// get attribute by namespace and attribute names
-    override Attribute attr(string nsname, string attrname) { return attr(_document.nsId(nsname), _document.attrId(attrname)); }
-
-    /// set attribute value by namespace and attribute ids
-    override Attribute setAttr(ns_id nsid, attr_id attrid, string value) {
-        Attribute a = attr(nsid, attrid);
-        if (!a) {
-            a = new Attribute(this, nsid, attrid, value);
-            _attrs.add(a);
-        } else {
-            a.value = value;
-        }
-        return a;
-    }
-    /// set attribute value by namespace and attribute names
-    override Attribute setAttr(string nsname, string attrname, string value) { return setAttr(_document.nsId(nsname), _document.attrId(attrname), value); }
-    /// get attribute value by namespace and attribute ids
-    override string attrValue(ns_id nsid, attr_id attrid) {
-        if (Attribute a = attr(nsid, attrid))
-            return a.value;
-        return null;
-    }
-    /// get attribute value by namespace and attribute ids
-    override string attrValue(string nsname, string attrname) { return attrValue(_document.nsId(nsname), _document.attrId(attrname)); }
-
-    // child nodes
-
-    /// returns child node count
-    override @property int childCount() { return cast(int)_children.length; }
-    /// returns child node by index
-    override @property Node child(int index) { return index >= 0 && index < _children.length ? _children[index] : null; }
-    /// returns first child node
-    override @property Node firstChild() { return _children.length > 0 ? _children[0] : null; }
-    /// returns last child node
-    override @property Node lastChild() { return _children.length > 0 ? _children[_children.length - 1] : null; }
-    /// find child node, return its index if found, -1 if not found or not child of this node
-    override int childIndex(Node child) {
-        for (int i = 0; i < _children.length; i++)
-            if (child is _children[i])
-                return i;
-        return -1;
-    }
-
-    /// append text child
-    override Node appendText(dstring s, int index = -1) {
-        Node item = document.createText(s);
-        _children.add(item, index >= 0 ? index : size_t.max);
-        return item;
-    }
-    /// append element child - by namespace and tag ids
-    override Node appendElement(ns_id ns, elem_id tag, int index = -1) {
-        Node item = document.createElement(ns, tag);
-        _children.add(item, index >= 0 ? index : size_t.max);
-        return item;
-    }
-    /// append element child - by namespace and tag names
-    override Node appendElement(string ns, string tag, int index = -1) { return appendElement(_document.nsId(ns), _document.tagId(tag), index); }
-}
-
-/// Document node
-class Document : Element {
-public:
-    this() {
-        super(null, 0, 0);
-        _elemIds.initialize!Tag();
-        _attrIds.initialize!Attr();
-        _nsIds.initialize!Ns();
-        _document = this;
-    }
-    /// create text node
-    Text createText(dstring text) {
-        return new Text(this, text);
-    }
-    /// create element node by namespace and tag ids
-    Element createElement(ns_id ns, elem_id tag) {
-        return new Element(this, ns, tag);
-    }
-    /// create element node by namespace and tag names
-    Element createElement(string ns, string tag) {
-        return new Element(this, nsId(ns), tagId(tag));
-    }
-
-    // Ids
-
-    /// return name for element tag id
-    string tagName(elem_id id) {
-        return _elemIds[id];
-    }
-    /// return name for namespace id
-    string nsName(ns_id id) {
-        return _nsIds[id];
-    }
-    /// return name for attribute id
-    string attrName(ns_id id) {
-        return _attrIds[id];
-    }
-    /// get id for element tag name
-    elem_id tagId(string s) {
-        if (s.empty)
-            return 0;
-        return _elemIds.intern(s);
-    }
-    /// get id for namespace name
-    ns_id nsId(string s) {
-        if (s.empty)
-            return 0;
-        return _nsIds.intern(s);
-    }
-    /// get id for attribute name
-    attr_id attrId(string s) {
-        if (s.empty)
-            return 0;
-        return _attrIds.intern(s);
-    }
-private:
-    IdentMap!(elem_id) _elemIds;
-    IdentMap!(attr_id) _attrIds;
-    IdentMap!(ns_id) _nsIds;
-}
-
-class Attribute {
-private:
-    attr_id _id;
-    ns_id _nsid;
-    string _value;
-    Node _parent;
-    this(Node parent, ns_id nsid, attr_id id, string value) {
-        _parent = parent;
-        _nsid = nsid;
-        _id = id;
-        _value = value;
-    }
-public:
-    /// Parent element which owns this attribute
-    @property Node parent() { return _parent; }
-    /// Parent element document
-    @property Document document() { return _parent.document; }
-
-    /// get attribute id
-    @property attr_id id() { return _id; }
-    /// get attribute namespace id
-    @property ns_id nsid() { return _nsid; }
-    /// get attribute tag name
-    @property string name() { return document.tagName(_id); }
-    /// get attribute namespace name
-    @property string nsname() { return document.nsName(_nsid); }
-
-    /// get attribute value
-    @property string value() { return _value; }
-    /// set attribute value
-    @property void value(string s) { _value = s; }
-}
-
-/// remove trailing _ from string, e.g. "body_" -> "body"
-private string removeTrailingUnderscore(string s) {
-    if (s.endsWith("_"))
-        return s[0..$-1];
-    return s;
-}
-
-/// String identifier to Id map - for interning strings
-struct IdentMap(ident_t) {
-    /// initialize with elements of enum
-    void initialize(E)() if (is(E == enum)) {
-        foreach(member; EnumMembers!E) {
-            static if (member.to!int > 0) {
-                //pragma(msg, "interning string '" ~ removeTrailingUnderscore(member.to!string) ~ "' for " ~ E.stringof);
-                intern(removeTrailingUnderscore(member.to!string), member);
-            }
-        }
-    }
-    /// intern string - return ID assigned for it
-    ident_t intern(string s, ident_t id = 0) {
-        if (auto p = s in _stringToId)
-            return *p;
-        ident_t res;
-        if (id > 0) {
-            if (_nextId <= id)
-                _nextId = cast(ident_t)(id + 1);
-            res = id;
-        } else {
-           res = _nextId++;
-        }
-        _idToString[res] = s;
-        _stringToId[s] = res;
-        return res;
-    }
-    /// lookup id for string, return 0 if string is not found
-    ident_t opIndex(string s) {
-        if (s.empty)
-            return 0;
-        if (auto p = s in _stringToId)
-            return *p;
-        return 0;
-    }
-    /// lookup name for id, return null if not found
-    string opIndex(ident_t id) {
-        if (!id)
-            return null;
-        if (auto p = id in _idToString)
-            return *p;
-        return null;
-    }
-private:
-    string[ident_t] _idToString;
-    ident_t[string] _stringToId;
-    ident_t _nextId = 1;
-}
-
-/// standard tags
-enum Tag : elem_id {
-    none,
-    body_,
-    pre,
-    div,
-    span
-}
-
-/// standard attributes
-enum Attr : attr_id {
-    none,
-    id,
-    class_,
-    style
-}
-
-/// standard namespaces
-enum Ns : ns_id {
-    any = -1,
-    none = 0,
-    xmlns,
-    xs,
-    xlink,
-    l,
-    xsi
-}
-
-unittest {
-    import std.algorithm : equal;
-    //import std.stdio;
-    IdentMap!(elem_id) map;
-    map.initialize!Tag();
-    //writeln("running DOM unit test");
-    assert(map["pre"] == Tag.pre);
-    assert(map["body"] == Tag.body_);
-    assert(map[Tag.div].equal("div"));
-
-    Document doc = new Document();
-    auto body_ = doc.appendElement(null, "body");
-    assert(body_.id == Tag.body_);
-    assert(body_.name.equal("body"));
-    auto div = body_.appendElement(null, "div");
-    assert(body_.childCount == 1);
-    assert(div.id == Tag.div);
-    assert(div.name.equal("div"));
-    auto t1 = div.appendText("Some text"d);
-    assert(div.childCount == 1);
-    assert(div.child(0).text.equal("Some text"d));
-    auto t2 = div.appendText("Some more text"d);
-    assert(div.childCount == 2);
-    assert(div.childIndex(t1) == 0);
-    assert(div.childIndex(t2) == 1);
-
-    div.setAttr(Ns.none, Attr.id, "div_id");
-    assert(div.attrValue(Ns.none, Attr.id).equal("div_id"));
-
-    destroy(doc);
-}
-
diff --git a/src/dlangui/dom/cssparser.d b/src/dlangui/dom/cssparser.d
deleted file mode 100644
index 69f6392d..00000000
--- a/src/dlangui/dom/cssparser.d
+++ /dev/null
@@ -1,1277 +0,0 @@
-module dom.cssparser;
-
-/**
-Before sending the input stream to the tokenizer, implementations must make the following code point substitutions:
-    * Replace any U+000D CARRIAGE RETURN (CR) code point, U+000C FORM FEED (FF) code point, or pairs of U+000D CARRIAGE RETURN (CR) followed by U+000A LINE FEED (LF) by a single U+000A LINE FEED (LF) code point.
-    * Replace any U+0000 NULL code point with U+FFFD REPLACEMENT CHARACTER.
-*/
-char[] preProcessCSS(char[] src) {
-    char[] res;
-    res.assumeSafeAppend();
-    int p = 0;
-    bool last0D = false;
-    foreach(ch; src) {
-        if (ch == 0) {
-            // append U+FFFD 1110xxxx 10xxxxxx 10xxxxxx == EF BF BD
-            res ~= 0xEF;
-            res ~= 0xBF;
-            res ~= 0xBD;
-        } else if (ch == 0x0D || ch == 0x0C) {
-            res ~= 0x0A;
-        } else if (ch == 0x0A) {
-            if (!last0D)
-                res ~= 0x0A;
-        } else {
-            res ~= ch;
-        }
-        last0D = (ch == 0x0D);
-    }
-    return res;
-}
-
-struct CSSImportRule {
-    /// start position - byte offset of @import
-    size_t startPos;
-    /// end position - byte offset of next char after closing ';'
-    size_t endPos;
-    /// url of CSS to import
-    string url;
-    /// content of downloaded URL to apply in place of rule
-    string content;
-}
-
-enum CSSTokenType : ubyte {
-    eof, // end of file
-    delim, // delimiter (may be unknown token or error)
-    comment, /* some comment */
-    //newline, // any of \n \r\n \r \f
-    whitespace, // space, \t, newline
-    ident, // identifier
-    url, // url()
-    badUrl, // url() which is bad
-    func, // function(
-    str, // string '' or ""
-    badStr, // string '' or "" ended with newline character
-    hashToken, // #
-    prefixMatch, // ^=
-    suffixMatch, // $=
-    substringMatch, // *=
-    includeMatch, // ~=
-    dashMatch, // |=
-    column, // ||
-    parentOpen, // (
-    parentClose, // )
-    squareOpen, // [
-    squareClose, // ]
-    curlyOpen, // {
-    curlyClose, // }
-    comma, // ,
-    colon, // :
-    semicolon, // ;
-    number, // +12345.324e-3
-    dimension, // 1.23px  -- number with dimension
-    cdo, // <!--
-    cdc, // -->
-    atKeyword, // @someKeyword -- tokenText will contain keyword w/o @ prefix
-    unicodeRange, // U+XXX-XXX
-}
-
-struct CSSToken {
-    CSSTokenType type;
-    string text;
-    string dimensionUnit;
-    union {
-        struct {
-            long intValue = 0; /// for number and dimension
-            double doubleValue = 0; /// for number and dimension
-            bool typeFlagInteger; /// for number and dimension - true if number is integer, false if double
-        }
-        struct {
-            uint unicodeRangeStart; /// for unicodeRange (initialized to 0 via intValue=0)
-            uint unicodeRangeEnd; /// for unicodeRange (initialized to 0 via intValue=0)
-        }
-        bool typeFlagId; // true if identifier is valid ID
-    }
-}
-
-int decodeHexDigit(char ch) {
-    if (ch >= 'a' && ch <= 'f')
-        return (ch - 'a') + 10;
-    if (ch >= 'A' && ch <= 'F')
-        return (ch - 'A') + 10;
-    if (ch >= '0' && ch <= '9')
-        return (ch - '0');
-    return -1;
-}
-
-bool isCSSWhiteSpaceChar(char ch) {
-    return ch == ' ' || ch == '\t' || ch == 0x0C || ch == 0x0D || ch == 0x0A;
-}
-
-// returns true if code point is letter, underscore or non-ascii
-bool isCSSNameStart(char ch) {
-    return ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch & 0x80) > 0 || ch == '_');
-}
-
-bool isCSSNonPrintable(char ch) {
-    if (ch >= 0 && ch <= 8)
-        return true;
-    if (ch == 0x0B || ch == 0x7F)
-        return true;
-    if (ch >= 0x0E && ch <= 0x1F)
-        return true;
-    return false;
-}
-// This section describes how to check if two code points are a valid escape
-bool isCSSValidEscSequence(char ch, char ch2) {
-    //If the first code point is not U+005D REVERSE SOLIDUS (\), return false.
-    if (ch != '\\')
-        return false;
-    if (ch2 == '\r' || ch2 == '\n')
-        return false;
-    return true;
-}
-
-struct CSSTokenizer {
-    /// CSS source code (utf-8)
-    char[] src;
-    /// current token type
-    CSSTokenType tokenType;
-    /// current token start byte offset
-    size_t tokenStart;
-    /// current token end byte offset
-    size_t tokenEnd;
-    char[] tokenText;
-    char[] dimensionUnit;
-    bool tokenTypeFlagId; // true if identifier is valid ID
-    bool tokenTypeInteger; // for number and dimension - true if number is integer, false if double
-    long tokenIntValue; // for number and dimension
-    double tokenDoubleValue; // for number and dimension
-    uint unicodeRangeStart = 0; // for unicodeRange
-    uint unicodeRangeEnd = 0; // for unicodeRange
-    void start(string _src) {
-        src = _src.dup;
-        tokenStart = tokenEnd = 0;
-        tokenText.length = 1000;
-        tokenText.assumeSafeAppend;
-        dimensionUnit.length = 1000;
-        dimensionUnit.assumeSafeAppend;
-    }
-    bool eof() {
-        return tokenEnd >= src.length;
-    }
-    /**
-      Skip whitespace; return true if at least one whitespace char is skipped; move tokenEnd position
-      tokenType will be set to newline if any newline character found, otherwise - to whitespace
-    */
-    bool skipWhiteSpace() {
-        bool skipped = false;
-        tokenType = CSSTokenType.whitespace;
-        for (;;) {
-            if (tokenEnd >= src.length) {
-                return false;
-            }
-            char ch = src.ptr[tokenEnd];
-            if (ch == '\r' || ch == '\n' || ch == 0x0C) {
-                tokenEnd++;
-                //tokenType = CSSTokenType.newline;
-                skipped = true;
-            } if (ch == ' ' || ch == '\t') {
-                tokenEnd++;
-                skipped = true;
-            } else if (ch == 0xEF && tokenEnd  + 2 < src.length && src.ptr[tokenEnd + 1] == 0xBF && src.ptr[tokenEnd + 2] == 0xBD) {
-                // U+FFFD 1110xxxx 10xxxxxx 10xxxxxx == EF BF BD
-                tokenEnd++;
-                skipped = true;
-            } else {
-                return skipped;
-            }
-        }
-    }
-
-    private dchar parseEscape(ref size_t p) {
-        size_t pos = p + 1;
-        if (pos >= src.length)
-            return cast(dchar)0xFFFFFFFF; // out of bounds
-        char ch = src.ptr[pos];
-        pos++;
-        if (ch == '\r' || ch == '\n' || ch == 0x0C)
-            return cast(dchar)0xFFFFFFFF; // unexpected newline: invalid esc sequence
-        int hex = decodeHexDigit(ch);
-        if (hex >= 0) {
-            dchar res = hex;
-            int count = 1;
-            while (count < 6) {
-                if (pos >= src.length)
-                    break;
-                ch = src.ptr[pos];
-                hex = decodeHexDigit(ch);
-                if (hex < 0)
-                    break;
-                res = (res << 4) | hex;
-                pos++;
-                count++;
-            }
-            if (isCSSWhiteSpaceChar(ch))
-                pos++;
-            p = pos;
-            return res;
-        } else {
-            // not a hex: one character is escaped
-            p = pos;
-            return ch;
-        }
-    }
-    private void appendEscapedIdentChar(dchar ch) {
-        if (ch < 0x80) {
-            // put as is
-            tokenText ~= cast(char)ch;
-        } else {
-            // UTF-8 encode
-            import std.utf : encode, isValidDchar;
-            char[4] buf;
-            size_t chars = isValidDchar(ch) ? encode(buf, ch) : 0;
-            if (chars)
-                tokenText ~= buf[0 .. chars];
-            else
-                tokenText ~= '?'; // replacement for invalid character
-        }
-    }
-
-    /** Consume identifier at current position, append it to tokenText */
-    bool consumeIdent(ref char[] tokenText) {
-        size_t p = tokenEnd;
-        char ch = src.ptr[p];
-        bool hasHyphen = false;
-        if (ch == '-') {
-            p++;
-            if (p >= src.length)
-                return false; // eof
-            hasHyphen = true;
-            ch = src.ptr[p];
-        }
-        if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_' || ch >= 0x80) {
-            if (hasHyphen)
-                tokenText ~= '-';
-            tokenText ~= ch;
-            p++;
-        } else if (ch == '\\') {
-            dchar esc = parseEscape(p);
-            if (esc == 0xFFFFFFFF)
-                return false; // invalid esc
-            // encode to UTF-8
-            appendEscapedIdentChar(esc);
-        } else {
-            return false;
-        }
-        for (;;) {
-            if (p >= src.length)
-                break;
-            ch = src.ptr[p];
-            if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')  || (ch >= '0' && ch <= '9') || ch == '_'  || ch == '-' || ch >= 0x80) {
-                tokenText ~= ch;
-                p++;
-            } else if (ch == '\\') {
-                dchar esc = parseEscape(p);
-                if (esc == 0xFFFFFFFF)
-                    break; // invalid esc
-                // encode to UTF-8
-                appendEscapedIdentChar(esc);
-            } else {
-                break;
-            }
-        }
-        tokenEnd = p;
-        return true;
-    }
-
-    /**
-      Parse identifier.
-      Returns true if identifier is parsed. tokenText will contain identifier text.
-    */
-    bool parseIdent() {
-        if (!isIdentStart(tokenEnd))
-            return false;
-        if (consumeIdent(tokenText)) {
-            tokenType = tokenType.ident;
-            return true;
-        }
-        return false;
-    }
-
-    /** returns true if current tokenEnd position is identifier start */
-    bool isIdentStart(size_t p) {
-        if (p >= src.length)
-            return false;
-        char ch = src.ptr[p];
-        if (isCSSNameStart(ch))
-            return true;
-        if (ch == '-') {
-            //If the second code point is a name-start code point or the second and third code points are a valid escape, return true. Otherwise, return false.
-            p++;
-            if (p >= src.length)
-                return false;
-            ch = src.ptr[p];
-            if (isCSSNameStart(ch))
-                return true;
-        }
-        if (ch == '\\') {
-            p++;
-            if (p >= src.length)
-                return false;
-            char ch2 = src.ptr[p];
-            return isCSSValidEscSequence(ch, ch2);
-        }
-        return false;
-    }
-
-    /**
-    Parse identifier.
-    Returns true if identifier is parsed. tokenText will contain identifier text.
-    */
-    bool parseNumber() {
-        tokenTypeInteger = true;
-        tokenIntValue = 0;
-        tokenDoubleValue = 0;
-        size_t p = tokenEnd;
-        char ch = src.ptr[p];
-        int numberSign = 1;
-        int exponentSign = 1;
-        bool hasPoint = false;
-        ulong intValue = 0;
-        ulong afterPointValue = 0;
-        ulong exponentValue = 0;
-        int beforePointDigits = 0;
-        int afterPointDigits = 0;
-        int exponentDigits = 0;
-        if (ch == '+' || ch == '-') {
-            if (ch == '-')
-                numberSign = -1;
-            tokenText ~= ch;
-            p++;
-            if (p >= src.length)
-                return false; // eof
-            ch = src.ptr[p];
-        }
-        // append digits before point
-        while (ch >= '0' && ch <= '9') {
-            tokenText ~= ch;
-            intValue = intValue * 10 + (ch - '0');
-            beforePointDigits++;
-            p++;
-            if (p >= src.length) {
-                ch = 0;
-                break;
-            }
-            ch = src.ptr[p];
-        }
-        // check for point
-        if (ch == '.') {
-            hasPoint = true;
-            tokenText ~= ch;
-            p++;
-            if (p >= src.length)
-                return false; // eof
-            ch = src.ptr[p];
-        }
-        // append digits after point
-        while (ch >= '0' && ch <= '9') {
-            tokenText ~= ch;
-            afterPointValue = afterPointValue * 10 + (ch - '0');
-            afterPointDigits++;
-            p++;
-            if (p >= src.length) {
-                ch = 0;
-                break;
-            }
-            ch = src.ptr[p];
-        }
-        if (!beforePointDigits && !afterPointDigits) {
-            if (tokenText.length)
-                tokenText.length = 0;
-            return false; // not a number
-        }
-        if (ch == 'e' || ch == 'E') {
-            char nextCh = p + 1 < src.length ? src.ptr[p + 1] : 0;
-            char nextCh2 = p + 2 < src.length ? src.ptr[p + 2] : 0;
-            int skip = 1;
-            if (nextCh == '+' || nextCh == '-') {
-                if (nextCh == '-')
-                    exponentSign = -1;
-                skip = 2;
-                nextCh = nextCh2;
-            }
-            if (nextCh >= '0' && nextCh <= '9') {
-                tokenText ~= src.ptr[p .. p + skip];
-                p += skip;
-                ch = nextCh;
-                // append exponent digits
-                while (ch >= '0' && ch <= '9') {
-                    tokenText ~= ch;
-                    exponentValue = exponentValue * 10 + (ch - '0');
-                    exponentDigits++;
-                    p++;
-                    if (p >= src.length) {
-                        ch = 0;
-                        break;
-                    }
-                    ch = src.ptr[p];
-                }
-            }
-        }
-        tokenType = CSSTokenType.number;
-        tokenEnd = p;
-        if (exponentDigits || afterPointDigits) {
-            // parsed floating point
-            tokenDoubleValue = cast(long)intValue;
-            if (afterPointDigits) {
-                long divider = 1;
-                for (int i = 0; i < afterPointDigits; i++)
-                    divider *= 10;
-                tokenDoubleValue += afterPointValue / cast(double)divider;
-            }
-            if (numberSign < 0)
-                tokenDoubleValue = -tokenDoubleValue;
-            if (exponentDigits) {
-                import std.math : pow;
-                double exponent = (cast(long)exponentValue * exponentSign);
-                tokenDoubleValue = tokenDoubleValue * pow(10, exponent);
-            }
-            tokenIntValue = cast(long)tokenDoubleValue;
-        } else {
-            // parsed integer
-            tokenIntValue = cast(long)intValue;
-            if (numberSign < 0)
-                tokenIntValue = -tokenIntValue;
-            tokenDoubleValue = tokenIntValue;
-        }
-        dimensionUnit.length = 0;
-        if (isIdentStart(tokenEnd)) {
-            tokenType = CSSTokenType.dimension;
-            consumeIdent(dimensionUnit);
-        }
-        return true;
-    }
-
-    bool parseString(char quotationChar) {
-        tokenType = CSSTokenType.str;
-        // skip first delimiter ' or "
-        size_t p = tokenEnd + 1;
-        for (;;) {
-            if (p >= src.length) {
-                // unexpected end of file
-                tokenEnd = p;
-                return true;
-            }
-            char ch = src.ptr[p];
-            if (ch == '\r' || ch == '\n') {
-                tokenType = CSSTokenType.badStr;
-                tokenEnd = p - 1;
-                return true;
-            } else if (ch == quotationChar) {
-                // end of string
-                tokenEnd = p + 1;
-                return true;
-            } else if (ch == '\\') {
-                if (p + 1 >= src.length) {
-                    // unexpected end of file
-                    tokenEnd = p;
-                    return true;
-                }
-                ch = src.ptr[p + 1];
-                if (ch == '\r' || ch == '\n') {
-                    // \ NEWLINE
-                    //tokenText ~= 0x0A;
-                    p++;
-                } else {
-                    dchar esc = parseEscape(p);
-                    if (esc == 0xFFFFFFFF) {
-                        esc = '?'; // replace invalid code point
-                        p++;
-                    }
-                    // encode to UTF-8
-                    appendEscapedIdentChar(esc);
-                }
-            } else {
-                // normal character
-                tokenText ~= ch;
-                p++;
-            }
-        }
-    }
-    CSSTokenType emitDelimToken() {
-        import std.utf : stride, UTFException;
-        try {
-            uint len = stride(src[tokenStart .. $]);
-            tokenEnd = tokenStart + len;
-        } catch (UTFException e) {
-            tokenEnd = tokenStart + 1;
-        }
-        tokenText ~= src[tokenStart .. tokenEnd];
-        tokenType = CSSTokenType.delim;
-        return tokenType;
-    }
-    // #token
-    CSSTokenType parseHashToken() {
-        tokenTypeFlagId = false;
-        tokenEnd++;
-        // set tokenTypeFlagId flag
-        if (parseIdent()) {
-            tokenType = CSSTokenType.hashToken;
-            if (tokenText[0] < '0' || tokenText[0] > '9')
-                tokenTypeFlagId = true; // is valid ID
-            return tokenType;
-        }
-        // invalid ident
-        return emitDelimToken();
-    }
-    /// current chars are /*
-    CSSTokenType parseComment() {
-        size_t p = tokenEnd + 2; // skip /*
-        while (p < src.length) {
-            char ch = src.ptr[p];
-            char ch2 = p + 1 < src.length ? src.ptr[p + 1] : 0;
-            if (ch == '*' && ch2 == '/') {
-                p += 2;
-                break;
-            }
-            p++;
-        }
-        tokenEnd = p;
-        tokenType = CSSTokenType.comment;
-        return tokenType;
-    }
-    /// current chars are U+ or u+ followed by hex digit or ?
-    CSSTokenType parseUnicodeRangeToken() {
-        unicodeRangeStart = 0;
-        unicodeRangeEnd = 0;
-        size_t p = tokenEnd + 2; // skip U+
-        // now we have hex digit or ?
-        int hexCount = 0;
-        uint hexNumber = 0;
-        int questionCount = 0;
-        // consume hex digits
-        while (p < src.length) {
-            char ch = src.ptr[p];
-            int digit = decodeHexDigit(ch);
-            if (digit < 0)
-                break;
-            hexCount++;
-            hexNumber = (hexNumber << 4) | digit;
-            p++;
-            if (hexCount >= 6)
-                break;
-        }
-        // consume question marks
-        while (p < src.length && questionCount + hexCount < 6) {
-            char ch = src.ptr[p];
-            if (ch != '?')
-                break;
-            questionCount++;
-            p++;
-        }
-        if (questionCount) {
-            int shift = 4 * questionCount;
-            unicodeRangeStart = hexNumber << shift;
-            unicodeRangeEnd = unicodeRangeStart + ((1 << shift) - 1);
-        } else {
-            unicodeRangeStart = hexNumber;
-            char ch = p < src.length ? src.ptr[p] : 0;
-            char ch2 = p + 1 < src.length ? src.ptr[p + 1] : 0;
-            int digit = decodeHexDigit(ch2);
-            if (ch == '-' && digit >= 0) {
-                p += 2; // skip - and first digit
-                hexCount = 1;
-                hexNumber = digit;
-                while (p < src.length) {
-                    ch = src.ptr[p];
-                    digit = decodeHexDigit(ch);
-                    if (digit < 0)
-                        break;
-                    hexCount++;
-                    hexNumber = (hexNumber << 4) | digit;
-                    p++;
-                    if (hexCount >= 6)
-                        break;
-                }
-                unicodeRangeEnd = hexNumber;
-            } else {
-                unicodeRangeEnd = unicodeRangeStart;
-            }
-        }
-        tokenEnd = p;
-        tokenType = CSSTokenType.unicodeRange;
-        return tokenType;
-    }
-    /// emit single char token like () {} [] : ;
-    CSSTokenType emitSingleCharToken(CSSTokenType type) {
-        tokenType = type;
-        tokenEnd = tokenStart + 1;
-        tokenText ~= src[tokenStart];
-        return type;
-    }
-    /// emit double char token like $= *=
-    CSSTokenType emitDoubleCharToken(CSSTokenType type) {
-        tokenType = type;
-        tokenEnd = tokenStart + 2;
-        tokenText ~= src[tokenStart .. tokenStart + 2];
-        return type;
-    }
-    void consumeBadUrl() {
-        for (;;) {
-            char ch = tokenEnd < src.length ? src.ptr[tokenEnd] : 0;
-            char ch2 = tokenEnd + 1 < src.length ? src.ptr[tokenEnd + 1] : 0;
-            if (ch == ')' || ch == 0) {
-                if (ch == ')')
-                    tokenEnd++;
-                break;
-            }
-            if (isCSSValidEscSequence(ch, ch2)) {
-                parseEscape(tokenEnd);
-            }
-            tokenEnd++;
-        }
-        tokenType = CSSTokenType.badUrl;
-    }
-    // Current position is after url(
-    void parseUrlToken() {
-        tokenText.length = 0;
-        skipWhiteSpace();
-        if (tokenEnd >= src.length)
-            return;
-        char ch = src.ptr[tokenEnd];
-        if (ch == '\'' || ch == '\"') {
-            if (parseString(ch)) {
-                skipWhiteSpace();
-                ch = tokenEnd < src.length ? src.ptr[tokenEnd] : 0;
-                if (ch == ')' || ch == 0) {
-                    // valid URL token
-                    if (ch == ')')
-                        tokenEnd++;
-                    tokenType = CSSTokenType.url;
-                    return;
-                }
-            }
-            // bad url
-            consumeBadUrl();
-            return;
-        }
-        // not quoted
-        for (;;) {
-            if (skipWhiteSpace()) {
-                ch = tokenEnd < src.length ? src.ptr[tokenEnd] : 0;
-                if (ch == ')' || ch == 0) {
-                    if (ch == ')')
-                        tokenEnd++;
-                    tokenType = CSSTokenType.url;
-                    return;
-                }
-                consumeBadUrl();
-                return;
-            }
-            ch = tokenEnd < src.length ? src.ptr[tokenEnd] : 0;
-            char ch2 = tokenEnd + 1 < src.length ? src.ptr[tokenEnd + 1] : 0;
-            if (ch == ')' || ch == 0) {
-                if (ch == ')')
-                    tokenEnd++;
-                tokenType = CSSTokenType.url;
-                return;
-            }
-            if (ch == '(' || ch == '\'' || ch == '\"' || isCSSNonPrintable(ch)) {
-                consumeBadUrl();
-                return;
-            }
-            if (ch == '\\') {
-                if (isCSSValidEscSequence(ch, ch2)) {
-                    dchar esc = parseEscape(tokenEnd);
-                    appendEscapedIdentChar(ch);
-                } else {
-                    consumeBadUrl();
-                    return;
-                }
-            }
-            tokenText ~= ch;
-            tokenEnd++;
-        }
-    }
-    CSSTokenType next() {
-        // move beginning of token
-        tokenStart = tokenEnd;
-        tokenText.length = 0;
-        // check for whitespace
-        if (skipWhiteSpace())
-            return tokenType; // whitespace or newline token
-        // check for eof
-        if (tokenEnd >= src.length)
-            return CSSTokenType.eof;
-        char ch = src.ptr[tokenEnd];
-        char nextCh = tokenEnd + 1 < src.length ? src.ptr[tokenEnd + 1] : 0;
-        if (ch == '\"' || ch == '\'') {
-            parseString(ch);
-            return tokenType;
-        }
-        if (ch == '#') {
-            return parseHashToken();
-        }
-        if (ch == '$') {
-            if (nextCh == '=') {
-                return emitDoubleCharToken(CSSTokenType.suffixMatch);
-            } else {
-                return emitDelimToken();
-            }
-        }
-        if (ch == '^') {
-            if (nextCh == '=') {
-                return emitDoubleCharToken(CSSTokenType.prefixMatch);
-            } else {
-                return emitDelimToken();
-            }
-        }
-        if (ch == '(')
-            return emitSingleCharToken(CSSTokenType.parentOpen);
-        if (ch == ')')
-            return emitSingleCharToken(CSSTokenType.parentClose);
-        if (ch == '[')
-            return emitSingleCharToken(CSSTokenType.squareOpen);
-        if (ch == ']')
-            return emitSingleCharToken(CSSTokenType.squareClose);
-        if (ch == '{')
-            return emitSingleCharToken(CSSTokenType.curlyOpen);
-        if (ch == '}')
-            return emitSingleCharToken(CSSTokenType.curlyClose);
-        if (ch == ',')
-            return emitSingleCharToken(CSSTokenType.comma);
-        if (ch == ':')
-            return emitSingleCharToken(CSSTokenType.colon);
-        if (ch == ';')
-            return emitSingleCharToken(CSSTokenType.semicolon);
-        if (ch == '*') {
-            if (nextCh == '=') {
-                return emitDoubleCharToken(CSSTokenType.substringMatch);
-            } else {
-                return emitDelimToken();
-            }
-        }
-        if (ch == '~') {
-            if (nextCh == '=') {
-                return emitDoubleCharToken(CSSTokenType.includeMatch);
-            } else {
-                return emitDelimToken();
-            }
-        }
-        if (ch == '|') {
-            if (nextCh == '=') {
-                return emitDoubleCharToken(CSSTokenType.dashMatch);
-            } else if (nextCh == '|') {
-                return emitDoubleCharToken(CSSTokenType.column);
-            } else {
-                return emitDelimToken();
-            }
-        }
-        if (ch == '/') {
-            if (nextCh == '*') {
-                return parseComment();
-            } else {
-                return emitDelimToken();
-            }
-        }
-        char nextCh2 = tokenEnd + 2 < src.length ? src.ptr[tokenEnd + 2] : 0;
-        if (ch == 'u' || ch == 'U') {
-            if (nextCh == '+' && (decodeHexDigit(nextCh2) >= 0 || nextCh2 == '?')) {
-                return parseUnicodeRangeToken();
-            }
-        }
-        if (parseNumber())
-            return tokenType;
-        if (parseIdent()) {
-            ch = tokenEnd < src.length ? src.ptr[tokenEnd] : 0;
-            if (ch == '(') {
-                tokenEnd++;
-                import std.uni : icmp;
-                if (tokenText.length == 3 && icmp(tokenText, "url") == 0) {
-                    // parse URL function
-                    parseUrlToken();
-                } else {
-                    tokenType = CSSTokenType.func;
-                }
-            }
-            return tokenType;
-        }
-        if (ch == '-') {
-            if (nextCh == '-' && nextCh2 == '>') {
-                tokenEnd = tokenStart + 3;
-                tokenType = CSSTokenType.cdc;
-                tokenText ~= src[tokenStart .. tokenEnd];
-                return tokenType;
-            }
-            return emitDelimToken();
-        }
-        if (ch == '<') {
-            char nextCh3 = tokenEnd + 3 < src.length ? src.ptr[tokenEnd + 3] : 0;
-            if (nextCh == '!' && nextCh2 == '-' && nextCh3 == '-') {
-                tokenEnd = tokenStart + 4;
-                tokenType = CSSTokenType.cdo;
-                tokenText ~= src[tokenStart .. tokenEnd];
-                return tokenType;
-            }
-            return emitDelimToken();
-        }
-        if (ch == '@') {
-            if (isIdentStart(tokenEnd + 1)) {
-                tokenEnd++;
-                parseIdent();
-                tokenType = CSSTokenType.atKeyword;
-                return tokenType;
-            }
-            return emitDelimToken();
-        }
-        return emitDelimToken();
-    }
-    /// same as next() but returns filled CSSToken struct
-    CSSToken nextToken() {
-        CSSToken res;
-        res.type = next();
-        if (res.type == CSSTokenType.str || res.type == CSSTokenType.ident || res.type == CSSTokenType.atKeyword || res.type == CSSTokenType.url || res.type == CSSTokenType.func) {
-            if (tokenText.length)
-                res.text = tokenText.dup;
-        }
-        if (res.type == CSSTokenType.dimension && dimensionUnit.length)
-            res.dimensionUnit = dimensionUnit.dup;
-        if (res.type == CSSTokenType.dimension || res.type == CSSTokenType.number) {
-            res.doubleValue = tokenDoubleValue;
-            res.intValue = tokenIntValue;
-            res.typeFlagInteger = tokenTypeInteger;
-        } else if (res.type == CSSTokenType.ident) {
-            res.typeFlagId = tokenTypeFlagId;
-        } else if (res.type == CSSTokenType.unicodeRange) {
-            res.unicodeRangeStart = unicodeRangeStart;
-            res.unicodeRangeEnd = unicodeRangeEnd;
-        }
-        return res;
-    }
-}
-
-unittest {
-    CSSTokenizer tokenizer;
-    tokenizer.start("ident-1{ }\n#id\n'blabla' \"bla bla 2\" -ident2*=12345 -.234e+5 "
-                    ~ "1.23px/* some comment */U+123?!"
-                    ~"url(   'text.css'  )url(bad url)functionName()url( bla )"
-                    ~"'\\30 \\31'");
-    assert(tokenizer.next() == CSSTokenType.ident);
-    assert(tokenizer.tokenText == "ident-1");
-    assert(tokenizer.next() == CSSTokenType.curlyOpen);
-    assert(tokenizer.next() == CSSTokenType.whitespace);
-    assert(tokenizer.next() == CSSTokenType.curlyClose);
-    assert(tokenizer.next() == CSSTokenType.whitespace); //newline
-    assert(tokenizer.next() == CSSTokenType.hashToken);
-    assert(tokenizer.tokenText == "id");
-    assert(tokenizer.tokenTypeFlagId == true);
-    assert(tokenizer.next() == CSSTokenType.whitespace); //newline
-    assert(tokenizer.next() == CSSTokenType.str);
-    assert(tokenizer.tokenText == "blabla");
-    assert(tokenizer.next() == CSSTokenType.whitespace);
-    assert(tokenizer.next() == CSSTokenType.str);
-    assert(tokenizer.tokenText == "bla bla 2");
-    assert(tokenizer.next() == CSSTokenType.whitespace);
-    assert(tokenizer.next() == CSSTokenType.ident);
-    assert(tokenizer.tokenText == "-ident2");
-    assert(tokenizer.next() == CSSTokenType.substringMatch);
-    assert(tokenizer.next() == CSSTokenType.number);
-    assert(tokenizer.tokenText == "12345");
-    assert(tokenizer.tokenIntValue == 12345);
-    assert(tokenizer.next() == CSSTokenType.whitespace);
-    assert(tokenizer.next() == CSSTokenType.number);
-    assert(tokenizer.tokenText == "-.234e+5");
-    assert(tokenizer.tokenIntValue == -23400);
-    assert(tokenizer.tokenDoubleValue == -.234e+5);
-    assert(tokenizer.next() == CSSTokenType.whitespace);
-    // next line
-    assert(tokenizer.next() == CSSTokenType.dimension);
-    assert(tokenizer.tokenText == "1.23");
-    assert(tokenizer.tokenIntValue == 1);
-    assert(tokenizer.tokenDoubleValue == 1.23);
-    assert(tokenizer.dimensionUnit == "px");
-    assert(tokenizer.next() == CSSTokenType.comment);
-    assert(tokenizer.next() == CSSTokenType.unicodeRange);
-    assert(tokenizer.unicodeRangeStart == 0x1230 && tokenizer.unicodeRangeEnd == 0x123F);
-    assert(tokenizer.next() == CSSTokenType.delim);
-    assert(tokenizer.tokenText == "!");
-    // next line
-    assert(tokenizer.next() == CSSTokenType.url);
-    assert(tokenizer.tokenText == "text.css");
-    assert(tokenizer.next() == CSSTokenType.badUrl);
-    assert(tokenizer.next() == CSSTokenType.func);
-    assert(tokenizer.tokenText == "functionName");
-    assert(tokenizer.next() == CSSTokenType.parentClose);
-    assert(tokenizer.next() == CSSTokenType.url);
-    assert(tokenizer.tokenText == "bla");
-    // next line
-    assert(tokenizer.next() == CSSTokenType.str);
-    assert(tokenizer.tokenText == "01"); //'\30 \31'
-    assert(tokenizer.next() == CSSTokenType.eof);
-}
-
-
-/**
-Tokenizes css source, returns array of tokens (last token is EOF).
-Source must be preprocessed utf-8 string.
-*/
-static CSSToken[] tokenizeCSS(string src) {
-    CSSTokenizer tokenizer;
-    tokenizer.start(src);
-    CSSToken[] res;
-    res.assumeSafeAppend();
-    for(;;) {
-        res ~= tokenizer.nextToken();
-        if (res[$ - 1].type == CSSTokenType.eof)
-            break;
-    }
-    return res;
-}
-
-unittest {
-    string src = "pre {123em}";
-    auto res = tokenizeCSS(src);
-    assert(res.length == 6);
-    assert(res[0].type == CSSTokenType.ident);
-    assert(res[0].text == "pre");
-    assert(res[1].type == CSSTokenType.whitespace);
-    assert(res[2].type == CSSTokenType.curlyOpen);
-    assert(res[3].type == CSSTokenType.dimension);
-    assert(res[3].typeFlagInteger == true);
-    assert(res[3].intValue == 123);
-    assert(res[3].dimensionUnit == "em");
-    assert(res[4].type == CSSTokenType.curlyClose);
-    assert(res[$ - 1].type == CSSTokenType.eof);
-}
-
-// easy way to extract and apply imports w/o full document parsing
-/**
-    Extract CSS vimport rules from source.
-*/
-CSSImportRule[] extractCSSImportRules(string src) {
-    enum ParserState {
-        start, // before rule begin, switch to this state after ;
-        afterImport, // after @import
-        afterCharset, // after @charset
-        afterCharsetName, // after @charset
-        afterImportUrl, // after @charset
-    }
-    ParserState state = ParserState.start;
-    CSSImportRule[] res;
-    CSSTokenizer tokenizer;
-    tokenizer.start(src);
-    bool insideImportRule = false;
-    string url;
-    size_t startPos = 0;
-    size_t endPos = 0;
-    for (;;) {
-        CSSTokenType type = tokenizer.next();
-        if (type == CSSTokenType.eof)
-            break;
-        if (type == CSSTokenType.whitespace || type == CSSTokenType.comment)
-            continue; // skip whitespaces and comments
-        if (type == CSSTokenType.atKeyword) {
-            if (tokenizer.tokenText == "charset") {
-                state = ParserState.afterCharset;
-                continue;
-            }
-            if (tokenizer.tokenText != "import")
-                break;
-            // import rule
-            state = ParserState.afterImport;
-            startPos = tokenizer.tokenStart;
-            continue;
-        }
-        if (type == CSSTokenType.str || type == CSSTokenType.url) {
-            if (state == ParserState.afterImport) {
-                url = tokenizer.tokenText.dup;
-                state = ParserState.afterImportUrl;
-                continue;
-            }
-            if (state == ParserState.afterCharset) {
-                state = ParserState.afterCharsetName;
-                continue;
-            }
-            break;
-        }
-        if (type == CSSTokenType.curlyOpen)
-            break;
-        if (type == CSSTokenType.ident && state == ParserState.start)
-            break; // valid @imports may be only at the beginning of file
-        if (type == CSSTokenType.semicolon) {
-            if (state == ParserState.afterImportUrl) {
-                // add URL
-                endPos = tokenizer.tokenEnd;
-                CSSImportRule rule;
-                rule.startPos = startPos;
-                rule.endPos = endPos;
-                rule.url = url;
-                res ~= rule;
-            }
-            state = ParserState.start;
-            continue;
-        }
-    }
-    return res;
-}
-
-/**
-  Replace source code import rules obtained by extractImportRules() with imported content.
-*/
-string applyCSSImportRules(string src, CSSImportRule[] rules) {
-    if (!rules.length)
-        return src; // no rules
-    char[] res;
-    res.assumeSafeAppend;
-    size_t start = 0;
-    for (int i = 0; i < rules.length; i++) {
-        res ~= src[start .. rules[i].startPos];
-        res ~= rules[i].content;
-        start = rules[i].endPos;
-    }
-    if (start < src.length)
-        res ~= src[start .. $];
-    return cast(string)res;
-}
-
-
-unittest {
-    string src = q{
-        @charset "utf-8";
-        /* comment must be ignored */
-        @import "file1.css"; /* string */
-        @import url(file2.css); /* url */
-        pre {}
-        @import "ignore_me.css";
-        p {}
-    };
-    auto res = extractCSSImportRules(src);
-    assert(res.length == 2);
-    assert(res[0].url == "file1.css");
-    assert(res[1].url == "file2.css");
-    res[0].content = "[file1_content]";
-    res[1].content = "[file2_content]";
-    string s = applyCSSImportRules(src, res);
-    assert (s.length != src.length);
-}
-
-enum ASTNodeType {
-    simpleBlock,
-    componentValue,
-    preservedToken,
-    func,
-    atRule,
-    qualifiedRule,
-}
-
-class ASTNode {
-    ASTNodeType type;
-}
-
-class ComponentValueNode : ASTNode {
-    this() {
-        type = ASTNodeType.componentValue;
-    }
-}
-
-class SimpleBlockNode : ComponentValueNode {
-    CSSTokenType blockType = CSSTokenType.curlyOpen;
-    ComponentValueNode[] componentValues;
-    this() {
-        type = ASTNodeType.simpleBlock;
-    }
-}
-
-class FunctionNode : ComponentValueNode {
-    ComponentValueNode[] componentValues;
-    this(string name) {
-        type = ASTNodeType.func;
-    }
-}
-
-class PreservedTokenNode : ComponentValueNode {
-    CSSToken token;
-    this(ref CSSToken token) {
-        this.token = token;
-        type = ASTNodeType.preservedToken;
-    }
-}
-
-class QualifiedRuleNode : ASTNode {
-    ComponentValueNode[] componentValues;
-    SimpleBlockNode block;
-    this() {
-        type = ASTNodeType.qualifiedRule;
-    }
-}
-
-class ATRuleNode : QualifiedRuleNode {
-    string name;
-    this() {
-        type = ASTNodeType.atRule;
-    }
-}
-
-
-class CSSParser {
-    CSSToken[] tokens;
-    int pos = 0;
-    this(CSSToken[] _tokens) {
-        tokens = _tokens;
-    }
-    /// peek current token
-    @property ref CSSToken currentToken() {
-        return tokens[pos];
-    }
-    /// peek next token
-    @property ref CSSToken nextToken() {
-        return tokens[pos + 1 < $ ? pos + 1 : pos];
-    }
-    /// move to next token
-    bool next() {
-        if (pos < tokens.length) {
-            pos++;
-            return true;
-        }
-        return false;
-    }
-    /// move to nearest non-whitespace token; return current token type (does not move if current token is not whitespace)
-    CSSTokenType skipWhiteSpace() {
-        while (currentToken.type == CSSTokenType.whitespace || currentToken.type == CSSTokenType.comment || currentToken.type == CSSTokenType.delim)
-            next();
-        return currentToken.type;
-    }
-    /// skip current token, then move to nearest non-whitespace token; return new token type
-    @property CSSTokenType nextNonWhiteSpace() {
-        next();
-        return skipWhiteSpace();
-    }
-    SimpleBlockNode parseSimpleBlock() {
-        auto type = skipWhiteSpace();
-        CSSTokenType closeType;
-        if (type == CSSTokenType.curlyOpen) {
-            closeType = CSSTokenType.curlyClose;
-        } else if (type == CSSTokenType.squareOpen) {
-            closeType = CSSTokenType.squareClose;
-        } else if (type == CSSTokenType.parentOpen) {
-            closeType = CSSTokenType.parentClose;
-        } else {
-            // not a simple block
-            return null;
-        }
-        SimpleBlockNode res = new SimpleBlockNode();
-        res.blockType = type;
-        auto t = nextNonWhiteSpace();
-        res.componentValues = parseComponentValueList(closeType);
-        t = skipWhiteSpace();
-        if (t == closeType)
-            nextNonWhiteSpace();
-        return res;
-    }
-    FunctionNode parseFunctionBlock() {
-        auto type = skipWhiteSpace();
-        if (type != CSSTokenType.func)
-            return null;
-        FunctionNode res = new FunctionNode(currentToken.text);
-        auto t = nextNonWhiteSpace();
-        res.componentValues = parseComponentValueList(CSSTokenType.parentClose);
-        t = skipWhiteSpace();
-        if (t == CSSTokenType.parentClose)
-            nextNonWhiteSpace();
-        return res;
-    }
-    ComponentValueNode[] parseComponentValueList(CSSTokenType endToken1 = CSSTokenType.eof, CSSTokenType endToken2 = CSSTokenType.eof) {
-        ComponentValueNode[] res;
-        for (;;) {
-            auto type = skipWhiteSpace();
-            if (type == CSSTokenType.eof)
-                return res;
-            if (type == endToken1 || type == endToken2)
-                return res;
-            if (type == CSSTokenType.squareOpen || type == CSSTokenType.parentOpen || type == CSSTokenType.curlyOpen) {
-                res ~= parseSimpleBlock();
-            } else if (type == CSSTokenType.func) {
-                res ~= parseFunctionBlock();
-            } else {
-                res ~= new PreservedTokenNode(currentToken);
-                next();
-            }
-        }
-    }
-    ATRuleNode parseATRule() {
-        auto type = skipWhiteSpace();
-        if (type != CSSTokenType.atKeyword)
-            return null;
-        ATRuleNode res = new ATRuleNode();
-        res.name = currentToken.text;
-        type = nextNonWhiteSpace();
-        res.componentValues = parseComponentValueList(CSSTokenType.semicolon, CSSTokenType.curlyOpen);
-        type = skipWhiteSpace();
-        if (type == CSSTokenType.semicolon) {
-            next();
-            return res;
-        }
-        if (type == CSSTokenType.curlyOpen) {
-            res.block = parseSimpleBlock();
-            return res;
-        }
-        if (type == CSSTokenType.eof)
-            return res;
-        return res;
-    }
-
-    QualifiedRuleNode parseQualifiedRule() {
-        auto type = skipWhiteSpace();
-        if (type == CSSTokenType.eof)
-            return null;
-        QualifiedRuleNode res = new QualifiedRuleNode();
-        res.componentValues = parseComponentValueList(CSSTokenType.curlyOpen);
-        type = skipWhiteSpace();
-        if (type == CSSTokenType.curlyOpen) {
-            res.block = parseSimpleBlock();
-        }
-        return res;
-    }
-}
-
-unittest {
-    ATRuleNode atRule = new CSSParser(tokenizeCSS("@atRuleName;")).parseATRule();
-    assert(atRule !is null);
-    assert(atRule.name == "atRuleName");
-    assert(atRule.block is null);
-
-    atRule = new CSSParser(tokenizeCSS("@atRuleName2 { }")).parseATRule();
-    assert(atRule !is null);
-    assert(atRule.name == "atRuleName2");
-    assert(atRule.block !is null);
-    assert(atRule.block.blockType == CSSTokenType.curlyOpen);
-
-    atRule = new CSSParser(tokenizeCSS("@atRuleName3 url('bla') { 123 }")).parseATRule();
-    assert(atRule !is null);
-    assert(atRule.name == "atRuleName3");
-    assert(atRule.componentValues.length == 1);
-    assert(atRule.componentValues[0].type == ASTNodeType.preservedToken);
-    assert(atRule.block !is null);
-    assert(atRule.block.blockType == CSSTokenType.curlyOpen);
-    assert(atRule.block.componentValues.length == 1);
-
-
-    atRule = new CSSParser(tokenizeCSS("@atRuleName4 \"value\" { funcName(123) }")).parseATRule();
-    assert(atRule !is null);
-    assert(atRule.name == "atRuleName4");
-    assert(atRule.componentValues.length == 1);
-    assert(atRule.componentValues[0].type == ASTNodeType.preservedToken);
-    assert(atRule.block !is null);
-    assert(atRule.block.blockType == CSSTokenType.curlyOpen);
-    assert(atRule.block.componentValues.length == 1);
-    assert(atRule.block.componentValues[0].type == ASTNodeType.func);
-}
-
-unittest {
-    QualifiedRuleNode qualifiedRule = new CSSParser(tokenizeCSS(" pre { display: none } ")).parseQualifiedRule();
-    assert(qualifiedRule !is null);
-    assert(qualifiedRule.componentValues.length == 1);
-    assert(qualifiedRule.block !is null);
-    assert(qualifiedRule.block.componentValues.length == 3);
-}
diff --git a/src/dlangui/dom/encoding.d b/src/dlangui/dom/encoding.d
deleted file mode 100644
index f6f17ad0..00000000
--- a/src/dlangui/dom/encoding.d
+++ /dev/null
@@ -1,72 +0,0 @@
-module dom.encoding;
-
-string findCharsetDirective(ubyte[] src) {
-    import std.string;
-    import std.algorithm : min;
-    string encoding = null;
-    if (src.length >= 17) {
-        auto head = cast(string)src[0 .. min(1024, src.length)];
-        auto encPos = head.indexOf(`@charset "`);
-        if (encPos >= 0) {
-            head = head[10 .. $];
-            auto endPos = head.indexOf('"');
-            if (endPos > 0) {
-                head = head[0 .. endPos];
-                bool valid = true;
-                ubyte v = 0;
-                foreach(ch; head)
-                    v |= ch;
-                if (v & 0x80) {
-                    // only code points 0..127
-                    // found valid @charset directive
-                    return cast(string)head.dup;
-                }
-            }
-        }
-    }
-    return null; // not found
-}
-
-/**
-   Convert CSS code bytes to utf-8.
-   src is source byte stream
-   baseEncoding is name of HTTP stream encoding or base document encoding.
-*/
-char[] bytesToUtf8(ubyte[] src, string streamEncoding = null, string environmentEncoding = null) {
-    import std.string;
-    import std.algorithm : min;
-    bool isUtf8 = false;
-    string encoding = null;
-    if (streamEncoding) {
-        encoding = streamEncoding;
-    } else {
-        string charsetDirectiveEncoding = findCharsetDirective(src);
-        if (charsetDirectiveEncoding) {
-            encoding = charsetDirectiveEncoding;
-            if (charsetDirectiveEncoding[0] == 'u' && charsetDirectiveEncoding[1] == 't' && charsetDirectiveEncoding[2] == 'f' && charsetDirectiveEncoding[3] == '-') {
-                isUtf8 = true; // for utf-16be, utf-16le use utf-8
-                encoding = "utf-8";
-            }
-        }
-    }
-    if (!encoding && environmentEncoding)
-        encoding = environmentEncoding;
-    if (!encoding) {
-        // check bom
-        // utf-8 BOM
-        if (src.length > 3 && src[0] == 0xEF && src[1] == 0xBB && src[2] == 0xBF) {
-            isUtf8 = true;
-            encoding = "utf-8";
-            src = src[3 .. $];
-        } else {
-            // TODO: support other UTF-8 BOMs
-        }
-    }
-    if (isUtf8) {
-        // no decoding needed
-        return cast(char[])src.dup;
-    }
-    // TODO: support more encodings
-    // unknown encoding
-    return null;
-}