@rindo/core 1.8.12 → 2.5.2

package/dist/hydrate/index.mjs

@@ -1,1281 +0,0 @@
-import { hydrateFactory } from '@rindo/core/hydrate-factory';
-import { constrainTimeouts, patchWindow, MockWindow, serializeNodeToHtml } from '@rindo/core/mock-doc';
-
-const URL_ = /*@__PURE__*/(function(){
-  if (typeof URL === 'function') {
-    return URL;
-  }
-  const requireFunc = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : require;
-  if (typeof requireFunc === 'function') {
-    try {
-      return requireFunc('url').URL;
-    } catch (e) {}
-  }
-  return function() {}
-})();
-
-function normalizeHydrateOptions(inputOpts) {
-    const outputOpts = Object.assign({
-        hasTimedOut: false,
-        serializeToHtml: false,
-        destroyWindow: false,
-        destroyDocument: false,
-    }, inputOpts || {});
-    if (typeof outputOpts.clientHydrateAnnotations !== 'boolean') {
-        outputOpts.clientHydrateAnnotations = true;
-    }
-    if (typeof outputOpts.constrainTimeouts !== 'boolean') {
-        outputOpts.constrainTimeouts = true;
-    }
-    if (typeof outputOpts.maxHydrateCount !== 'number') {
-        outputOpts.maxHydrateCount = 300;
-    }
-    if (typeof outputOpts.timeout !== 'number') {
-        outputOpts.timeout = 15000;
-    }
-    if (!Array.isArray(outputOpts.excludeComponents)) {
-        outputOpts.excludeComponents = [];
-    }
-    outputOpts.excludeComponents = outputOpts.excludeComponents
-        .filter(c => typeof c === 'string' && c.includes('-'))
-        .map(c => c.toLowerCase());
-    return outputOpts;
-}
-function generateHydrateResults(opts) {
-    if (typeof opts.url !== 'string') {
-        opts.url = `https://hydrate-rindojs.web.app/`;
-    }
-    const results = {
-        diagnostics: [],
-        url: opts.url,
-        host: null,
-        hostname: null,
-        href: null,
-        port: null,
-        pathname: null,
-        search: null,
-        hash: null,
-        html: null,
-        hydratedCount: 0,
-        anchors: [],
-        components: [],
-        imgs: [],
-        scripts: [],
-        styles: [],
-        title: null
-    };
-    try {
-        const url = new URL_(opts.url, `https://hydrate-rindojs.web.app/`);
-        results.url = url.href;
-        results.host = url.host;
-        results.hostname = url.hostname;
-        results.href = url.href;
-        results.port = url.port;
-        results.pathname = url.pathname;
-        results.search = url.search;
-        results.hash = url.hash;
-    }
-    catch (e) {
-        renderCatchError(results, e);
-    }
-    return results;
-}
-function renderBuildError(results, msg) {
-    const diagnostic = {
-        level: 'error',
-        type: 'build',
-        header: 'Hydrate Error',
-        messageText: msg,
-        relFilePath: null,
-        absFilePath: null,
-        lines: []
-    };
-    if (results.pathname) {
-        if (results.pathname !== '/') {
-            diagnostic.header += ': ' + results.pathname;
-        }
-    }
-    else if (results.url) {
-        diagnostic.header += ': ' + results.url;
-    }
-    results.diagnostics.push(diagnostic);
-    return diagnostic;
-}
-function renderCatchError(results, err) {
-    const diagnostic = renderBuildError(results, null);
-    if (err != null) {
-        if (err.stack != null) {
-            diagnostic.messageText = err.stack.toString();
-        }
-        else {
-            if (err.message != null) {
-                diagnostic.messageText = err.message.toString();
-            }
-            else {
-                diagnostic.messageText = err.toString();
-            }
-        }
-    }
-    return diagnostic;
-}
-
-function initializeWindow(win, opts, results) {
-    try {
-        win.location.href = opts.url;
-    }
-    catch (e) {
-        renderCatchError(results, e);
-    }
-    if (typeof opts.userAgent === 'string') {
-        try {
-            win.navigator.userAgent = opts.userAgent;
-        }
-        catch (e) { }
-    }
-    if (typeof opts.cookie === 'string') {
-        try {
-            win.document.cookie = opts.cookie;
-        }
-        catch (e) { }
-    }
-    if (typeof opts.referrer === 'string') {
-        try {
-            win.document.referrer = opts.referrer;
-        }
-        catch (e) { }
-    }
-    if (typeof opts.direction === 'string') {
-        try {
-            win.document.documentElement.setAttribute('dir', opts.direction);
-        }
-        catch (e) { }
-    }
-    if (typeof opts.language === 'string') {
-        try {
-            win.document.documentElement.setAttribute('lang', opts.language);
-        }
-        catch (e) { }
-    }
-    try {
-        win.customElements = null;
-    }
-    catch (e) { }
-    if (opts.constrainTimeouts) {
-        constrainTimeouts(win);
-    }
-    try {
-        win.console.error = function () {
-            renderCatchError(results, [...arguments].join(', '));
-        };
-        win.console.debug = function () {
-            const diagnostic = renderCatchError(results, [...arguments].join(', '));
-            diagnostic.level = 'debug';
-            diagnostic.messageText = 'Hydrate Debug';
-        };
-    }
-    catch (e) {
-        renderCatchError(results, e);
-    }
-    return win;
-}
-
-function inspectElement(results, elm, depth) {
-    const children = elm.children;
-    for (let i = 0, ii = children.length; i < ii; i++) {
-        const childElm = children[i];
-        const tagName = childElm.nodeName.toLowerCase();
-        if (tagName.includes('-')) {
-            const cmp = results.components.find(c => c.tag === tagName);
-            if (cmp != null) {
-                cmp.count++;
-                if (depth > cmp.depth) {
-                    cmp.depth = depth;
-                }
-            }
-        }
-        else {
-            switch (tagName) {
-                case 'a':
-                    const anchor = collectAttributes(childElm);
-                    anchor.href = childElm.href;
-                    if (typeof anchor.href === 'string') {
-                        if (!results.anchors.some(a => a.href === anchor.href)) {
-                            results.anchors.push(anchor);
-                        }
-                    }
-                    break;
-                case 'img':
-                    const img = collectAttributes(childElm);
-                    img.src = childElm.src;
-                    if (typeof img.src === 'string') {
-                        if (!results.imgs.some(a => a.src === img.src)) {
-                            results.imgs.push(img);
-                        }
-                    }
-                    break;
-                case 'link':
-                    const link = collectAttributes(childElm);
-                    link.href = childElm.href;
-                    if (typeof link.rel === 'string' && link.rel.toLowerCase() === 'stylesheet') {
-                        if (typeof link.href === 'string') {
-                            if (!results.styles.some(s => s.link === link.href)) {
-                                delete link.rel;
-                                delete link.type;
-                                results.styles.push(link);
-                            }
-                        }
-                    }
-                    break;
-                case 'script':
-                    const script = collectAttributes(childElm);
-                    script.src = childElm.src;
-                    if (typeof script.src === 'string') {
-                        if (!results.scripts.some(s => s.src === script.src)) {
-                            results.scripts.push(script);
-                        }
-                    }
-                    break;
-            }
-        }
-        depth++;
-        inspectElement(results, childElm, depth);
-    }
-}
-function collectAttributes(node) {
-    const parsedElm = {};
-    const attrs = node.attributes;
-    for (let i = 0, ii = attrs.length; i < ii; i++) {
-        const attr = attrs.item(i);
-        const attrName = attr.nodeName.toLowerCase();
-        if (SKIP_ATTRS.has(attrName)) {
-            continue;
-        }
-        const attrValue = attr.nodeValue;
-        if (attrName === 'class' && attrValue === '') {
-            continue;
-        }
-        parsedElm[attrName] = attrValue;
-    }
-    return parsedElm;
-}
-const SKIP_ATTRS = new Set([
-    's-id', 'c-id'
-]);
-
-function patchDomImplementation(doc, opts) {
-    let win;
-    if (doc.defaultView != null) {
-        opts.destroyWindow = true;
-        patchWindow(doc.defaultView);
-        win = doc.defaultView;
-    }
-    else {
-        opts.destroyWindow = true;
-        opts.destroyDocument = false;
-        win = new MockWindow(false);
-    }
-    if (win.document !== doc) {
-        win.document = doc;
-    }
-    if (doc.defaultView !== win) {
-        doc.defaultView = win;
-    }
-    const HTMLElement = doc.documentElement.constructor.prototype;
-    if (typeof HTMLElement.getRootNode !== 'function') {
-        const elm = doc.createElement('unknown-element');
-        const HTMLUnknownElement = elm.constructor.prototype;
-        HTMLUnknownElement.getRootNode = getRootNode;
-    }
-    if (typeof doc.createEvent === 'function') {
-        const CustomEvent = doc.createEvent('CustomEvent').constructor;
-        if (win.CustomEvent !== CustomEvent) {
-            win.CustomEvent = CustomEvent;
-        }
-    }
-    try {
-        doc.baseURI;
-    }
-    catch (e) {
-        Object.defineProperty(doc, 'baseURI', {
-            get() {
-                const baseElm = doc.querySelector('base[href]');
-                if (baseElm) {
-                    return (new URL(baseElm.getAttribute('href'), win.location.href)).href;
-                }
-                return win.location.href;
-            }
-        });
-    }
-    return win;
-}
-function getRootNode(opts) {
-    const isComposed = (opts != null && opts.composed === true);
-    let node = this;
-    while (node.parentNode != null) {
-        node = node.parentNode;
-        if (isComposed === true && node.parentNode == null && node.host != null) {
-            node = node.host;
-        }
-    }
-    return node;
-}
-
-function relocateMetaCharset(doc) {
-    const head = doc.head;
-    let charsetElm = head.querySelector('meta[charset]');
-    if (charsetElm == null) {
-        charsetElm = doc.createElement('meta');
-        charsetElm.setAttribute('charset', 'utf-8');
-    }
-    else {
-        charsetElm.remove();
-    }
-    head.insertBefore(charsetElm, head.firstChild);
-}
-
-const commentre = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g;
-function parseCss(css, filePath) {
-    var lineno = 1;
-    var column = 1;
-    var srcLines;
-    function updatePosition(str) {
-        const lines = str.match(/\n/g);
-        if (lines)
-            lineno += lines.length;
-        const i = str.lastIndexOf('\n');
-        column = ~i ? str.length - i : column + str.length;
-    }
-    function position() {
-        const start = { line: lineno, column: column };
-        return function (node) {
-            node.position = new ParsePosition(start);
-            whitespace();
-            return node;
-        };
-    }
-    class ParsePosition {
-        constructor(start) {
-            this.start = start;
-            this.end = { line: lineno, column: column };
-            this.source = filePath;
-        }
-    }
-    ParsePosition.prototype.content = css;
-    const diagnostics = [];
-    function error(msg) {
-        if (!srcLines) {
-            srcLines = css.split('\n');
-        }
-        const d = {
-            level: 'error',
-            type: 'css',
-            language: 'css',
-            header: 'CSS Parse',
-            messageText: msg,
-            absFilePath: filePath,
-            lines: [{
-                    lineIndex: lineno - 1,
-                    lineNumber: lineno,
-                    errorCharStart: column,
-                    text: css[lineno - 1],
-                }]
-        };
-        if (lineno > 1) {
-            const previousLine = {
-                lineIndex: lineno - 1,
-                lineNumber: lineno - 1,
-                text: css[lineno - 2],
-                errorCharStart: -1,
-                errorLength: -1
-            };
-            d.lines.unshift(previousLine);
-        }
-        if (lineno + 2 < srcLines.length) {
-            const nextLine = {
-                lineIndex: lineno,
-                lineNumber: lineno + 1,
-                text: srcLines[lineno],
-                errorCharStart: -1,
-                errorLength: -1
-            };
-            d.lines.push(nextLine);
-        }
-        diagnostics.push(d);
-    }
-    function stylesheet() {
-        const rulesList = rules();
-        return {
-            type: 'stylesheet',
-            stylesheet: {
-                source: filePath,
-                rules: rulesList,
-                diagnostics: diagnostics
-            }
-        };
-    }
-    function open() {
-        return match(/^{\s*/);
-    }
-    function close() {
-        return match(/^}/);
-    }
-    function rules() {
-        var node;
-        const rules = [];
-        whitespace();
-        comments(rules);
-        while (css.length && css.charAt(0) !== '}' && (node = atrule() || rule())) {
-            if (node !== false) {
-                rules.push(node);
-                comments(rules);
-            }
-        }
-        return rules;
-    }
-    function match(re) {
-        const m = re.exec(css);
-        if (!m)
-            return;
-        const str = m[0];
-        updatePosition(str);
-        css = css.slice(str.length);
-        return m;
-    }
-    function whitespace() {
-        match(/^\s*/);
-    }
-    function comments(rules) {
-        var c;
-        rules = rules || [];
-        while (c = comment()) {
-            if (c !== false) {
-                rules.push(c);
-            }
-        }
-        return rules;
-    }
-    function comment() {
-        const pos = position();
-        if ('/' !== css.charAt(0) || '*' !== css.charAt(1))
-            return;
-        var i = 2;
-        while ('' !== css.charAt(i) && ('*' !== css.charAt(i) || '/' !== css.charAt(i + 1)))
-            ++i;
-        i += 2;
-        if ('' === css.charAt(i - 1)) {
-            return error('End of comment missing');
-        }
-        const str = css.slice(2, i - 2);
-        column += 2;
-        updatePosition(str);
-        css = css.slice(i);
-        column += 2;
-        return pos({
-            type: 'comment',
-            comment: str
-        });
-    }
-    function selector() {
-        const m = match(/^([^{]+)/);
-        if (!m)
-            return;
-        return trim(m[0])
-            .replace(/\/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*\/+/g, '')
-            .replace(/"(?:\\"|[^"])*"|'(?:\\'|[^'])*'/g, function (m) {
-            return m.replace(/,/g, '\u200C');
-        })
-            .split(/\s*(?![^(]*\)),\s*/)
-            .map(function (s) {
-            return s.replace(/\u200C/g, ',');
-        });
-    }
-    function declaration() {
-        const pos = position();
-        var prop = match(/^(\*?[-#\/\*\\\w]+(\[[0-9a-z_-]+\])?)\s*/);
-        if (!prop)
-            return;
-        prop = trim(prop[0]);
-        if (!match(/^:\s*/))
-            return error(`property missing ':'`);
-        const val = match(/^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^\)]*?\)|[^};])+)/);
-        const ret = pos({
-            type: 'declaration',
-            property: prop.replace(commentre, ''),
-            value: val ? trim(val[0]).replace(commentre, '') : ''
-        });
-        match(/^[;\s]*/);
-        return ret;
-    }
-    function declarations() {
-        const decls = [];
-        if (!open())
-            return error(`missing '{'`);
-        comments(decls);
-        var decl;
-        while (decl = declaration()) {
-            if (decl !== false) {
-                decls.push(decl);
-                comments(decls);
-            }
-        }
-        if (!close())
-            return error(`missing '}'`);
-        return decls;
-    }
-    function keyframe() {
-        var m;
-        const vals = [];
-        const pos = position();
-        while (m = match(/^((\d+\.\d+|\.\d+|\d+)%?|[a-z]+)\s*/)) {
-            vals.push(m[1]);
-            match(/^,\s*/);
-        }
-        if (!vals.length)
-            return;
-        return pos({
-            type: 'keyframe',
-            values: vals,
-            declarations: declarations()
-        });
-    }
-    function atkeyframes() {
-        const pos = position();
-        var m = match(/^@([-\w]+)?keyframes\s*/);
-        if (!m)
-            return;
-        const vendor = m[1];
-        m = match(/^([-\w]+)\s*/);
-        if (!m)
-            return error(`@keyframes missing name`);
-        const name = m[1];
-        if (!open())
-            return error(`@keyframes missing '{'`);
-        var frame;
-        var frames = comments();
-        while (frame = keyframe()) {
-            frames.push(frame);
-            frames = frames.concat(comments());
-        }
-        if (!close())
-            return error(`@keyframes missing '}'`);
-        return pos({
-            type: 'keyframes',
-            name: name,
-            vendor: vendor,
-            keyframes: frames
-        });
-    }
-    function atsupports() {
-        const pos = position();
-        const m = match(/^@supports *([^{]+)/);
-        if (!m)
-            return;
-        const supports = trim(m[1]);
-        if (!open())
-            return error(`@supports missing '{'`);
-        const style = comments().concat(rules());
-        if (!close())
-            return error(`@supports missing '}'`);
-        return pos({
-            type: 'supports',
-            supports: supports,
-            rules: style
-        });
-    }
-    function athost() {
-        const pos = position();
-        const m = match(/^@host\s*/);
-        if (!m)
-            return;
-        if (!open())
-            return error(`@host missing '{'`);
-        const style = comments().concat(rules());
-        if (!close())
-            return error(`@host missing '}'`);
-        return pos({
-            type: 'host',
-            rules: style
-        });
-    }
-    function atmedia() {
-        const pos = position();
-        const m = match(/^@media *([^{]+)/);
-        if (!m)
-            return;
-        const media = trim(m[1]);
-        if (!open())
-            return error(`@media missing '{'`);
-        const style = comments().concat(rules());
-        if (!close())
-            return error(`@media missing '}'`);
-        return pos({
-            type: 'media',
-            media: media,
-            rules: style
-        });
-    }
-    function atcustommedia() {
-        const pos = position();
-        const m = match(/^@custom-media\s+(--[^\s]+)\s*([^{;]+);/);
-        if (!m)
-            return;
-        return pos({
-            type: 'custom-media',
-            name: trim(m[1]),
-            media: trim(m[2])
-        });
-    }
-    function atpage() {
-        const pos = position();
-        const m = match(/^@page */);
-        if (!m)
-            return;
-        const sel = selector() || [];
-        if (!open())
-            return error(`@page missing '{'`);
-        var decls = comments();
-        var decl;
-        while (decl = declaration()) {
-            decls.push(decl);
-            decls = decls.concat(comments());
-        }
-        if (!close())
-            return error(`@page missing '}'`);
-        return pos({
-            type: 'page',
-            selectors: sel,
-            declarations: decls
-        });
-    }
-    function atdocument() {
-        const pos = position();
-        const m = match(/^@([-\w]+)?document *([^{]+)/);
-        if (!m)
-            return;
-        const vendor = trim(m[1]);
-        const doc = trim(m[2]);
-        if (!open())
-            return error(`@document missing '{'`);
-        const style = comments().concat(rules());
-        if (!close())
-            return error(`@document missing '}'`);
-        return pos({
-            type: 'document',
-            document: doc,
-            vendor: vendor,
-            rules: style
-        });
-    }
-    function atfontface() {
-        const pos = position();
-        const m = match(/^@font-face\s*/);
-        if (!m)
-            return;
-        if (!open())
-            return error(`@font-face missing '{'`);
-        var decls = comments();
-        var decl;
-        while (decl = declaration()) {
-            decls.push(decl);
-            decls = decls.concat(comments());
-        }
-        if (!close())
-            return error(`@font-face missing '}'`);
-        return pos({
-            type: 'font-face',
-            declarations: decls
-        });
-    }
-    const atimport = _compileAtrule('import');
-    const atcharset = _compileAtrule('charset');
-    const atnamespace = _compileAtrule('namespace');
-    function _compileAtrule(name) {
-        const re = new RegExp('^@' + name + '\\s*([^;]+);');
-        return function () {
-            const pos = position();
-            const m = match(re);
-            if (!m)
-                return;
-            const ret = { type: name };
-            ret[name] = m[1].trim();
-            return pos(ret);
-        };
-    }
-    function atrule() {
-        if (css[0] !== '@')
-            return;
-        return atkeyframes()
-            || atmedia()
-            || atcustommedia()
-            || atsupports()
-            || atimport()
-            || atcharset()
-            || atnamespace()
-            || atdocument()
-            || atpage()
-            || athost()
-            || atfontface();
-    }
-    function rule() {
-        const pos = position();
-        const sel = selector();
-        if (!sel)
-            return error('selector missing');
-        comments();
-        return pos({
-            type: 'rule',
-            selectors: sel,
-            declarations: declarations()
-        });
-    }
-    return addParent(stylesheet());
-}
-function trim(str) {
-    return str ? str.trim() : '';
-}
-function addParent(obj, parent) {
-    const isNode = obj && typeof obj.type === 'string';
-    const childParent = isNode ? obj : parent;
-    for (const k in obj) {
-        const value = obj[k];
-        if (Array.isArray(value)) {
-            value.forEach(function (v) { addParent(v, childParent); });
-        }
-        else if (value && typeof value === 'object') {
-            addParent(value, childParent);
-        }
-    }
-    if (isNode) {
-        Object.defineProperty(obj, 'parent', {
-            configurable: true,
-            writable: true,
-            enumerable: false,
-            value: parent || null
-        });
-    }
-    return obj;
-}
-
-function getSelectors(sel) {
-    SELECTORS.all.length = SELECTORS.tags.length = SELECTORS.classNames.length = SELECTORS.ids.length = SELECTORS.attrs.length = 0;
-    sel = sel.replace(/\./g, ' .')
-        .replace(/\#/g, ' #')
-        .replace(/\[/g, ' [')
-        .replace(/\>/g, ' > ')
-        .replace(/\+/g, ' + ')
-        .replace(/\~/g, ' ~ ')
-        .replace(/\*/g, ' * ')
-        .replace(/\:not\((.*?)\)/g, ' ');
-    const items = sel.split(' ');
-    for (var i = 0; i < items.length; i++) {
-        items[i] = items[i].split(':')[0];
-        if (items[i].length === 0)
-            continue;
-        if (items[i].charAt(0) === '.') {
-            SELECTORS.classNames.push(items[i].substr(1));
-        }
-        else if (items[i].charAt(0) === '#') {
-            SELECTORS.ids.push(items[i].substr(1));
-        }
-        else if (items[i].charAt(0) === '[') {
-            items[i] = items[i].substr(1).split('=')[0].split(']')[0].trim();
-            SELECTORS.attrs.push(items[i].toLowerCase());
-        }
-        else if (/[a-z]/g.test(items[i].charAt(0))) {
-            SELECTORS.tags.push(items[i].toLowerCase());
-        }
-    }
-    SELECTORS.classNames = SELECTORS.classNames.sort((a, b) => {
-        if (a.length < b.length)
-            return -1;
-        if (a.length > b.length)
-            return 1;
-        return 0;
-    });
-    return SELECTORS;
-}
-const SELECTORS = {
-    all: [],
-    tags: [],
-    classNames: [],
-    ids: [],
-    attrs: []
-};
-
-class StringifyCss {
-    constructor(usedSelectors) {
-        this.usedSelectors = usedSelectors;
-        this.hasUsedAttrs = usedSelectors.attrs.size > 0;
-        this.hasUsedClassNames = usedSelectors.classNames.size > 0;
-        this.hasUsedIds = usedSelectors.ids.size > 0;
-        this.hasUsedTags = usedSelectors.tags.size > 0;
-    }
-    visit(node) {
-        return this[node.type](node);
-    }
-    mapVisit(nodes, delim) {
-        let buf = '';
-        delim = delim || '';
-        for (let i = 0, length = nodes.length; i < length; i++) {
-            buf += this.visit(nodes[i]);
-            if (delim && i < length - 1)
-                buf += delim;
-        }
-        return buf;
-    }
-    compile(node) {
-        return node.stylesheet
-            .rules.map(this.visit, this)
-            .join('');
-    }
-    comment() {
-        return '';
-    }
-    import(node) {
-        return '@import ' + node.import + ';';
-    }
-    media(node) {
-        const mediaCss = this.mapVisit(node.rules);
-        if (mediaCss === '') {
-            return '';
-        }
-        return '@media ' + node.media + '{' + this.mapVisit(node.rules) + '}';
-    }
-    document(node) {
-        const documentCss = this.mapVisit(node.rules);
-        if (documentCss === '') {
-            return '';
-        }
-        const doc = '@' + (node.vendor || '') + 'document ' + node.document;
-        return doc + '{' + documentCss + '}';
-    }
-    charset(node) {
-        return '@charset ' + node.charset + ';';
-    }
-    namespace(node) {
-        return '@namespace ' + node.namespace + ';';
-    }
-    supports(node) {
-        const supportsCss = this.mapVisit(node.rules);
-        if (supportsCss === '') {
-            return '';
-        }
-        return '@supports ' + node.supports + '{' + supportsCss + '}';
-    }
-    keyframes(node) {
-        const keyframesCss = this.mapVisit(node.keyframes);
-        if (keyframesCss === '') {
-            return '';
-        }
-        return '@' + (node.vendor || '') + 'keyframes ' + node.name + '{' + keyframesCss + '}';
-    }
-    keyframe(node) {
-        const decls = node.declarations;
-        return node.values.join(',') + '{' + this.mapVisit(decls) + '}';
-    }
-    page(node) {
-        const sel = node.selectors.length
-            ? node.selectors.join(', ')
-            : '';
-        return '@page ' + sel + '{' + this.mapVisit(node.declarations) + '}';
-    }
-    ['font-face'](node) {
-        const fontCss = this.mapVisit(node.declarations);
-        if (fontCss === '') {
-            return '';
-        }
-        return '@font-face{' + fontCss + '}';
-    }
-    host(node) {
-        return '@host{' + this.mapVisit(node.rules) + '}';
-    }
-    ['custom-media'](node) {
-        return '@custom-media ' + node.name + ' ' + node.media + ';';
-    }
-    rule(node) {
-        const decls = node.declarations;
-        if (decls == null || decls.length === 0) {
-            return '';
-        }
-        const usedSelectors = this.usedSelectors;
-        let i;
-        let j;
-        for (i = node.selectors.length - 1; i >= 0; i--) {
-            const sel = getSelectors(node.selectors[i]);
-            let include = true;
-            let jlen = sel.classNames.length;
-            if (jlen > 0 && this.hasUsedClassNames) {
-                for (j = 0; j < jlen; j++) {
-                    if (!usedSelectors.classNames.has(sel.classNames[j])) {
-                        include = false;
-                        break;
-                    }
-                }
-            }
-            if (include && this.hasUsedTags) {
-                jlen = sel.tags.length;
-                if (jlen > 0) {
-                    for (j = 0; j < jlen; j++) {
-                        if (!usedSelectors.tags.has(sel.tags[j])) {
-                            include = false;
-                            break;
-                        }
-                    }
-                }
-            }
-            if (include && this.hasUsedAttrs) {
-                jlen = sel.attrs.length;
-                if (jlen > 0) {
-                    for (j = 0; j < jlen; j++) {
-                        if (!usedSelectors.attrs.has(sel.attrs[j])) {
-                            include = false;
-                            break;
-                        }
-                    }
-                }
-            }
-            if (include && this.hasUsedIds) {
-                jlen = sel.ids.length;
-                if (jlen > 0) {
-                    for (j = 0; j < jlen; j++) {
-                        if (!usedSelectors.ids.has(sel.ids[j])) {
-                            include = false;
-                            break;
-                        }
-                    }
-                }
-            }
-            if (!include) {
-                node.selectors.splice(i, 1);
-            }
-        }
-        if (node.selectors.length === 0) {
-            return '';
-        }
-        return `${node.selectors}{${this.mapVisit(decls)}}`;
-    }
-    declaration(node) {
-        return node.property + ':' + node.value + ';';
-    }
-}
-
-class UsedSelectors {
-    constructor(elm) {
-        this.tags = new Set();
-        this.classNames = new Set();
-        this.ids = new Set();
-        this.attrs = new Set();
-        this.collectSelectors(elm);
-    }
-    collectSelectors(elm) {
-        if (elm != null && elm.tagName) {
-            const tagName = elm.tagName.toLowerCase();
-            this.tags.add(tagName);
-            const attributes = elm.attributes;
-            for (let i = 0, l = attributes.length; i < l; i++) {
-                const attr = attributes.item(i);
-                const attrName = attr.name.toLowerCase();
-                if (attrName === 'class') {
-                    const classList = elm.classList;
-                    for (let i = 0, l = classList.length; i < l; i++) {
-                        this.classNames.add(classList.item(i));
-                    }
-                }
-                else if (attrName === 'style') {
-                    continue;
-                }
-                else if (attrName === 'id') {
-                    this.ids.add(attr.value);
-                }
-                else {
-                    this.attrs.add(attrName);
-                }
-            }
-            for (let i = 0, l = elm.children.length; i < l; i++) {
-                this.collectSelectors(elm.children[i]);
-            }
-        }
-    }
-}
-
-function removeUnusedStyles(doc, diagnostics) {
-    const styleElms = doc.head.querySelectorAll(`style[data-styles]`);
-    if (styleElms.length > 0) {
-        const usedSelectors = new UsedSelectors(doc.body);
-        for (let i = 0; i < styleElms.length; i++) {
-            removeUnusedStyleText(usedSelectors, diagnostics, styleElms[i]);
-        }
-    }
-}
-function removeUnusedStyleText(usedSelectors, diagnostics, styleElm) {
-    try {
-        const cssAst = parseCss(styleElm.innerHTML);
-        if (cssAst.stylesheet.diagnostics.length > 0) {
-            diagnostics.push(...cssAst.stylesheet.diagnostics);
-            return;
-        }
-        try {
-            const stringify = new StringifyCss(usedSelectors);
-            styleElm.innerHTML = stringify.compile(cssAst);
-        }
-        catch (e) {
-            diagnostics.push({
-                level: 'warn',
-                type: 'css',
-                header: 'CSS Stringify',
-                messageText: e
-            });
-        }
-    }
-    catch (e) {
-        diagnostics.push({
-            level: 'warn',
-            type: 'css',
-            header: 'CSS Parse',
-            messageText: e
-        });
-    }
-}
-
-function updateCanonicalLink(doc, href) {
-    let canonicalLinkElm = doc.head.querySelector('link[rel="canonical"]');
-    if (typeof href === 'string') {
-        if (canonicalLinkElm == null) {
-            canonicalLinkElm = doc.createElement('link');
-            canonicalLinkElm.setAttribute('rel', 'canonical');
-            doc.head.appendChild(canonicalLinkElm);
-        }
-        canonicalLinkElm.setAttribute('href', href);
-    }
-    else {
-        if (canonicalLinkElm != null) {
-            canonicalLinkElm.parentNode.removeChild(canonicalLinkElm);
-        }
-    }
-}
-
-function renderToString(html, userOpts) {
-    const opts = normalizeHydrateOptions(userOpts);
-    opts.serializeToHtml = true;
-    return new Promise(resolve => {
-        const results = generateHydrateResults(opts);
-        if (results.diagnostics.length > 0) {
-            resolve(results);
-        }
-        else if (typeof html === 'string') {
-            try {
-                opts.destroyWindow = true;
-                opts.destroyDocument = true;
-                const win = new MockWindow(html);
-                render(win, opts, results, resolve);
-            }
-            catch (e) {
-                renderCatchError(results, e);
-                resolve(results);
-            }
-        }
-        else if (isValidDocument(html)) {
-            try {
-                opts.destroyDocument = false;
-                const win = patchDomImplementation(html, opts);
-                render(win, opts, results, resolve);
-            }
-            catch (e) {
-                renderCatchError(results, e);
-                resolve(results);
-            }
-        }
-        else {
-            renderBuildError(results, `Invalid html or document. Must be either valid "html" string, or DOM "document".`);
-            resolve(results);
-        }
-    });
-}
-function hydrateDocument(doc, userOpts) {
-    const opts = normalizeHydrateOptions(userOpts);
-    opts.serializeToHtml = false;
-    return new Promise(resolve => {
-        const results = generateHydrateResults(opts);
-        if (results.diagnostics.length > 0) {
-            resolve(results);
-        }
-        else if (typeof doc === 'string') {
-            try {
-                opts.destroyWindow = true;
-                opts.destroyDocument = true;
-                const win = new MockWindow(doc);
-                render(win, opts, results, resolve);
-            }
-            catch (e) {
-                renderCatchError(results, e);
-                resolve(results);
-            }
-        }
-        else if (isValidDocument(doc)) {
-            try {
-                opts.destroyDocument = false;
-                const win = patchDomImplementation(doc, opts);
-                render(win, opts, results, resolve);
-            }
-            catch (e) {
-                renderCatchError(results, e);
-                resolve(results);
-            }
-        }
-        else {
-            renderBuildError(results, `Invalid html or document. Must be either valid "html" string, or DOM "document".`);
-            resolve(results);
-        }
-    });
-}
-function isValidDocument(doc) {
-    return doc != null &&
-        doc.nodeType === 9 &&
-        doc.documentElement != null &&
-        doc.documentElement.nodeType === 1 &&
-        doc.body != null &&
-        doc.body.nodeType === 1;
-}
-function render(win, opts, results, resolve) {
-    if (!process.__rindoErrors) {
-        process.__rindoErrors = true;
-        process.on('unhandledRejection', e => {
-            console.log('unhandledRejection', e);
-        });
-    }
-    initializeWindow(win, opts, results);
-    if (typeof opts.beforeHydrate === 'function') {
-        try {
-            const rtn = opts.beforeHydrate(win.document);
-            if (rtn != null && typeof rtn.then === 'function') {
-                rtn.then(() => {
-                    hydrateFactory(win, opts, results, afterHydrate, resolve);
-                });
-            }
-            else {
-                hydrateFactory(win, opts, results, afterHydrate, resolve);
-            }
-        }
-        catch (e) {
-            renderCatchError(results, e);
-            finalizeHydrate(win, opts, results, resolve);
-        }
-    }
-    else {
-        hydrateFactory(win, opts, results, afterHydrate, resolve);
-    }
-}
-function afterHydrate(win, opts, results, resolve) {
-    if (typeof opts.afterHydrate === 'function') {
-        try {
-            const rtn = opts.afterHydrate(win.document);
-            if (rtn != null && typeof rtn.then === 'function') {
-                rtn.then(() => {
-                    finalizeHydrate(win, opts, results, resolve);
-                });
-            }
-            else {
-                finalizeHydrate(win, opts, results, resolve);
-            }
-        }
-        catch (e) {
-            renderCatchError(results, e);
-            finalizeHydrate(win, opts, results, resolve);
-        }
-    }
-    else {
-        finalizeHydrate(win, opts, results, resolve);
-    }
-}
-function finalizeHydrate(win, opts, results, resolve) {
-    try {
-        inspectElement(results, win.document.documentElement, 0);
-        if (opts.removeUnusedStyles !== false) {
-            try {
-                removeUnusedStyles(win.document, results.diagnostics);
-            }
-            catch (e) {
-                renderCatchError(results, e);
-            }
-        }
-        if (typeof opts.title === 'string') {
-            try {
-                win.document.title = opts.title;
-            }
-            catch (e) {
-                renderCatchError(results, e);
-            }
-        }
-        results.title = win.document.title;
-        if (opts.removeScripts) {
-            removeScripts(win.document.documentElement);
-        }
-        try {
-            updateCanonicalLink(win.document, opts.canonicalUrl);
-        }
-        catch (e) {
-            renderCatchError(results, e);
-        }
-        try {
-            relocateMetaCharset(win.document);
-        }
-        catch (e) { }
-        try {
-            const metaStatus = win.document.head.querySelector('meta[http-equiv="status"]');
-            if (metaStatus != null) {
-                const content = metaStatus.getAttribute('content');
-                if (content != null) {
-                    results.httpStatus = parseInt(content, 10);
-                }
-            }
-        }
-        catch (e) { }
-        if (opts.clientHydrateAnnotations) {
-            win.document.documentElement.classList.add('hydrated');
-        }
-        if (opts.serializeToHtml) {
-            results.html = serializeNodeToHtml(win.document, {
-                approximateLineWidth: opts.approximateLineWidth,
-                outerHtml: false,
-                prettyHtml: opts.prettyHtml,
-                removeAttributeQuotes: opts.removeAttributeQuotes,
-                removeBooleanAttributeQuotes: opts.removeBooleanAttributeQuotes,
-                removeEmptyAttributes: opts.removeEmptyAttributes,
-                removeHtmlComments: opts.removeHtmlComments,
-                serializeShadowRoot: false,
-            });
-        }
-    }
-    catch (e) {
-        renderCatchError(results, e);
-    }
-    if (opts.destroyWindow) {
-        try {
-            if (!opts.destroyDocument) {
-                const doc = win.document;
-                win.document = null;
-                doc.defaultView = null;
-            }
-            win.close();
-        }
-        catch (e) {
-            renderCatchError(results, e);
-        }
-    }
-    resolve(results);
-}
-function removeScripts(elm) {
-    const children = elm.children;
-    for (let i = children.length - 1; i >= 0; i--) {
-        const child = children[i];
-        removeScripts(child);
-        if (child.nodeName === 'SCRIPT') {
-            child.remove();
-        }
-        else if (child.nodeName === 'LINK' && child.getAttribute('rel') === 'modulepreload') {
-            child.remove();
-        }
-    }
-}
-
-export { hydrateDocument, renderToString };