@rindo/core 1.8.12

package/dist/hydrate/index.mjs

@@ -0,0 +1,1281 @@
+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 };