isomorfeus-preact 10.5.0 → 10.5.4

data/node_modules/nano-css/addon/keyframes.d.ts

@@ -0,0 +1,34 @@
+import {NanoRenderer} from '../types/nano';
+
+export interface KeyframesAddon {
+    /**
+     * @param frames Map of keyframes.
+     * @param block Optional semantic name.
+     *
+     * Returns a generated animation name.
+     *
+     * ```js
+     * const animationName = nano.keyframes({
+     *     from: {
+     *         left: '0%',
+     *     },
+     *     to: {
+     *         left: '100%',
+     *     },
+     * });
+     * ```
+     *
+     * You need to install [`keyframes()` addon]()https://github.com/streamich/nano-css/blob/master/docs/keyframes.md) to use this method.
+     *
+     * ```js
+     * import {create} from 'nano-css';
+     * import {addon as addonKeyframes} from 'nano-css/addon/keyframes';
+     *
+     * const nano = create();
+     * addonKeyframes(nano);
+     * ```
+     */
+    keyframes: (frames: object, block?: string) => string;
+}
+
+export function addon(nano: NanoRenderer);

data/node_modules/nano-css/addon/keyframes.js

@@ -0,0 +1,61 @@
+'use strict';
+
+exports.addon = function (renderer, config) {
+    if (process.env.NODE_ENV !== 'production') {
+        require('./__dev__/warnOnMissingDependencies')('keyframes', renderer, ['putRaw', 'put']);
+    }
+
+    config = renderer.assign({
+        prefixes: ['-webkit-', '-moz-', '-o-', ''],
+    }, config || {});
+
+    var prefixes = config.prefixes;
+
+    if (renderer.client) {
+        // Craete @keyframe Stylesheet `ksh`.
+        document.head.appendChild(renderer.ksh = document.createElement('style'));
+    }
+
+    var putAt = renderer.putAt;
+
+    renderer.putAt = function (__, keyframes, prelude) {
+        // @keyframes
+        if (prelude[1] === 'k') {
+            var str = '';
+
+            for (var keyframe in keyframes) {
+                var decls = keyframes[keyframe];
+                var strDecls = '';
+
+                for (var prop in decls)
+                    strDecls += renderer.decl(prop, decls[prop]);
+
+                str += keyframe + '{' + strDecls + '}';
+            }
+
+            for (var i = 0; i < prefixes.length; i++) {
+                var prefix = prefixes[i];
+                var rawKeyframes = prelude.replace('@keyframes', '@' + prefix + 'keyframes') + '{' + str + '}';
+
+                if (renderer.client) {
+                    renderer.ksh.appendChild(document.createTextNode(rawKeyframes));
+                } else {
+                    renderer.putRaw(rawKeyframes);
+                }
+            }
+
+            return;
+        }
+
+        putAt(__, keyframes, prelude);
+    };
+
+    renderer.keyframes = function (keyframes, block) {
+        if (!block) block = renderer.hash(keyframes);
+        block = renderer.pfx + block;
+
+        renderer.putAt('', keyframes, '@keyframes ' + block);
+
+        return block;
+    };
+};

data/node_modules/nano-css/addon/limit.js

@@ -0,0 +1,26 @@
+'use strict';
+
+exports.addon = function (renderer, limit) {
+    limit = limit || 50000;
+
+    if (process.env.NODE_ENV !== 'production') {
+        require('./__dev__/warnOnMissingDependencies')('limit', renderer, ['putRaw']);
+    }
+
+    if (!renderer.client) {
+        var putRaw = renderer.putRaw;
+
+        renderer.putRaw = function (rawCssRule) {
+            if (renderer.raw.length + rawCssRule.length > limit) {
+                /* eslint-disable */
+                console.info('CSS was not injected, because total CSS would go over ' + limit + ' byte limit.');
+                console.log(rawCssRule);
+                /* eslint-enable */
+
+                return;
+            }
+
+            putRaw(rawCssRule);
+        };
+    }
+};

data/node_modules/nano-css/addon/nesting.js

@@ -0,0 +1,37 @@
+'use strict';
+
+exports.addon = function (renderer) {
+    renderer.selector = function (parentSelectors, selector) {
+        var parents = parentSelectors.split(',');
+        var result = [];
+        var selectors = selector.split(',');
+        var len1 = parents.length;
+        var len2 = selectors.length;
+        var i, j, sel, pos, parent, replacedSelector;
+
+        for (i = 0; i < len2; i++) {
+            sel = selectors[i];
+            pos = sel.indexOf('&');
+
+            if (pos > -1) {
+                for (j = 0; j < len1; j++) {
+                    parent = parents[j];
+                    replacedSelector = sel.replace(/&/g, parent);
+                    result.push(replacedSelector);
+                }
+            } else {
+                for (j = 0; j < len1; j++) {
+                    parent = parents[j];
+
+                    if (parent) {
+                        result.push(parent + ' ' + sel);
+                    } else {
+                        result.push(sel);
+                    }
+                }
+            }
+        }
+
+        return result.join(',');
+    };
+};

data/node_modules/nano-css/addon/pipe.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var addonCssom = require('./cssom').addon;
+
+exports.addon = function (renderer) {
+    if (!renderer.putRule) {
+        addonCssom(renderer);
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+        require('./__dev__/warnOnMissingDependencies')('pipe', renderer, ['createRule']);
+    }
+
+    var counter = 0;
+
+    renderer.pipe = function () {
+        var rules = {};
+        var className = renderer.pfx + 'pipe-' + (counter++).toString(36);
+        var attr = 'data-' + className;
+        var scope1 = '.' + className;
+        var scope2 = '[' + attr + ']';
+
+        var obj = {
+            attr: attr,
+            className: className,
+            css: function (css) {
+                for (var selectorTemplate in css) {
+                    var declarations = css[selectorTemplate];
+                    var rule = rules[selectorTemplate];
+
+                    if (!rule) {
+                        var selector = selectorTemplate.replace('&', scope1) + ',' + selectorTemplate.replace('&', scope2);
+
+                        rules[selectorTemplate] = rule = renderer.putRule(selector);
+                    }
+
+                    for (var prop in declarations)
+                        rule.style.setProperty(prop, declarations[prop]);
+                }
+
+                // GC
+                for (var selectorTemplate2 in rules) {
+                    if (!(selectorTemplate2 in css)) {
+                        rules[selectorTemplate2].remove();
+                        delete rules[selectorTemplate2];
+                    }
+                }
+            },
+            remove: function () {
+                for (var selectorTemplate in rules)
+                    renderer.sh.deleteRule(rule.index);
+            }
+        };
+
+        return obj;
+    };
+};

data/node_modules/nano-css/addon/prefixer.js

@@ -0,0 +1,79 @@
+'use strict';
+
+var prefix = require('inline-style-prefixer').prefix;
+
+var CAMEL_REGEX = /-[a-z\u00E0-\u00F6\u00F8-\u00FE]/g;
+
+var matchCallback = function (match) {
+    return match.slice(1).toUpperCase();
+};
+
+exports.addon = function (renderer) {
+    var decl = renderer.decl;
+    var origPut = renderer.put;
+
+    renderer.camel = function (prop) {
+        return prop.replace(CAMEL_REGEX, matchCallback);
+    };
+
+    renderer.prefix = function (prop, value) {
+        var obj = {};
+        obj[renderer.camel(prop)] = value;
+        obj = prefix(obj);
+
+        var result = {};
+
+        for (var propPrefixed in obj) {
+            value = obj[propPrefixed];
+            if (propPrefixed.slice(0, 2) === 'ms') {
+                propPrefixed = 'M' + propPrefixed.slice(1);
+            }
+            propPrefixed = renderer.kebab(propPrefixed);
+
+            if (value instanceof Array) {
+                result[propPrefixed] = value.join(';' + propPrefixed + ':');
+            } else {
+                result[propPrefixed] = value;
+            }
+        }
+
+        return result;
+    };
+
+    renderer.decl = function (prop, value) {
+        var result = renderer.prefix(prop, value);
+
+        var returned = '';
+        Object.keys(result).forEach(function (key) {
+            var str = decl(key, value);
+            returned += str;
+        });
+
+        return returned;
+    };
+
+    function newPut(selector, decls, atrule) {
+        var indexed = selector.indexOf('::placeholder');
+        if (indexed > -1) {
+            var split = selector.split(',');
+            if (split.length > 1) {
+                split.forEach(function(sp) {
+                    newPut(sp.trim(), decls, atrule);
+                });
+                return;
+            }
+            var bareSelect = selector.substring(0, indexed);
+            [
+                '::-webkit-input-placeholder',
+                '::-moz-placeholder',
+                ':-ms-input-placeholder',
+                ':-moz-placeholder'
+            ].forEach(function(ph) {
+                origPut(bareSelect + ph, decls, atrule);
+            });
+        }
+        origPut(selector, decls, atrule);
+    }
+
+    renderer.put = newPut;
+};

data/node_modules/nano-css/addon/ref.js

@@ -0,0 +1,87 @@
+'use strict';
+
+var addonPipe = require('./pipe').addon;
+
+// eslint-disable-next-line no-undef
+var sNano = typeof Symbol === 'object' ? Symbol('nano-css') : '@@nano-css';
+
+exports.addon = function (renderer) {
+    if (!renderer.pipe) {
+        addonPipe(renderer);
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+        require('./__dev__/warnOnMissingDependencies')('ref', renderer, ['pipe']);
+    }
+
+    renderer.createRef = function () {
+        var pipe = renderer.pipe();
+        var el = null;
+        var ref = function (element) {
+            if (el) el = element;
+            else {
+                el = null;
+                pipe.remove();
+            }
+        };
+        var obj = {ref: ref};
+
+        obj[pipe.attr] = '';
+
+        return function (css) {
+            pipe.css(css);
+            return obj;
+        };
+    };
+
+    renderer.ref = function (css, originalRef) {
+        if (process.env.NODE_ENV !== 'production') {
+            if (originalRef && typeof originalRef !== 'function') {
+                console.error(
+                    'nano-css "ref" function expects argument to be a ref function, "' + (typeof originalRef) + '" provided.'
+                );
+            }
+        }
+
+        var obj = {
+            ref: function (el) {
+                if (originalRef) originalRef(el);
+                if (!el) return;
+
+                var pipe = el[sNano];
+
+                if (!pipe) {
+                    el[sNano] = pipe = renderer.pipe();
+                    el.setAttribute(pipe.attr, '');
+
+                    // Add unmount logic
+
+                    var observer = new MutationObserver(function (mutations) {
+                        for (var i = 0; i < mutations.length; i++) {
+                            var mutation = mutations[i];
+
+                            if (mutation.removedNodes.length) {
+                                var nodes = mutation.removedNodes;
+
+                                for (var j = 0; j < nodes.length; j++) {
+                                    if (nodes[j] === el) {
+                                        pipe.remove();
+                                        delete el[sNano];
+                                        observer.disconnect();
+                                        return;
+                                    }
+                                }
+                            }
+                        }
+                    });
+
+                    observer.observe(el.parentNode, {childList: true});
+                }
+
+                pipe.css(css);
+            }
+        };
+
+        return obj;
+    };
+};

data/node_modules/nano-css/addon/reset/EricMeyer.js

@@ -0,0 +1,48 @@
+'use strict';
+
+exports.addon = function (renderer) {
+    if (process.env.NODE_ENV !== 'production') {
+        require('../__dev__/warnOnMissingDependencies')('reset', renderer, ['put']);
+    }
+
+    var css = {
+        'html,body,div,span,applet,object,iframe,table,caption,tbody,tfoot,thead,tr,th,td,del,dfn,em,font,img,ins,kbd,q,s,samp,small,strike,strong,sub,sup,tt,var,h1,h2,h3,h4,h5,h6,p,blockquote,pre,a,abbr,acronym,address,big,cite,code,dl,dt,dd,ol,ul,li,fieldset,form,label,legend': {
+            'vertical-align': 'baseline',
+            ff: 'inherit',
+            fw: 'inherit',
+            fs: 'inherit',
+            fz: '100%',
+            out: 0,
+            pad: 0,
+            mar: 0,
+            bd: 0,
+        },
+        ':focus': {
+            out: 0,
+        },
+        body: {
+            bg: 'white',
+            lh: 1,
+            col: 'black',
+        },
+        'ol, ul': {
+            'list-style': 'none',
+        },
+        table: {
+            'border-collapse': 'separate',
+            'border-spacing': 0,
+        },
+        'caption, th, td': {
+            fw: 'normal',
+            ta: 'left',
+        },
+        'blockquote:before, blockquote:after, q:before, q:after': {
+            content: '""',
+        },
+        'blockquote, q': {
+            quotes: '"" ""',
+        },
+    };
+
+    renderer.put('', css);
+};

data/node_modules/nano-css/addon/reset/EricMeyerCondensed.js

@@ -0,0 +1,44 @@
+'use strict';
+
+exports.addon = function (renderer) {
+    if (process.env.NODE_ENV !== 'production') {
+        require('../__dev__/warnOnMissingDependencies')('reset', renderer, ['put']);
+    }
+
+    var css = {
+        'body,div,dl,dt,dd,ul,ol,li,h1,h2,h3,h4,h5,h6,pre,form,fieldset,input,textarea,p,blockquote,th,td': {
+            pad: 0,
+            mar: 0,
+        },
+        'fieldset, img': {
+            bd: 0,
+        },
+        table: {
+            'border-collapse': 'collapse',
+            'border-spacing': 0,
+        },
+        'ol, ul': {
+            'list-style': 'none',
+        },
+        'address, caption, cite, code, dfn, em, strong, th, var': {
+            fw: 'normal',
+            fs: 'normal',
+        },
+        'caption, th': {
+            ta: 'left',
+        },
+        'h1, h2, h3, h4, h5, h6': {
+            fw: 'normal',
+            fs: '100%',
+        },
+        'q:before, q:after': {
+            con: "''",
+        },
+        'abbr, acronym': {
+            bd: 0,
+        },
+    };
+
+    renderer.put('', css);
+};
+