isomorfeus-preact 10.5.0 → 10.5.4

data/node_modules/css-tree/lib/lexer/prepare-tokens.js

@@ -0,0 +1,73 @@
+var tokenize = require('../tokenizer');
+var TokenStream = require('../common/TokenStream');
+var tokenStream = new TokenStream();
+var astToTokens = {
+    decorator: function(handlers) {
+        var curNode = null;
+        var prev = { len: 0, node: null };
+        var nodes = [prev];
+        var buffer = '';
+
+        return {
+            children: handlers.children,
+            node: function(node) {
+                var tmp = curNode;
+                curNode = node;
+                handlers.node.call(this, node);
+                curNode = tmp;
+            },
+            chunk: function(chunk) {
+                buffer += chunk;
+                if (prev.node !== curNode) {
+                    nodes.push({
+                        len: chunk.length,
+                        node: curNode
+                    });
+                } else {
+                    prev.len += chunk.length;
+                }
+            },
+            result: function() {
+                return prepareTokens(buffer, nodes);
+            }
+        };
+    }
+};
+
+function prepareTokens(str, nodes) {
+    var tokens = [];
+    var nodesOffset = 0;
+    var nodesIndex = 0;
+    var currentNode = nodes ? nodes[nodesIndex].node : null;
+
+    tokenize(str, tokenStream);
+
+    while (!tokenStream.eof) {
+        if (nodes) {
+            while (nodesIndex < nodes.length && nodesOffset + nodes[nodesIndex].len <= tokenStream.tokenStart) {
+                nodesOffset += nodes[nodesIndex++].len;
+                currentNode = nodes[nodesIndex].node;
+            }
+        }
+
+        tokens.push({
+            type: tokenStream.tokenType,
+            value: tokenStream.getTokenValue(),
+            index: tokenStream.tokenIndex, // TODO: remove it, temporary solution
+            balance: tokenStream.balance[tokenStream.tokenIndex], // TODO: remove it, temporary solution
+            node: currentNode
+        });
+        tokenStream.next();
+        // console.log({ ...tokens[tokens.length - 1], node: undefined });
+    }
+
+    return tokens;
+}
+
+module.exports = function(value, syntax) {
+    if (typeof value === 'string') {
+        return prepareTokens(value, null);
+    }
+
+    return syntax.generate(value, astToTokens);
+};

data/node_modules/css-tree/lib/lexer/search.js

@@ -0,0 +1,65 @@
+var List = require('../common/List');
+
+function getFirstMatchNode(matchNode) {
+    if ('node' in matchNode) {
+        return matchNode.node;
+    }
+
+    return getFirstMatchNode(matchNode.match[0]);
+}
+
+function getLastMatchNode(matchNode) {
+    if ('node' in matchNode) {
+        return matchNode.node;
+    }
+
+    return getLastMatchNode(matchNode.match[matchNode.match.length - 1]);
+}
+
+function matchFragments(lexer, ast, match, type, name) {
+    function findFragments(matchNode) {
+        if (matchNode.syntax !== null &&
+            matchNode.syntax.type === type &&
+            matchNode.syntax.name === name) {
+            var start = getFirstMatchNode(matchNode);
+            var end = getLastMatchNode(matchNode);
+
+            lexer.syntax.walk(ast, function(node, item, list) {
+                if (node === start) {
+                    var nodes = new List();
+
+                    do {
+                        nodes.appendData(item.data);
+
+                        if (item.data === end) {
+                            break;
+                        }
+
+                        item = item.next;
+                    } while (item !== null);
+
+                    fragments.push({
+                        parent: list,
+                        nodes: nodes
+                    });
+                }
+            });
+        }
+
+        if (Array.isArray(matchNode.match)) {
+            matchNode.match.forEach(findFragments);
+        }
+    }
+
+    var fragments = [];
+
+    if (match.matched !== null) {
+        findFragments(match.matched);
+    }
+
+    return fragments;
+}
+
+module.exports = {
+    matchFragments: matchFragments
+};

data/node_modules/css-tree/lib/lexer/structure.js

@@ -0,0 +1,163 @@
+var List = require('../common/List');
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function isValidNumber(value) {
+    // Number.isInteger(value) && value >= 0
+    return (
+        typeof value === 'number' &&
+        isFinite(value) &&
+        Math.floor(value) === value &&
+        value >= 0
+    );
+}
+
+function isValidLocation(loc) {
+    return (
+        Boolean(loc) &&
+        isValidNumber(loc.offset) &&
+        isValidNumber(loc.line) &&
+        isValidNumber(loc.column)
+    );
+}
+
+function createNodeStructureChecker(type, fields) {
+    return function checkNode(node, warn) {
+        if (!node || node.constructor !== Object) {
+            return warn(node, 'Type of node should be an Object');
+        }
+
+        for (var key in node) {
+            var valid = true;
+
+            if (hasOwnProperty.call(node, key) === false) {
+                continue;
+            }
+
+            if (key === 'type') {
+                if (node.type !== type) {
+                    warn(node, 'Wrong node type `' + node.type + '`, expected `' + type + '`');
+                }
+            } else if (key === 'loc') {
+                if (node.loc === null) {
+                    continue;
+                } else if (node.loc && node.loc.constructor === Object) {
+                    if (typeof node.loc.source !== 'string') {
+                        key += '.source';
+                    } else if (!isValidLocation(node.loc.start)) {
+                        key += '.start';
+                    } else if (!isValidLocation(node.loc.end)) {
+                        key += '.end';
+                    } else {
+                        continue;
+                    }
+                }
+
+                valid = false;
+            } else if (fields.hasOwnProperty(key)) {
+                for (var i = 0, valid = false; !valid && i < fields[key].length; i++) {
+                    var fieldType = fields[key][i];
+
+                    switch (fieldType) {
+                        case String:
+                            valid = typeof node[key] === 'string';
+                            break;
+
+                        case Boolean:
+                            valid = typeof node[key] === 'boolean';
+                            break;
+
+                        case null:
+                            valid = node[key] === null;
+                            break;
+
+                        default:
+                            if (typeof fieldType === 'string') {
+                                valid = node[key] && node[key].type === fieldType;
+                            } else if (Array.isArray(fieldType)) {
+                                valid = node[key] instanceof List;
+                            }
+                    }
+                }
+            } else {
+                warn(node, 'Unknown field `' + key + '` for ' + type + ' node type');
+            }
+
+            if (!valid) {
+                warn(node, 'Bad value for `' + type + '.' + key + '`');
+            }
+        }
+
+        for (var key in fields) {
+            if (hasOwnProperty.call(fields, key) &&
+                hasOwnProperty.call(node, key) === false) {
+                warn(node, 'Field `' + type + '.' + key + '` is missed');
+            }
+        }
+    };
+}
+
+function processStructure(name, nodeType) {
+    var structure = nodeType.structure;
+    var fields = {
+        type: String,
+        loc: true
+    };
+    var docs = {
+        type: '"' + name + '"'
+    };
+
+    for (var key in structure) {
+        if (hasOwnProperty.call(structure, key) === false) {
+            continue;
+        }
+
+        var docsTypes = [];
+        var fieldTypes = fields[key] = Array.isArray(structure[key])
+            ? structure[key].slice()
+            : [structure[key]];
+
+        for (var i = 0; i < fieldTypes.length; i++) {
+            var fieldType = fieldTypes[i];
+            if (fieldType === String || fieldType === Boolean) {
+                docsTypes.push(fieldType.name);
+            } else if (fieldType === null) {
+                docsTypes.push('null');
+            } else if (typeof fieldType === 'string') {
+                docsTypes.push('<' + fieldType + '>');
+            } else if (Array.isArray(fieldType)) {
+                docsTypes.push('List'); // TODO: use type enum
+            } else {
+                throw new Error('Wrong value `' + fieldType + '` in `' + name + '.' + key + '` structure definition');
+            }
+        }
+
+        docs[key] = docsTypes.join(' | ');
+    }
+
+    return {
+        docs: docs,
+        check: createNodeStructureChecker(name, fields)
+    };
+}
+
+module.exports = {
+    getStructureFromConfig: function(config) {
+        var structure = {};
+
+        if (config.node) {
+            for (var name in config.node) {
+                if (hasOwnProperty.call(config.node, name)) {
+                    var nodeType = config.node[name];
+
+                    if (nodeType.structure) {
+                        structure[name] = processStructure(name, nodeType);
+                    } else {
+                        throw new Error('Missed `structure` field in `' + name + '` node type definition');
+                    }
+                }
+            }
+        }
+
+        return structure;
+    }
+};

data/node_modules/css-tree/lib/lexer/trace.js

@@ -0,0 +1,79 @@
+function getTrace(node) {
+    function shouldPutToTrace(syntax) {
+        if (syntax === null) {
+            return false;
+        }
+
+        return (
+            syntax.type === 'Type' ||
+            syntax.type === 'Property' ||
+            syntax.type === 'Keyword'
+        );
+    }
+
+    function hasMatch(matchNode) {
+        if (Array.isArray(matchNode.match)) {
+            // use for-loop for better perfomance
+            for (var i = 0; i < matchNode.match.length; i++) {
+                if (hasMatch(matchNode.match[i])) {
+                    if (shouldPutToTrace(matchNode.syntax)) {
+                        result.unshift(matchNode.syntax);
+                    }
+
+                    return true;
+                }
+            }
+        } else if (matchNode.node === node) {
+            result = shouldPutToTrace(matchNode.syntax)
+                ? [matchNode.syntax]
+                : [];
+
+            return true;
+        }
+
+        return false;
+    }
+
+    var result = null;
+
+    if (this.matched !== null) {
+        hasMatch(this.matched);
+    }
+
+    return result;
+}
+
+function testNode(match, node, fn) {
+    var trace = getTrace.call(match, node);
+
+    if (trace === null) {
+        return false;
+    }
+
+    return trace.some(fn);
+}
+
+function isType(node, type) {
+    return testNode(this, node, function(matchNode) {
+        return matchNode.type === 'Type' && matchNode.name === type;
+    });
+}
+
+function isProperty(node, property) {
+    return testNode(this, node, function(matchNode) {
+        return matchNode.type === 'Property' && matchNode.name === property;
+    });
+}
+
+function isKeyword(node) {
+    return testNode(this, node, function(matchNode) {
+        return matchNode.type === 'Keyword';
+    });
+}
+
+module.exports = {
+    getTrace: getTrace,
+    isType: isType,
+    isProperty: isProperty,
+    isKeyword: isKeyword
+};

data/node_modules/css-tree/lib/parser/create.js

@@ -0,0 +1,304 @@
+var OffsetToLocation = require('../common/OffsetToLocation');
+var SyntaxError = require('../common/SyntaxError');
+var TokenStream = require('../common/TokenStream');
+var List = require('../common/List');
+var tokenize = require('../tokenizer');
+var constants = require('../tokenizer/const');
+var { findWhiteSpaceStart, cmpStr } = require('../tokenizer/utils');
+var sequence = require('./sequence');
+var noop = function() {};
+
+var TYPE = constants.TYPE;
+var NAME = constants.NAME;
+var WHITESPACE = TYPE.WhiteSpace;
+var COMMENT = TYPE.Comment;
+var IDENT = TYPE.Ident;
+var FUNCTION = TYPE.Function;
+var URL = TYPE.Url;
+var HASH = TYPE.Hash;
+var PERCENTAGE = TYPE.Percentage;
+var NUMBER = TYPE.Number;
+var NUMBERSIGN = 0x0023; // U+0023 NUMBER SIGN (#)
+var NULL = 0;
+
+function createParseContext(name) {
+    return function() {
+        return this[name]();
+    };
+}
+
+function processConfig(config) {
+    var parserConfig = {
+        context: {},
+        scope: {},
+        atrule: {},
+        pseudo: {}
+    };
+
+    if (config.parseContext) {
+        for (var name in config.parseContext) {
+            switch (typeof config.parseContext[name]) {
+                case 'function':
+                    parserConfig.context[name] = config.parseContext[name];
+                    break;
+
+                case 'string':
+                    parserConfig.context[name] = createParseContext(config.parseContext[name]);
+                    break;
+            }
+        }
+    }
+
+    if (config.scope) {
+        for (var name in config.scope) {
+            parserConfig.scope[name] = config.scope[name];
+        }
+    }
+
+    if (config.atrule) {
+        for (var name in config.atrule) {
+            var atrule = config.atrule[name];
+
+            if (atrule.parse) {
+                parserConfig.atrule[name] = atrule.parse;
+            }
+        }
+    }
+
+    if (config.pseudo) {
+        for (var name in config.pseudo) {
+            var pseudo = config.pseudo[name];
+
+            if (pseudo.parse) {
+                parserConfig.pseudo[name] = pseudo.parse;
+            }
+        }
+    }
+
+    if (config.node) {
+        for (var name in config.node) {
+            parserConfig[name] = config.node[name].parse;
+        }
+    }
+
+    return parserConfig;
+}
+
+module.exports = function createParser(config) {
+    var parser = {
+        scanner: new TokenStream(),
+        locationMap: new OffsetToLocation(),
+
+        filename: '<unknown>',
+        needPositions: false,
+        onParseError: noop,
+        onParseErrorThrow: false,
+        parseAtrulePrelude: true,
+        parseRulePrelude: true,
+        parseValue: true,
+        parseCustomProperty: false,
+
+        readSequence: sequence,
+
+        createList: function() {
+            return new List();
+        },
+        createSingleNodeList: function(node) {
+            return new List().appendData(node);
+        },
+        getFirstListNode: function(list) {
+            return list && list.first();
+        },
+        getLastListNode: function(list) {
+            return list.last();
+        },
+
+        parseWithFallback: function(consumer, fallback) {
+            var startToken = this.scanner.tokenIndex;
+
+            try {
+                return consumer.call(this);
+            } catch (e) {
+                if (this.onParseErrorThrow) {
+                    throw e;
+                }
+
+                var fallbackNode = fallback.call(this, startToken);
+
+                this.onParseErrorThrow = true;
+                this.onParseError(e, fallbackNode);
+                this.onParseErrorThrow = false;
+
+                return fallbackNode;
+            }
+        },
+
+        lookupNonWSType: function(offset) {
+            do {
+                var type = this.scanner.lookupType(offset++);
+                if (type !== WHITESPACE) {
+                    return type;
+                }
+            } while (type !== NULL);
+
+            return NULL;
+        },
+
+        eat: function(tokenType) {
+            if (this.scanner.tokenType !== tokenType) {
+                var offset = this.scanner.tokenStart;
+                var message = NAME[tokenType] + ' is expected';
+
+                // tweak message and offset
+                switch (tokenType) {
+                    case IDENT:
+                        // when identifier is expected but there is a function or url
+                        if (this.scanner.tokenType === FUNCTION || this.scanner.tokenType === URL) {
+                            offset = this.scanner.tokenEnd - 1;
+                            message = 'Identifier is expected but function found';
+                        } else {
+                            message = 'Identifier is expected';
+                        }
+                        break;
+
+                    case HASH:
+                        if (this.scanner.isDelim(NUMBERSIGN)) {
+                            this.scanner.next();
+                            offset++;
+                            message = 'Name is expected';
+                        }
+                        break;
+
+                    case PERCENTAGE:
+                        if (this.scanner.tokenType === NUMBER) {
+                            offset = this.scanner.tokenEnd;
+                            message = 'Percent sign is expected';
+                        }
+                        break;
+
+                    default:
+                        // when test type is part of another token show error for current position + 1
+                        // e.g. eat(HYPHENMINUS) will fail on "-foo", but pointing on "-" is odd
+                        if (this.scanner.source.charCodeAt(this.scanner.tokenStart) === tokenType) {
+                            offset = offset + 1;
+                        }
+                }
+
+                this.error(message, offset);
+            }
+
+            this.scanner.next();
+        },
+
+        consume: function(tokenType) {
+            var value = this.scanner.getTokenValue();
+
+            this.eat(tokenType);
+
+            return value;
+        },
+        consumeFunctionName: function() {
+            var name = this.scanner.source.substring(this.scanner.tokenStart, this.scanner.tokenEnd - 1);
+
+            this.eat(FUNCTION);
+
+            return name;
+        },
+
+        getLocation: function(start, end) {
+            if (this.needPositions) {
+                return this.locationMap.getLocationRange(
+                    start,
+                    end,
+                    this.filename
+                );
+            }
+
+            return null;
+        },
+        getLocationFromList: function(list) {
+            if (this.needPositions) {
+                var head = this.getFirstListNode(list);
+                var tail = this.getLastListNode(list);
+                return this.locationMap.getLocationRange(
+                    head !== null ? head.loc.start.offset - this.locationMap.startOffset : this.scanner.tokenStart,
+                    tail !== null ? tail.loc.end.offset - this.locationMap.startOffset : this.scanner.tokenStart,
+                    this.filename
+                );
+            }
+
+            return null;
+        },
+
+        error: function(message, offset) {
+            var location = typeof offset !== 'undefined' && offset < this.scanner.source.length
+                ? this.locationMap.getLocation(offset)
+                : this.scanner.eof
+                    ? this.locationMap.getLocation(findWhiteSpaceStart(this.scanner.source, this.scanner.source.length - 1))
+                    : this.locationMap.getLocation(this.scanner.tokenStart);
+
+            throw new SyntaxError(
+                message || 'Unexpected input',
+                this.scanner.source,
+                location.offset,
+                location.line,
+                location.column
+            );
+        }
+    };
+
+    config = processConfig(config || {});
+    for (var key in config) {
+        parser[key] = config[key];
+    }
+
+    return function(source, options) {
+        options = options || {};
+
+        var context = options.context || 'default';
+        var onComment = options.onComment;
+        var ast;
+
+        tokenize(source, parser.scanner);
+        parser.locationMap.setSource(
+            source,
+            options.offset,
+            options.line,
+            options.column
+        );
+
+        parser.filename = options.filename || '<unknown>';
+        parser.needPositions = Boolean(options.positions);
+        parser.onParseError = typeof options.onParseError === 'function' ? options.onParseError : noop;
+        parser.onParseErrorThrow = false;
+        parser.parseAtrulePrelude = 'parseAtrulePrelude' in options ? Boolean(options.parseAtrulePrelude) : true;
+        parser.parseRulePrelude = 'parseRulePrelude' in options ? Boolean(options.parseRulePrelude) : true;
+        parser.parseValue = 'parseValue' in options ? Boolean(options.parseValue) : true;
+        parser.parseCustomProperty = 'parseCustomProperty' in options ? Boolean(options.parseCustomProperty) : false;
+
+        if (!parser.context.hasOwnProperty(context)) {
+            throw new Error('Unknown context `' + context + '`');
+        }
+
+        if (typeof onComment === 'function') {
+            parser.scanner.forEachToken((type, start, end) => {
+                if (type === COMMENT) {
+                    const loc = parser.getLocation(start, end);
+                    const value = cmpStr(source, end - 2, end, '*/')
+                        ? source.slice(start + 2, end - 2)
+                        : source.slice(start + 2, end);
+
+                    onComment(value, loc);
+                }
+            });
+        }
+
+        ast = parser.context[context].call(parser, options);
+
+        if (!parser.scanner.eof) {
+            parser.error();
+        }
+
+        return ast;
+    };
+};