@utrecht/web-component-library-stencil 1.0.0-alpha.243 → 1.0.0-alpha.246

package/dist/collection/node_modules/css-tree/lib/lexer/search.js

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

package/dist/collection/node_modules/css-tree/lib/lexer/structure.js

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

package/dist/collection/node_modules/css-tree/lib/lexer/trace.js

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

package/dist/collection/node_modules/css-tree/lib/parser/create.js

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

package/dist/collection/node_modules/css-tree/lib/parser/index.js

@@ -1,4 +0,0 @@
-var createParser = require('./create');
-var config = require('../syntax/config/parser');
-
-module.exports = createParser(config);

package/dist/collection/node_modules/css-tree/lib/parser/sequence.js

@@ -1,54 +0,0 @@
-var TYPE = require('../tokenizer').TYPE;
-var WHITESPACE = TYPE.WhiteSpace;
-var COMMENT = TYPE.Comment;
-
-module.exports = function readSequence(recognizer) {
-    var children = this.createList();
-    var child = null;
-    var context = {
-        recognizer: recognizer,
-        space: null,
-        ignoreWS: false,
-        ignoreWSAfter: false
-    };
-
-    this.scanner.skipSC();
-
-    while (!this.scanner.eof) {
-        switch (this.scanner.tokenType) {
-            case COMMENT:
-                this.scanner.next();
-                continue;
-
-            case WHITESPACE:
-                if (context.ignoreWS) {
-                    this.scanner.next();
-                } else {
-                    context.space = this.WhiteSpace();
-                }
-                continue;
-        }
-
-        child = recognizer.getNode.call(this, context);
-
-        if (child === undefined) {
-            break;
-        }
-
-        if (context.space !== null) {
-            children.push(context.space);
-            context.space = null;
-        }
-
-        children.push(child);
-
-        if (context.ignoreWSAfter) {
-            context.ignoreWSAfter = false;
-            context.ignoreWS = true;
-        } else {
-            context.ignoreWS = false;
-        }
-    }
-
-    return children;
-};

package/dist/collection/node_modules/css-tree/lib/syntax/atrule/font-face.js

@@ -1,8 +0,0 @@
-module.exports = {
-    parse: {
-        prelude: null,
-        block: function() {
-            return this.Block(true);
-        }
-    }
-};