@utrecht/web-component-library-stencil 1.0.0-alpha.21 → 1.0.0-alpha.212

package/dist/collection/node_modules/css-tree/lib/syntax/node/AnPlusB.js

@@ -0,0 +1,297 @@
+var cmpChar = require('../../tokenizer').cmpChar;
+var isDigit = require('../../tokenizer').isDigit;
+var TYPE = require('../../tokenizer').TYPE;
+
+var WHITESPACE = TYPE.WhiteSpace;
+var COMMENT = TYPE.Comment;
+var IDENT = TYPE.Ident;
+var NUMBER = TYPE.Number;
+var DIMENSION = TYPE.Dimension;
+var PLUSSIGN = 0x002B;    // U+002B PLUS SIGN (+)
+var HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)
+var N = 0x006E;           // U+006E LATIN SMALL LETTER N (n)
+var DISALLOW_SIGN = true;
+var ALLOW_SIGN = false;
+
+function checkInteger(offset, disallowSign) {
+    var pos = this.scanner.tokenStart + offset;
+    var code = this.scanner.source.charCodeAt(pos);
+
+    if (code === PLUSSIGN || code === HYPHENMINUS) {
+        if (disallowSign) {
+            this.error('Number sign is not allowed');
+        }
+        pos++;
+    }
+
+    for (; pos < this.scanner.tokenEnd; pos++) {
+        if (!isDigit(this.scanner.source.charCodeAt(pos))) {
+            this.error('Integer is expected', pos);
+        }
+    }
+}
+
+function checkTokenIsInteger(disallowSign) {
+    return checkInteger.call(this, 0, disallowSign);
+}
+
+function expectCharCode(offset, code) {
+    if (!cmpChar(this.scanner.source, this.scanner.tokenStart + offset, code)) {
+        var msg = '';
+
+        switch (code) {
+            case N:
+                msg = 'N is expected';
+                break;
+            case HYPHENMINUS:
+                msg = 'HyphenMinus is expected';
+                break;
+        }
+
+        this.error(msg, this.scanner.tokenStart + offset);
+    }
+}
+
+// ... <signed-integer>
+// ... ['+' | '-'] <signless-integer>
+function consumeB() {
+    var offset = 0;
+    var sign = 0;
+    var type = this.scanner.tokenType;
+
+    while (type === WHITESPACE || type === COMMENT) {
+        type = this.scanner.lookupType(++offset);
+    }
+
+    if (type !== NUMBER) {
+        if (this.scanner.isDelim(PLUSSIGN, offset) ||
+            this.scanner.isDelim(HYPHENMINUS, offset)) {
+            sign = this.scanner.isDelim(PLUSSIGN, offset) ? PLUSSIGN : HYPHENMINUS;
+
+            do {
+                type = this.scanner.lookupType(++offset);
+            } while (type === WHITESPACE || type === COMMENT);
+
+            if (type !== NUMBER) {
+                this.scanner.skip(offset);
+                checkTokenIsInteger.call(this, DISALLOW_SIGN);
+            }
+        } else {
+            return null;
+        }
+    }
+
+    if (offset > 0) {
+        this.scanner.skip(offset);
+    }
+
+    if (sign === 0) {
+        type = this.scanner.source.charCodeAt(this.scanner.tokenStart);
+        if (type !== PLUSSIGN && type !== HYPHENMINUS) {
+            this.error('Number sign is expected');
+        }
+    }
+
+    checkTokenIsInteger.call(this, sign !== 0);
+    return sign === HYPHENMINUS ? '-' + this.consume(NUMBER) : this.consume(NUMBER);
+}
+
+// An+B microsyntax https://www.w3.org/TR/css-syntax-3/#anb
+module.exports = {
+    name: 'AnPlusB',
+    structure: {
+        a: [String, null],
+        b: [String, null]
+    },
+    parse: function() {
+        /* eslint-disable brace-style*/
+        var start = this.scanner.tokenStart;
+        var a = null;
+        var b = null;
+
+        // <integer>
+        if (this.scanner.tokenType === NUMBER) {
+            checkTokenIsInteger.call(this, ALLOW_SIGN);
+            b = this.consume(NUMBER);
+        }
+
+        // -n
+        // -n <signed-integer>
+        // -n ['+' | '-'] <signless-integer>
+        // -n- <signless-integer>
+        // <dashndashdigit-ident>
+        else if (this.scanner.tokenType === IDENT && cmpChar(this.scanner.source, this.scanner.tokenStart, HYPHENMINUS)) {
+            a = '-1';
+
+            expectCharCode.call(this, 1, N);
+
+            switch (this.scanner.getTokenLength()) {
+                // -n
+                // -n <signed-integer>
+                // -n ['+' | '-'] <signless-integer>
+                case 2:
+                    this.scanner.next();
+                    b = consumeB.call(this);
+                    break;
+
+                // -n- <signless-integer>
+                case 3:
+                    expectCharCode.call(this, 2, HYPHENMINUS);
+
+                    this.scanner.next();
+                    this.scanner.skipSC();
+
+                    checkTokenIsInteger.call(this, DISALLOW_SIGN);
+
+                    b = '-' + this.consume(NUMBER);
+                    break;
+
+                // <dashndashdigit-ident>
+                default:
+                    expectCharCode.call(this, 2, HYPHENMINUS);
+                    checkInteger.call(this, 3, DISALLOW_SIGN);
+                    this.scanner.next();
+
+                    b = this.scanner.substrToCursor(start + 2);
+            }
+        }
+
+        // '+'? n
+        // '+'? n <signed-integer>
+        // '+'? n ['+' | '-'] <signless-integer>
+        // '+'? n- <signless-integer>
+        // '+'? <ndashdigit-ident>
+        else if (this.scanner.tokenType === IDENT || (this.scanner.isDelim(PLUSSIGN) && this.scanner.lookupType(1) === IDENT)) {
+            var sign = 0;
+            a = '1';
+
+            // just ignore a plus
+            if (this.scanner.isDelim(PLUSSIGN)) {
+                sign = 1;
+                this.scanner.next();
+            }
+
+            expectCharCode.call(this, 0, N);
+
+            switch (this.scanner.getTokenLength()) {
+                // '+'? n
+                // '+'? n <signed-integer>
+                // '+'? n ['+' | '-'] <signless-integer>
+                case 1:
+                    this.scanner.next();
+                    b = consumeB.call(this);
+                    break;
+
+                // '+'? n- <signless-integer>
+                case 2:
+                    expectCharCode.call(this, 1, HYPHENMINUS);
+
+                    this.scanner.next();
+                    this.scanner.skipSC();
+
+                    checkTokenIsInteger.call(this, DISALLOW_SIGN);
+
+                    b = '-' + this.consume(NUMBER);
+                    break;
+
+                // '+'? <ndashdigit-ident>
+                default:
+                    expectCharCode.call(this, 1, HYPHENMINUS);
+                    checkInteger.call(this, 2, DISALLOW_SIGN);
+                    this.scanner.next();
+
+                    b = this.scanner.substrToCursor(start + sign + 1);
+            }
+        }
+
+        // <ndashdigit-dimension>
+        // <ndash-dimension> <signless-integer>
+        // <n-dimension>
+        // <n-dimension> <signed-integer>
+        // <n-dimension> ['+' | '-'] <signless-integer>
+        else if (this.scanner.tokenType === DIMENSION) {
+            var code = this.scanner.source.charCodeAt(this.scanner.tokenStart);
+            var sign = code === PLUSSIGN || code === HYPHENMINUS;
+
+            for (var i = this.scanner.tokenStart + sign; i < this.scanner.tokenEnd; i++) {
+                if (!isDigit(this.scanner.source.charCodeAt(i))) {
+                    break;
+                }
+            }
+
+            if (i === this.scanner.tokenStart + sign) {
+                this.error('Integer is expected', this.scanner.tokenStart + sign);
+            }
+
+            expectCharCode.call(this, i - this.scanner.tokenStart, N);
+            a = this.scanner.source.substring(start, i);
+
+            // <n-dimension>
+            // <n-dimension> <signed-integer>
+            // <n-dimension> ['+' | '-'] <signless-integer>
+            if (i + 1 === this.scanner.tokenEnd) {
+                this.scanner.next();
+                b = consumeB.call(this);
+            } else {
+                expectCharCode.call(this, i - this.scanner.tokenStart + 1, HYPHENMINUS);
+
+                // <ndash-dimension> <signless-integer>
+                if (i + 2 === this.scanner.tokenEnd) {
+                    this.scanner.next();
+                    this.scanner.skipSC();
+                    checkTokenIsInteger.call(this, DISALLOW_SIGN);
+                    b = '-' + this.consume(NUMBER);
+                }
+                // <ndashdigit-dimension>
+                else {
+                    checkInteger.call(this, i - this.scanner.tokenStart + 2, DISALLOW_SIGN);
+                    this.scanner.next();
+                    b = this.scanner.substrToCursor(i + 1);
+                }
+            }
+        } else {
+            this.error();
+        }
+
+        if (a !== null && a.charCodeAt(0) === PLUSSIGN) {
+            a = a.substr(1);
+        }
+
+        if (b !== null && b.charCodeAt(0) === PLUSSIGN) {
+            b = b.substr(1);
+        }
+
+        return {
+            type: 'AnPlusB',
+            loc: this.getLocation(start, this.scanner.tokenStart),
+            a: a,
+            b: b
+        };
+    },
+    generate: function(node) {
+        var a = node.a !== null && node.a !== undefined;
+        var b = node.b !== null && node.b !== undefined;
+
+        if (a) {
+            this.chunk(
+                node.a === '+1' ? '+n' : // eslint-disable-line operator-linebreak, indent
+                node.a ===  '1' ?  'n' : // eslint-disable-line operator-linebreak, indent
+                node.a === '-1' ? '-n' : // eslint-disable-line operator-linebreak, indent
+                node.a + 'n'             // eslint-disable-line operator-linebreak, indent
+            );
+
+            if (b) {
+                b = String(node.b);
+                if (b.charAt(0) === '-' || b.charAt(0) === '+') {
+                    this.chunk(b.charAt(0));
+                    this.chunk(b.substr(1));
+                } else {
+                    this.chunk('+');
+                    this.chunk(b);
+                }
+            }
+        } else {
+            this.chunk(String(node.b));
+        }
+    }
+};

package/dist/collection/node_modules/css-tree/lib/syntax/node/Atrule.js

@@ -0,0 +1,107 @@
+var TYPE = require('../../tokenizer').TYPE;
+var rawMode = require('./Raw').mode;
+
+var ATKEYWORD = TYPE.AtKeyword;
+var SEMICOLON = TYPE.Semicolon;
+var LEFTCURLYBRACKET = TYPE.LeftCurlyBracket;
+var RIGHTCURLYBRACKET = TYPE.RightCurlyBracket;
+
+function consumeRaw(startToken) {
+    return this.Raw(startToken, rawMode.leftCurlyBracketOrSemicolon, true);
+}
+
+function isDeclarationBlockAtrule() {
+    for (var offset = 1, type; type = this.scanner.lookupType(offset); offset++) {
+        if (type === RIGHTCURLYBRACKET) {
+            return true;
+        }
+
+        if (type === LEFTCURLYBRACKET ||
+            type === ATKEYWORD) {
+            return false;
+        }
+    }
+
+    return false;
+}
+
+module.exports = {
+    name: 'Atrule',
+    structure: {
+        name: String,
+        prelude: ['AtrulePrelude', 'Raw', null],
+        block: ['Block', null]
+    },
+    parse: function() {
+        var start = this.scanner.tokenStart;
+        var name;
+        var nameLowerCase;
+        var prelude = null;
+        var block = null;
+
+        this.eat(ATKEYWORD);
+
+        name = this.scanner.substrToCursor(start + 1);
+        nameLowerCase = name.toLowerCase();
+        this.scanner.skipSC();
+
+        // parse prelude
+        if (this.scanner.eof === false &&
+            this.scanner.tokenType !== LEFTCURLYBRACKET &&
+            this.scanner.tokenType !== SEMICOLON) {
+            if (this.parseAtrulePrelude) {
+                prelude = this.parseWithFallback(this.AtrulePrelude.bind(this, name), consumeRaw);
+
+                // turn empty AtrulePrelude into null
+                if (prelude.type === 'AtrulePrelude' && prelude.children.head === null) {
+                    prelude = null;
+                }
+            } else {
+                prelude = consumeRaw.call(this, this.scanner.tokenIndex);
+            }
+
+            this.scanner.skipSC();
+        }
+
+        switch (this.scanner.tokenType) {
+            case SEMICOLON:
+                this.scanner.next();
+                break;
+
+            case LEFTCURLYBRACKET:
+                if (this.atrule.hasOwnProperty(nameLowerCase) &&
+                    typeof this.atrule[nameLowerCase].block === 'function') {
+                    block = this.atrule[nameLowerCase].block.call(this);
+                } else {
+                    // TODO: should consume block content as Raw?
+                    block = this.Block(isDeclarationBlockAtrule.call(this));
+                }
+
+                break;
+        }
+
+        return {
+            type: 'Atrule',
+            loc: this.getLocation(start, this.scanner.tokenStart),
+            name: name,
+            prelude: prelude,
+            block: block
+        };
+    },
+    generate: function(node) {
+        this.chunk('@');
+        this.chunk(node.name);
+
+        if (node.prelude !== null) {
+            this.chunk(' ');
+            this.node(node.prelude);
+        }
+
+        if (node.block) {
+            this.node(node.block);
+        } else {
+            this.chunk(';');
+        }
+    },
+    walkContext: 'atrule'
+};

package/dist/collection/node_modules/css-tree/lib/syntax/node/AtrulePrelude.js

@@ -0,0 +1,51 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var SEMICOLON = TYPE.Semicolon;
+var LEFTCURLYBRACKET = TYPE.LeftCurlyBracket;
+
+module.exports = {
+    name: 'AtrulePrelude',
+    structure: {
+        children: [[]]
+    },
+    parse: function(name) {
+        var children = null;
+
+        if (name !== null) {
+            name = name.toLowerCase();
+        }
+
+        this.scanner.skipSC();
+
+        if (this.atrule.hasOwnProperty(name) &&
+            typeof this.atrule[name].prelude === 'function') {
+            // custom consumer
+            children = this.atrule[name].prelude.call(this);
+        } else {
+            // default consumer
+            children = this.readSequence(this.scope.AtrulePrelude);
+        }
+
+        this.scanner.skipSC();
+
+        if (this.scanner.eof !== true &&
+            this.scanner.tokenType !== LEFTCURLYBRACKET &&
+            this.scanner.tokenType !== SEMICOLON) {
+            this.error('Semicolon or block is expected');
+        }
+
+        if (children === null) {
+            children = this.createList();
+        }
+
+        return {
+            type: 'AtrulePrelude',
+            loc: this.getLocationFromList(children),
+            children: children
+        };
+    },
+    generate: function(node) {
+        this.children(node);
+    },
+    walkContext: 'atrulePrelude'
+};

package/dist/collection/node_modules/css-tree/lib/syntax/node/AttributeSelector.js

@@ -0,0 +1,165 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var IDENT = TYPE.Ident;
+var STRING = TYPE.String;
+var COLON = TYPE.Colon;
+var LEFTSQUAREBRACKET = TYPE.LeftSquareBracket;
+var RIGHTSQUAREBRACKET = TYPE.RightSquareBracket;
+var DOLLARSIGN = 0x0024;       // U+0024 DOLLAR SIGN ($)
+var ASTERISK = 0x002A;         // U+002A ASTERISK (*)
+var EQUALSSIGN = 0x003D;       // U+003D EQUALS SIGN (=)
+var CIRCUMFLEXACCENT = 0x005E; // U+005E (^)
+var VERTICALLINE = 0x007C;     // U+007C VERTICAL LINE (|)
+var TILDE = 0x007E;            // U+007E TILDE (~)
+
+function getAttributeName() {
+    if (this.scanner.eof) {
+        this.error('Unexpected end of input');
+    }
+
+    var start = this.scanner.tokenStart;
+    var expectIdent = false;
+    var checkColon = true;
+
+    if (this.scanner.isDelim(ASTERISK)) {
+        expectIdent = true;
+        checkColon = false;
+        this.scanner.next();
+    } else if (!this.scanner.isDelim(VERTICALLINE)) {
+        this.eat(IDENT);
+    }
+
+    if (this.scanner.isDelim(VERTICALLINE)) {
+        if (this.scanner.source.charCodeAt(this.scanner.tokenStart + 1) !== EQUALSSIGN) {
+            this.scanner.next();
+            this.eat(IDENT);
+        } else if (expectIdent) {
+            this.error('Identifier is expected', this.scanner.tokenEnd);
+        }
+    } else if (expectIdent) {
+        this.error('Vertical line is expected');
+    }
+
+    if (checkColon && this.scanner.tokenType === COLON) {
+        this.scanner.next();
+        this.eat(IDENT);
+    }
+
+    return {
+        type: 'Identifier',
+        loc: this.getLocation(start, this.scanner.tokenStart),
+        name: this.scanner.substrToCursor(start)
+    };
+}
+
+function getOperator() {
+    var start = this.scanner.tokenStart;
+    var code = this.scanner.source.charCodeAt(start);
+
+    if (code !== EQUALSSIGN &&        // =
+        code !== TILDE &&             // ~=
+        code !== CIRCUMFLEXACCENT &&  // ^=
+        code !== DOLLARSIGN &&        // $=
+        code !== ASTERISK &&          // *=
+        code !== VERTICALLINE         // |=
+    ) {
+        this.error('Attribute selector (=, ~=, ^=, $=, *=, |=) is expected');
+    }
+
+    this.scanner.next();
+
+    if (code !== EQUALSSIGN) {
+        if (!this.scanner.isDelim(EQUALSSIGN)) {
+            this.error('Equal sign is expected');
+        }
+
+        this.scanner.next();
+    }
+
+    return this.scanner.substrToCursor(start);
+}
+
+// '[' <wq-name> ']'
+// '[' <wq-name> <attr-matcher> [ <string-token> | <ident-token> ] <attr-modifier>? ']'
+module.exports = {
+    name: 'AttributeSelector',
+    structure: {
+        name: 'Identifier',
+        matcher: [String, null],
+        value: ['String', 'Identifier', null],
+        flags: [String, null]
+    },
+    parse: function() {
+        var start = this.scanner.tokenStart;
+        var name;
+        var matcher = null;
+        var value = null;
+        var flags = null;
+
+        this.eat(LEFTSQUAREBRACKET);
+        this.scanner.skipSC();
+
+        name = getAttributeName.call(this);
+        this.scanner.skipSC();
+
+        if (this.scanner.tokenType !== RIGHTSQUAREBRACKET) {
+            // avoid case `[name i]`
+            if (this.scanner.tokenType !== IDENT) {
+                matcher = getOperator.call(this);
+
+                this.scanner.skipSC();
+
+                value = this.scanner.tokenType === STRING
+                    ? this.String()
+                    : this.Identifier();
+
+                this.scanner.skipSC();
+            }
+
+            // attribute flags
+            if (this.scanner.tokenType === IDENT) {
+                flags = this.scanner.getTokenValue();
+                this.scanner.next();
+
+                this.scanner.skipSC();
+            }
+        }
+
+        this.eat(RIGHTSQUAREBRACKET);
+
+        return {
+            type: 'AttributeSelector',
+            loc: this.getLocation(start, this.scanner.tokenStart),
+            name: name,
+            matcher: matcher,
+            value: value,
+            flags: flags
+        };
+    },
+    generate: function(node) {
+        var flagsPrefix = ' ';
+
+        this.chunk('[');
+        this.node(node.name);
+
+        if (node.matcher !== null) {
+            this.chunk(node.matcher);
+
+            if (node.value !== null) {
+                this.node(node.value);
+
+                // space between string and flags is not required
+                if (node.value.type === 'String') {
+                    flagsPrefix = '';
+                }
+            }
+        }
+
+        if (node.flags !== null) {
+            this.chunk(flagsPrefix);
+            this.chunk(node.flags);
+        }
+
+        this.chunk(']');
+    }
+};

package/dist/collection/node_modules/css-tree/lib/syntax/node/Block.js

@@ -0,0 +1,91 @@
+var TYPE = require('../../tokenizer').TYPE;
+var rawMode = require('./Raw').mode;
+
+var WHITESPACE = TYPE.WhiteSpace;
+var COMMENT = TYPE.Comment;
+var SEMICOLON = TYPE.Semicolon;
+var ATKEYWORD = TYPE.AtKeyword;
+var LEFTCURLYBRACKET = TYPE.LeftCurlyBracket;
+var RIGHTCURLYBRACKET = TYPE.RightCurlyBracket;
+
+function consumeRaw(startToken) {
+    return this.Raw(startToken, null, true);
+}
+function consumeRule() {
+    return this.parseWithFallback(this.Rule, consumeRaw);
+}
+function consumeRawDeclaration(startToken) {
+    return this.Raw(startToken, rawMode.semicolonIncluded, true);
+}
+function consumeDeclaration() {
+    if (this.scanner.tokenType === SEMICOLON) {
+        return consumeRawDeclaration.call(this, this.scanner.tokenIndex);
+    }
+
+    var node = this.parseWithFallback(this.Declaration, consumeRawDeclaration);
+
+    if (this.scanner.tokenType === SEMICOLON) {
+        this.scanner.next();
+    }
+
+    return node;
+}
+
+module.exports = {
+    name: 'Block',
+    structure: {
+        children: [[
+            'Atrule',
+            'Rule',
+            'Declaration'
+        ]]
+    },
+    parse: function(isDeclaration) {
+        var consumer = isDeclaration ? consumeDeclaration : consumeRule;
+
+        var start = this.scanner.tokenStart;
+        var children = this.createList();
+
+        this.eat(LEFTCURLYBRACKET);
+
+        scan:
+        while (!this.scanner.eof) {
+            switch (this.scanner.tokenType) {
+                case RIGHTCURLYBRACKET:
+                    break scan;
+
+                case WHITESPACE:
+                case COMMENT:
+                    this.scanner.next();
+                    break;
+
+                case ATKEYWORD:
+                    children.push(this.parseWithFallback(this.Atrule, consumeRaw));
+                    break;
+
+                default:
+                    children.push(consumer.call(this));
+            }
+        }
+
+        if (!this.scanner.eof) {
+            this.eat(RIGHTCURLYBRACKET);
+        }
+
+        return {
+            type: 'Block',
+            loc: this.getLocation(start, this.scanner.tokenStart),
+            children: children
+        };
+    },
+    generate: function(node) {
+        this.chunk('{');
+        this.children(node, function(prev) {
+            if (prev.type === 'Declaration') {
+                this.chunk(';');
+            }
+        });
+        this.chunk('}');
+    },
+    walkContext: 'block'
+};