@utrecht/web-component-library-stencil 1.0.0-alpha.23 → 1.0.0-alpha.232

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

@@ -0,0 +1,66 @@
+var sourceMap = require('./sourceMap');
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function processChildren(node, delimeter) {
+    var list = node.children;
+    var prev = null;
+
+    if (typeof delimeter !== 'function') {
+        list.forEach(this.node, this);
+    } else {
+        list.forEach(function(node) {
+            if (prev !== null) {
+                delimeter.call(this, prev);
+            }
+
+            this.node(node);
+            prev = node;
+        }, this);
+    }
+}
+
+module.exports = function createGenerator(config) {
+    function processNode(node) {
+        if (hasOwnProperty.call(types, node.type)) {
+            types[node.type].call(this, node);
+        } else {
+            throw new Error('Unknown node type: ' + node.type);
+        }
+    }
+
+    var types = {};
+
+    if (config.node) {
+        for (var name in config.node) {
+            types[name] = config.node[name].generate;
+        }
+    }
+
+    return function(node, options) {
+        var buffer = '';
+        var handlers = {
+            children: processChildren,
+            node: processNode,
+            chunk: function(chunk) {
+                buffer += chunk;
+            },
+            result: function() {
+                return buffer;
+            }
+        };
+
+        if (options) {
+            if (typeof options.decorator === 'function') {
+                handlers = options.decorator(handlers);
+            }
+
+            if (options.sourceMap) {
+                handlers = sourceMap(handlers);
+            }
+        }
+
+        handlers.node(node);
+
+        return handlers.result();
+    };
+};

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

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

package/dist/collection/node_modules/css-tree/lib/generator/sourceMap.js

@@ -0,0 +1,95 @@
+var SourceMapGenerator = require('source-map/lib/source-map-generator').SourceMapGenerator;
+var trackNodes = {
+    Atrule: true,
+    Selector: true,
+    Declaration: true
+};
+
+module.exports = function generateSourceMap(handlers) {
+    var map = new SourceMapGenerator();
+    var line = 1;
+    var column = 0;
+    var generated = {
+        line: 1,
+        column: 0
+    };
+    var original = {
+        line: 0, // should be zero to add first mapping
+        column: 0
+    };
+    var sourceMappingActive = false;
+    var activatedGenerated = {
+        line: 1,
+        column: 0
+    };
+    var activatedMapping = {
+        generated: activatedGenerated
+    };
+
+    var handlersNode = handlers.node;
+    handlers.node = function(node) {
+        if (node.loc && node.loc.start && trackNodes.hasOwnProperty(node.type)) {
+            var nodeLine = node.loc.start.line;
+            var nodeColumn = node.loc.start.column - 1;
+
+            if (original.line !== nodeLine ||
+                original.column !== nodeColumn) {
+                original.line = nodeLine;
+                original.column = nodeColumn;
+
+                generated.line = line;
+                generated.column = column;
+
+                if (sourceMappingActive) {
+                    sourceMappingActive = false;
+                    if (generated.line !== activatedGenerated.line ||
+                        generated.column !== activatedGenerated.column) {
+                        map.addMapping(activatedMapping);
+                    }
+                }
+
+                sourceMappingActive = true;
+                map.addMapping({
+                    source: node.loc.source,
+                    original: original,
+                    generated: generated
+                });
+            }
+        }
+
+        handlersNode.call(this, node);
+
+        if (sourceMappingActive && trackNodes.hasOwnProperty(node.type)) {
+            activatedGenerated.line = line;
+            activatedGenerated.column = column;
+        }
+    };
+
+    var handlersChunk = handlers.chunk;
+    handlers.chunk = function(chunk) {
+        for (var i = 0; i < chunk.length; i++) {
+            if (chunk.charCodeAt(i) === 10) { // \n
+                line++;
+                column = 0;
+            } else {
+                column++;
+            }
+        }
+
+        handlersChunk(chunk);
+    };
+
+    var handlersResult = handlers.result;
+    handlers.result = function() {
+        if (sourceMappingActive) {
+            map.addMapping(activatedMapping);
+        }
+
+        return {
+            css: handlersResult(),
+            map: map
+        };
+    };
+
+    return handlers;
+};

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

@@ -0,0 +1 @@
+module.exports = require('./syntax');

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

@@ -0,0 +1,466 @@
+var SyntaxReferenceError = require('./error').SyntaxReferenceError;
+var SyntaxMatchError = require('./error').SyntaxMatchError;
+var names = require('../utils/names');
+var generic = require('./generic');
+var parse = require('../definition-syntax/parse');
+var generate = require('../definition-syntax/generate');
+var walk = require('../definition-syntax/walk');
+var prepareTokens = require('./prepare-tokens');
+var buildMatchGraph = require('./match-graph').buildMatchGraph;
+var matchAsTree = require('./match').matchAsTree;
+var trace = require('./trace');
+var search = require('./search');
+var getStructureFromConfig = require('./structure').getStructureFromConfig;
+var cssWideKeywords = buildMatchGraph('inherit | initial | unset');
+var cssWideKeywordsWithExpression = buildMatchGraph('inherit | initial | unset | <-ms-legacy-expression>');
+
+function dumpMapSyntax(map, compact, syntaxAsAst) {
+    var result = {};
+
+    for (var name in map) {
+        if (map[name].syntax) {
+            result[name] = syntaxAsAst
+                ? map[name].syntax
+                : generate(map[name].syntax, { compact: compact });
+        }
+    }
+
+    return result;
+}
+
+function dumpAtruleMapSyntax(map, compact, syntaxAsAst) {
+    const result = {};
+
+    for (const [name, atrule] of Object.entries(map)) {
+        result[name] = {
+            prelude: atrule.prelude && (
+                syntaxAsAst
+                    ? atrule.prelude.syntax
+                    : generate(atrule.prelude.syntax, { compact })
+            ),
+            descriptors: atrule.descriptors && dumpMapSyntax(atrule.descriptors, compact, syntaxAsAst)
+        };
+    }
+
+    return result;
+}
+
+function valueHasVar(tokens) {
+    for (var i = 0; i < tokens.length; i++) {
+        if (tokens[i].value.toLowerCase() === 'var(') {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+function buildMatchResult(match, error, iterations) {
+    return {
+        matched: match,
+        iterations: iterations,
+        error: error,
+        getTrace: trace.getTrace,
+        isType: trace.isType,
+        isProperty: trace.isProperty,
+        isKeyword: trace.isKeyword
+    };
+}
+
+function matchSyntax(lexer, syntax, value, useCommon) {
+    var tokens = prepareTokens(value, lexer.syntax);
+    var result;
+
+    if (valueHasVar(tokens)) {
+        return buildMatchResult(null, new Error('Matching for a tree with var() is not supported'));
+    }
+
+    if (useCommon) {
+        result = matchAsTree(tokens, lexer.valueCommonSyntax, lexer);
+    }
+
+    if (!useCommon || !result.match) {
+        result = matchAsTree(tokens, syntax.match, lexer);
+        if (!result.match) {
+            return buildMatchResult(
+                null,
+                new SyntaxMatchError(result.reason, syntax.syntax, value, result),
+                result.iterations
+            );
+        }
+    }
+
+    return buildMatchResult(result.match, null, result.iterations);
+}
+
+var Lexer = function(config, syntax, structure) {
+    this.valueCommonSyntax = cssWideKeywords;
+    this.syntax = syntax;
+    this.generic = false;
+    this.atrules = {};
+    this.properties = {};
+    this.types = {};
+    this.structure = structure || getStructureFromConfig(config);
+
+    if (config) {
+        if (config.types) {
+            for (var name in config.types) {
+                this.addType_(name, config.types[name]);
+            }
+        }
+
+        if (config.generic) {
+            this.generic = true;
+            for (var name in generic) {
+                this.addType_(name, generic[name]);
+            }
+        }
+
+        if (config.atrules) {
+            for (var name in config.atrules) {
+                this.addAtrule_(name, config.atrules[name]);
+            }
+        }
+
+        if (config.properties) {
+            for (var name in config.properties) {
+                this.addProperty_(name, config.properties[name]);
+            }
+        }
+    }
+};
+
+Lexer.prototype = {
+    structure: {},
+    checkStructure: function(ast) {
+        function collectWarning(node, message) {
+            warns.push({
+                node: node,
+                message: message
+            });
+        }
+
+        var structure = this.structure;
+        var warns = [];
+
+        this.syntax.walk(ast, function(node) {
+            if (structure.hasOwnProperty(node.type)) {
+                structure[node.type].check(node, collectWarning);
+            } else {
+                collectWarning(node, 'Unknown node type `' + node.type + '`');
+            }
+        });
+
+        return warns.length ? warns : false;
+    },
+
+    createDescriptor: function(syntax, type, name, parent = null) {
+        var ref = {
+            type: type,
+            name: name
+        };
+        var descriptor = {
+            type: type,
+            name: name,
+            parent: parent,
+            syntax: null,
+            match: null
+        };
+
+        if (typeof syntax === 'function') {
+            descriptor.match = buildMatchGraph(syntax, ref);
+        } else {
+            if (typeof syntax === 'string') {
+                // lazy parsing on first access
+                Object.defineProperty(descriptor, 'syntax', {
+                    get: function() {
+                        Object.defineProperty(descriptor, 'syntax', {
+                            value: parse(syntax)
+                        });
+
+                        return descriptor.syntax;
+                    }
+                });
+            } else {
+                descriptor.syntax = syntax;
+            }
+
+            // lazy graph build on first access
+            Object.defineProperty(descriptor, 'match', {
+                get: function() {
+                    Object.defineProperty(descriptor, 'match', {
+                        value: buildMatchGraph(descriptor.syntax, ref)
+                    });
+
+                    return descriptor.match;
+                }
+            });
+        }
+
+        return descriptor;
+    },
+    addAtrule_: function(name, syntax) {
+        if (!syntax) {
+            return;
+        }
+
+        this.atrules[name] = {
+            type: 'Atrule',
+            name: name,
+            prelude: syntax.prelude ? this.createDescriptor(syntax.prelude, 'AtrulePrelude', name) : null,
+            descriptors: syntax.descriptors
+                ? Object.keys(syntax.descriptors).reduce((res, descName) => {
+                    res[descName] = this.createDescriptor(syntax.descriptors[descName], 'AtruleDescriptor', descName, name);
+                    return res;
+                }, {})
+                : null
+        };
+    },
+    addProperty_: function(name, syntax) {
+        if (!syntax) {
+            return;
+        }
+
+        this.properties[name] = this.createDescriptor(syntax, 'Property', name);
+    },
+    addType_: function(name, syntax) {
+        if (!syntax) {
+            return;
+        }
+
+        this.types[name] = this.createDescriptor(syntax, 'Type', name);
+
+        if (syntax === generic['-ms-legacy-expression']) {
+            this.valueCommonSyntax = cssWideKeywordsWithExpression;
+        }
+    },
+
+    checkAtruleName: function(atruleName) {
+        if (!this.getAtrule(atruleName)) {
+            return new SyntaxReferenceError('Unknown at-rule', '@' + atruleName);
+        }
+    },
+    checkAtrulePrelude: function(atruleName, prelude) {
+        let error = this.checkAtruleName(atruleName);
+
+        if (error) {
+            return error;
+        }
+
+        var atrule = this.getAtrule(atruleName);
+
+        if (!atrule.prelude && prelude) {
+            return new SyntaxError('At-rule `@' + atruleName + '` should not contain a prelude');
+        }
+
+        if (atrule.prelude && !prelude) {
+            return new SyntaxError('At-rule `@' + atruleName + '` should contain a prelude');
+        }
+    },
+    checkAtruleDescriptorName: function(atruleName, descriptorName) {
+        let error = this.checkAtruleName(atruleName);
+
+        if (error) {
+            return error;
+        }
+
+        var atrule = this.getAtrule(atruleName);
+        var descriptor = names.keyword(descriptorName);
+
+        if (!atrule.descriptors) {
+            return new SyntaxError('At-rule `@' + atruleName + '` has no known descriptors');
+        }
+
+        if (!atrule.descriptors[descriptor.name] &&
+            !atrule.descriptors[descriptor.basename]) {
+            return new SyntaxReferenceError('Unknown at-rule descriptor', descriptorName);
+        }
+    },
+    checkPropertyName: function(propertyName) {
+        var property = names.property(propertyName);
+
+        // don't match syntax for a custom property
+        if (property.custom) {
+            return new Error('Lexer matching doesn\'t applicable for custom properties');
+        }
+
+        if (!this.getProperty(propertyName)) {
+            return new SyntaxReferenceError('Unknown property', propertyName);
+        }
+    },
+
+    matchAtrulePrelude: function(atruleName, prelude) {
+        var error = this.checkAtrulePrelude(atruleName, prelude);
+
+        if (error) {
+            return buildMatchResult(null, error);
+        }
+
+        if (!prelude) {
+            return buildMatchResult(null, null);
+        }
+
+        return matchSyntax(this, this.getAtrule(atruleName).prelude, prelude, false);
+    },
+    matchAtruleDescriptor: function(atruleName, descriptorName, value) {
+        var error = this.checkAtruleDescriptorName(atruleName, descriptorName);
+
+        if (error) {
+            return buildMatchResult(null, error);
+        }
+
+        var atrule = this.getAtrule(atruleName);
+        var descriptor = names.keyword(descriptorName);
+
+        return matchSyntax(this, atrule.descriptors[descriptor.name] || atrule.descriptors[descriptor.basename], value, false);
+    },
+    matchDeclaration: function(node) {
+        if (node.type !== 'Declaration') {
+            return buildMatchResult(null, new Error('Not a Declaration node'));
+        }
+
+        return this.matchProperty(node.property, node.value);
+    },
+    matchProperty: function(propertyName, value) {
+        var error = this.checkPropertyName(propertyName);
+
+        if (error) {
+            return buildMatchResult(null, error);
+        }
+
+        return matchSyntax(this, this.getProperty(propertyName), value, true);
+    },
+    matchType: function(typeName, value) {
+        var typeSyntax = this.getType(typeName);
+
+        if (!typeSyntax) {
+            return buildMatchResult(null, new SyntaxReferenceError('Unknown type', typeName));
+        }
+
+        return matchSyntax(this, typeSyntax, value, false);
+    },
+    match: function(syntax, value) {
+        if (typeof syntax !== 'string' && (!syntax || !syntax.type)) {
+            return buildMatchResult(null, new SyntaxReferenceError('Bad syntax'));
+        }
+
+        if (typeof syntax === 'string' || !syntax.match) {
+            syntax = this.createDescriptor(syntax, 'Type', 'anonymous');
+        }
+
+        return matchSyntax(this, syntax, value, false);
+    },
+
+    findValueFragments: function(propertyName, value, type, name) {
+        return search.matchFragments(this, value, this.matchProperty(propertyName, value), type, name);
+    },
+    findDeclarationValueFragments: function(declaration, type, name) {
+        return search.matchFragments(this, declaration.value, this.matchDeclaration(declaration), type, name);
+    },
+    findAllFragments: function(ast, type, name) {
+        var result = [];
+
+        this.syntax.walk(ast, {
+            visit: 'Declaration',
+            enter: function(declaration) {
+                result.push.apply(result, this.findDeclarationValueFragments(declaration, type, name));
+            }.bind(this)
+        });
+
+        return result;
+    },
+
+    getAtrule: function(atruleName, fallbackBasename = true) {
+        var atrule = names.keyword(atruleName);
+        var atruleEntry = atrule.vendor && fallbackBasename
+            ? this.atrules[atrule.name] || this.atrules[atrule.basename]
+            : this.atrules[atrule.name];
+
+        return atruleEntry || null;
+    },
+    getAtrulePrelude: function(atruleName, fallbackBasename = true) {
+        const atrule = this.getAtrule(atruleName, fallbackBasename);
+
+        return atrule && atrule.prelude || null;
+    },
+    getAtruleDescriptor: function(atruleName, name) {
+        return this.atrules.hasOwnProperty(atruleName) && this.atrules.declarators
+            ? this.atrules[atruleName].declarators[name] || null
+            : null;
+    },
+    getProperty: function(propertyName, fallbackBasename = true) {
+        var property = names.property(propertyName);
+        var propertyEntry = property.vendor && fallbackBasename
+            ? this.properties[property.name] || this.properties[property.basename]
+            : this.properties[property.name];
+
+        return propertyEntry || null;
+    },
+    getType: function(name) {
+        return this.types.hasOwnProperty(name) ? this.types[name] : null;
+    },
+
+    validate: function() {
+        function validate(syntax, name, broken, descriptor) {
+            if (broken.hasOwnProperty(name)) {
+                return broken[name];
+            }
+
+            broken[name] = false;
+            if (descriptor.syntax !== null) {
+                walk(descriptor.syntax, function(node) {
+                    if (node.type !== 'Type' && node.type !== 'Property') {
+                        return;
+                    }
+
+                    var map = node.type === 'Type' ? syntax.types : syntax.properties;
+                    var brokenMap = node.type === 'Type' ? brokenTypes : brokenProperties;
+
+                    if (!map.hasOwnProperty(node.name) || validate(syntax, node.name, brokenMap, map[node.name])) {
+                        broken[name] = true;
+                    }
+                }, this);
+            }
+        }
+
+        var brokenTypes = {};
+        var brokenProperties = {};
+
+        for (var key in this.types) {
+            validate(this, key, brokenTypes, this.types[key]);
+        }
+
+        for (var key in this.properties) {
+            validate(this, key, brokenProperties, this.properties[key]);
+        }
+
+        brokenTypes = Object.keys(brokenTypes).filter(function(name) {
+            return brokenTypes[name];
+        });
+        brokenProperties = Object.keys(brokenProperties).filter(function(name) {
+            return brokenProperties[name];
+        });
+
+        if (brokenTypes.length || brokenProperties.length) {
+            return {
+                types: brokenTypes,
+                properties: brokenProperties
+            };
+        }
+
+        return null;
+    },
+    dump: function(syntaxAsAst, pretty) {
+        return {
+            generic: this.generic,
+            types: dumpMapSyntax(this.types, !pretty, syntaxAsAst),
+            properties: dumpMapSyntax(this.properties, !pretty, syntaxAsAst),
+            atrules: dumpAtruleMapSyntax(this.atrules, !pretty, syntaxAsAst)
+        };
+    },
+    toString: function() {
+        return JSON.stringify(this.dump());
+    }
+};
+
+module.exports = Lexer;