isomorfeus-preact 10.5.0 → 10.5.4

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

@@ -0,0 +1,177 @@
+'use strict';
+
+var emmet = (exports.emmet = {
+    // Visual Formatting;
+    pos: 'position',
+    t: 'top',
+    r: 'right',
+    b: 'bottom',
+    l: 'left',
+    z: 'z-index',
+    fl: 'float',
+    cl: 'clear',
+    d: 'display',
+    v: 'visibility',
+    ov: 'overflow',
+    ovx: 'overflow-x',
+    ovy: 'overflow-y',
+    ovs: 'overflow-style',
+    zm: 'zoom',
+    cp: 'clip',
+    rsz: 'resize',
+    cur: 'cursor',
+    // Margin & Padding;
+    m: 'margin',
+    mt: 'margin-top',
+    mr: 'margin-right',
+    mb: 'margin-bottom',
+    ml: 'margin-left',
+    p: 'padding',
+    pt: 'padding-top',
+    pr: 'padding-right',
+    pb: 'padding-bottom',
+    pl: 'padding-left',
+    // Box Sizing;
+    bxz: 'box-sizing',
+    bxsh: 'box-shadow',
+    w: 'width',
+    h: 'height',
+    maw: 'max-width',
+    mah: 'max-height',
+    miw: 'min-width',
+    mih: 'min-height',
+    // Font;
+    f: 'font',
+    fw: 'font-weight',
+    fs: 'font-style',
+    fv: 'font-variant',
+    fz: 'font-size',
+    ff: 'font-family',
+    fsm: 'font-smooth',
+    fst: 'font-stretch',
+    // Text;
+    va: 'vertical-align',
+    ta: 'text-align',
+    td: 'text-decoration',
+    te: 'text-emphasis',
+    ti: 'text-indent',
+    tj: 'text-justify',
+    tt: 'text-transform',
+    tsh: 'text-shadow',
+    lh: 'line-height',
+    lts: 'letter-spacing',
+    whs: 'white-space',
+    wob: 'word-break',
+    wos: 'word-spacing',
+    wow: 'word-wrap',
+    // Background;
+    bg: 'background',
+    bgc: 'background-color',
+    bgi: 'background-image',
+    bgr: 'background-repeat',
+    bga: 'background-attachment',
+    bgp: 'background-position',
+    bgpx: 'background-position-x',
+    bgpy: 'background-position-y',
+    bgcp: 'background-clip',
+    bgo: 'background-origin',
+    bgsz: 'background-size',
+    // Color;
+    c: 'color',
+    op: 'opacity',
+    // Generated Content;
+    ct: 'content',
+    q: 'quotes',
+    coi: 'counter-increment',
+    cor: 'counter-reset',
+    // Outline;
+    ol: 'outline',
+    olo: 'outline-offset',
+    olw: 'outline-width',
+    ols: 'outline-style',
+    olc: 'outline-color',
+    // Tables;
+    tbl: 'table-layout',
+    cps: 'caption-side',
+    ec: 'empty-cells',
+    // Border;
+    bd: 'border',
+    bdcl: 'border-collapse',
+    bdc: 'border-color',
+    bdi: 'border-image',
+    bds: 'border-style',
+    bdw: 'border-width',
+    bdt: 'border-top',
+    bdtw: 'border-top-width',
+    bdts: 'border-top-style',
+    bdtc: 'border-top-color',
+    bdr: 'border-right',
+    bdrw: 'border-right-width',
+    bdrst: 'border-right-style',
+    bdrc: 'border-right-color',
+    bdb: 'border-bottom',
+    bdbw: 'border-bottom-width',
+    bdbs: 'border-bottom-style',
+    bdbc: 'border-bottom-color',
+    bdl: 'border-left',
+    bdlw: 'border-left-width',
+    bdls: 'border-left-style',
+    bdlc: 'border-left-color',
+    bdrs: 'border-radius',
+    bdtlrs: 'border-top-left-radius',
+    bdtrrs: 'border-top-right-radius',
+    bdbrrs: 'border-bottom-right-radius',
+    bdblrs: 'border-bottom-left-radius',
+    // Lists;
+    lis: 'list-style',
+    lisp: 'list-style-position',
+    list: 'list-style-type',
+    lisi: 'list-style-image',
+    // Flexbox Parent/Child Properties;
+    ac: 'align-content',
+    ai: 'align-items',
+    as: 'align-self',
+    jc: 'justify-content',
+    fx: 'flex',
+    fxb: 'flex-basis',
+    fxd: 'flex-direction',
+    fxf: 'flex-flow',
+    fxg: 'flex-grow',
+    fxs: 'flex-shrink',
+    fxw: 'flex-wrap',
+    ord: 'order',
+    // CSS Grid Layout;
+    colm: 'columns',
+    colmc: 'column-count',
+    colmf: 'column-fill',
+    colmg: 'column-gap',
+    colmr: 'column-rule',
+    colmrc: 'column-rule-color',
+    colmrs: 'column-rule-style',
+    colmrw: 'column-rule-width',
+    colms: 'column-span',
+    colmw: 'column-width',
+    // CSS Transitions;
+    trf: 'transform',
+    trfo: 'transform-origin',
+    trfs: 'transform-style',
+    trs: 'transition',
+    trsde: 'transition-delay',
+    trsdu: 'transition-duration',
+    trsp: 'transition-property',
+    trstf: 'transition-timing-function',
+    // Others;
+    bfv: 'backface-visibility',
+    tov: 'text-overflow',
+    mar: 'max-resolution',
+    mir: 'min-resolution',
+    ori: 'orientation',
+    us: 'user-select',
+});
+
+exports.addon = function(renderer) {
+    var originalDecl = renderer.decl;
+    renderer.decl = function(key, value) {
+        return originalDecl(emmet[key] || key, value);
+    };
+};

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

@@ -0,0 +1,5 @@
+import {NanoRenderer} from '../types/nano';
+
+export interface ExtractAddon {}
+
+export function addon(nano: NanoRenderer);

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

@@ -0,0 +1,59 @@
+'use strict';
+
+exports.addon = function (renderer) {
+    if (renderer.client) {
+        console.error(
+            'You are running nano-css "extract" addon in browser. ' +
+            'You should use it ONLY on server and ONLY at build time.'
+        );
+
+        return;
+    }
+
+    var sheet = renderer.sheet;
+
+    // eslint-disable-next-line no-unused-vars
+    var dummy;
+
+    // Evaluate all lazy-evaluated sheet() styles.
+    if (sheet) {
+        renderer.sheet = function (map) {
+            var styles = sheet.apply(this, arguments);
+
+            for (var name in map) dummy = styles[name];
+
+            return styles;
+        };
+    }
+
+    var jsx = renderer.jsx;
+
+    // Render jsx component once to extract its static CSS.
+    if (jsx) {
+        renderer.jsx = function () {
+            var jsxComponent = jsx.apply(this, arguments);
+
+            process.nextTick(function () {
+                jsxComponent(jsxComponent.defaultProps || {});
+            });
+
+            return jsxComponent;
+        };
+    }
+
+    var style = renderer.style;
+
+    // Render styled component once with default props
+    // to extract its static CSS and "default" dynamic CSS.
+    if (style) {
+        renderer.style = function () {
+            var styledComponent = style.apply(this, arguments);
+
+            process.nextTick(function () {
+                styledComponent(styledComponent.defaultProps || {});
+            });
+
+            return styledComponent;
+        };
+    }
+};

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

@@ -0,0 +1,8 @@
+import {NanoRenderer} from '../types/nano';
+import {CssLikeObject} from '../types/common';
+
+export interface GlobalAddon {
+    global(css: CssLikeObject);
+}
+
+export function addon(nano: NanoRenderer);

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

@@ -0,0 +1,19 @@
+'use strict';
+
+exports.addon = function (renderer) {
+    if (process.env.NODE_ENV !== 'production') {
+        require('./__dev__/warnOnMissingDependencies')('global', renderer, ['put']);
+    }
+
+    var selector = renderer.selector;
+
+    renderer.selector = function (parent, current) {
+        if (parent.indexOf(':global') > -1) parent = '';
+
+        return selector(parent, current);
+    };
+
+    renderer.global = function (css) {
+        return renderer.put('', css);
+    };
+};

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

@@ -0,0 +1,8 @@
+import {NanoRenderer} from '../types/nano';
+import {CssLikeObject} from '../types/common';
+
+export interface GoogleFontAddon {
+    googleFont(font: string, weights: number | string | (number | string)[], subsets: string | string[]);
+}
+
+export function addon(nano: NanoRenderer);

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

@@ -0,0 +1,43 @@
+'use strict';
+
+function createUrl (font, weights, subsets) {
+    var params = '?family=' + encodeURIComponent(font);
+
+    if (weights) {
+        if (!(weights instanceof Array))
+            weights = [weights];
+
+        params += ':' + weights.join(',');
+    }
+
+    if (subsets) {
+        if (!(subsets instanceof Array))
+            subsets = [subsets];
+
+        params += '&subset=' + subsets.join(',');
+    }
+
+    return 'https://fonts.googleapis.com/css' + params;
+}
+
+exports.addon = function (renderer) {
+    if (process.env.NODE_ENV !== 'production') {
+        require('./__dev__/warnOnMissingDependencies')('hydrate', renderer, ['put']);
+    }
+
+    if (renderer.client) {
+        renderer.googleFont = function (font, weights, subsets) {
+            var el = document.createElement('link');
+
+            el.href = createUrl(font, weights, subsets);
+            el.rel = 'stylesheet';
+            el.type = 'text/css';
+
+            document.head.appendChild(el);
+        };
+    } else {
+        renderer.googleFont = function (font, weights, subsets) {
+            renderer.putRaw("@import url('" + createUrl(font, weights, subsets) + "');");
+        };
+    }
+};

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

@@ -0,0 +1,7 @@
+import {NanoRenderer} from '../types/nano';
+
+export interface HydrateAddon {
+    hydrate(sh: HTMLStyleElement);
+}
+
+export function addon(nano: NanoRenderer);

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

@@ -0,0 +1,28 @@
+'use strict';
+
+exports.addon = function (renderer) {
+    if (process.env.NODE_ENV !== 'production') {
+        require('./__dev__/warnOnMissingDependencies')('hydrate', renderer, ['put']);
+    }
+
+    var hydrated = {};
+
+    renderer.hydrate = function (sh) {
+        var cssRules = sh.cssRules || sh.sheet.cssRules;
+
+        for (var i = 0; i < cssRules.length; i++)
+            hydrated[cssRules[i].selectorText] = 1;
+    };
+
+    if (renderer.client) {
+        if (renderer.sh) renderer.hydrate(renderer.sh);
+
+        var put = renderer.put;
+
+        renderer.put = function (selector, css) {
+            if (selector in hydrated) return;
+
+            put(selector, css);
+        };
+    }
+};

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

@@ -0,0 +1,27 @@
+'use strict';
+
+exports.addon = function (renderer) {
+    if (process.env.NODE_ENV !== 'production') {
+        require('./__dev__/warnOnMissingDependencies')('hyperstyle', renderer, ['sheet']);
+    }
+
+    renderer.hyperstyle = function (map, block) {
+        var styles = renderer.sheet(map, block);
+
+        return function (type, props) {
+            if (props) {
+                var styleName = props.styleName;
+
+                if (styleName) {
+                    var className = styles[styleName];
+
+                    if (className) {
+                        props.className = (props.className || '') + className;
+                    }
+                }
+            }
+
+            return renderer.h.apply(null, arguments);
+        };
+    };
+};

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

@@ -0,0 +1,38 @@
+'use strict';
+
+function hasImportant (rawDecl) {
+    var parts = rawDecl.split(' ');
+
+    for (var i = 0; i < parts.length; i++) {
+        var part = parts[i].trim();
+
+        if (part === '!important') return true;
+    }
+
+    return false;
+}
+
+exports.addon = function (renderer) {
+    var decl = renderer.decl;
+
+    renderer.decl = function (prop, value) {
+        var rawDecl = decl(prop, value);
+        var decls = rawDecl.split(';');
+        var css = '';
+
+        for (var i = 0; i < decls.length; i++) {
+            rawDecl = decls[i].trim();
+
+            if (!rawDecl) continue;
+
+            // Don't add "!important" if it is already added.
+            if (!hasImportant(rawDecl)) {
+                css += rawDecl + ' !important;';
+            } else {
+                css += rawDecl + ';';
+            }
+        }
+
+        return css;
+    };
+};

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

@@ -0,0 +1,60 @@
+'use strict';
+
+var addonCache = require('./cache').addon;
+
+exports.addon = function (renderer) {
+    if (!renderer.cache) {
+        addonCache(renderer);
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+        require('./__dev__/warnOnMissingDependencies')('jsx', renderer, ['rule', 'cache']);
+    }
+
+    renderer.jsx = function (fn, styles, block) {
+        var className;
+        var isElement = typeof fn === 'string';
+
+        // In dev mode emit CSS immediately so correct sourcemaps can be generated.
+        if (process.env.NODE_ENV !== 'production') {
+            className = renderer.rule(styles, block);
+        }
+
+        var Component = function (props) {
+            if (!className) {
+                className = renderer.rule(styles, block);
+            }
+
+            var copy = props;
+            var $as = copy.$as;
+            var $ref = copy.$ref;
+
+            if (process.env.NODE_ENV !== 'production') {
+                copy = renderer.assign({}, props);
+            }
+
+            var dynamicClassName = renderer.cache(props.css);
+            delete copy.css;
+            delete copy.$as;
+
+            if (isElement || $as) {
+                delete copy.$ref;
+                copy.ref = $ref;
+            }
+
+            copy.className = (props.className || '') + className + dynamicClassName;
+
+            return (isElement || $as)
+                ? renderer.h($as || fn, copy)
+                : fn(copy);
+        };
+
+        if (process.env.NODE_ENV !== 'production') {
+            if (block) {
+                Component.displayName = 'jsx(' + block + ')';
+            }
+        }
+
+        return Component;
+    };
+};