@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/StyleSheet.js

@@ -0,0 +1,81 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var WHITESPACE = TYPE.WhiteSpace;
+var COMMENT = TYPE.Comment;
+var ATKEYWORD = TYPE.AtKeyword;
+var CDO = TYPE.CDO;
+var CDC = TYPE.CDC;
+var EXCLAMATIONMARK = 0x0021; // U+0021 EXCLAMATION MARK (!)
+
+function consumeRaw(startToken) {
+    return this.Raw(startToken, null, false);
+}
+
+module.exports = {
+    name: 'StyleSheet',
+    structure: {
+        children: [[
+            'Comment',
+            'CDO',
+            'CDC',
+            'Atrule',
+            'Rule',
+            'Raw'
+        ]]
+    },
+    parse: function() {
+        var start = this.scanner.tokenStart;
+        var children = this.createList();
+        var child;
+
+        scan:
+        while (!this.scanner.eof) {
+            switch (this.scanner.tokenType) {
+                case WHITESPACE:
+                    this.scanner.next();
+                    continue;
+
+                case COMMENT:
+                    // ignore comments except exclamation comments (i.e. /*! .. */) on top level
+                    if (this.scanner.source.charCodeAt(this.scanner.tokenStart + 2) !== EXCLAMATIONMARK) {
+                        this.scanner.next();
+                        continue;
+                    }
+
+                    child = this.Comment();
+                    break;
+
+                case CDO: // <!--
+                    child = this.CDO();
+                    break;
+
+                case CDC: // -->
+                    child = this.CDC();
+                    break;
+
+                // CSS Syntax Module Level 3
+                // §2.2 Error handling
+                // At the "top level" of a stylesheet, an <at-keyword-token> starts an at-rule.
+                case ATKEYWORD:
+                    child = this.parseWithFallback(this.Atrule, consumeRaw);
+                    break;
+
+                // Anything else starts a qualified rule ...
+                default:
+                    child = this.parseWithFallback(this.Rule, consumeRaw);
+            }
+
+            children.push(child);
+        }
+
+        return {
+            type: 'StyleSheet',
+            loc: this.getLocation(start, this.scanner.tokenStart),
+            children: children
+        };
+    },
+    generate: function(node) {
+        this.children(node);
+    },
+    walkContext: 'stylesheet'
+};

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

@@ -0,0 +1,53 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var IDENT = TYPE.Ident;
+var ASTERISK = 0x002A;     // U+002A ASTERISK (*)
+var VERTICALLINE = 0x007C; // U+007C VERTICAL LINE (|)
+
+function eatIdentifierOrAsterisk() {
+    if (this.scanner.tokenType !== IDENT &&
+        this.scanner.isDelim(ASTERISK) === false) {
+        this.error('Identifier or asterisk is expected');
+    }
+
+    this.scanner.next();
+}
+
+// ident
+// ident|ident
+// ident|*
+// *
+// *|ident
+// *|*
+// |ident
+// |*
+module.exports = {
+    name: 'TypeSelector',
+    structure: {
+        name: String
+    },
+    parse: function() {
+        var start = this.scanner.tokenStart;
+
+        if (this.scanner.isDelim(VERTICALLINE)) {
+            this.scanner.next();
+            eatIdentifierOrAsterisk.call(this);
+        } else {
+            eatIdentifierOrAsterisk.call(this);
+
+            if (this.scanner.isDelim(VERTICALLINE)) {
+                this.scanner.next();
+                eatIdentifierOrAsterisk.call(this);
+            }
+        }
+
+        return {
+            type: 'TypeSelector',
+            loc: this.getLocation(start, this.scanner.tokenStart),
+            name: this.scanner.substrToCursor(start)
+        };
+    },
+    generate: function(node) {
+        this.chunk(node.name);
+    }
+};

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

@@ -0,0 +1,173 @@
+var isHexDigit = require('../../tokenizer').isHexDigit;
+var cmpChar = require('../../tokenizer').cmpChar;
+var TYPE = require('../../tokenizer').TYPE;
+var NAME = require('../../tokenizer').NAME;
+
+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 QUESTIONMARK = 0x003F; // U+003F QUESTION MARK (?)
+var U = 0x0075;            // U+0075 LATIN SMALL LETTER U (u)
+
+function eatHexSequence(offset, allowDash) {
+    for (var pos = this.scanner.tokenStart + offset, len = 0; pos < this.scanner.tokenEnd; pos++) {
+        var code = this.scanner.source.charCodeAt(pos);
+
+        if (code === HYPHENMINUS && allowDash && len !== 0) {
+            if (eatHexSequence.call(this, offset + len + 1, false) === 0) {
+                this.error();
+            }
+
+            return -1;
+        }
+
+        if (!isHexDigit(code)) {
+            this.error(
+                allowDash && len !== 0
+                    ? 'HyphenMinus' + (len < 6 ? ' or hex digit' : '') + ' is expected'
+                    : (len < 6 ? 'Hex digit is expected' : 'Unexpected input'),
+                pos
+            );
+        }
+
+        if (++len > 6) {
+            this.error('Too many hex digits', pos);
+        };
+    }
+
+    this.scanner.next();
+    return len;
+}
+
+function eatQuestionMarkSequence(max) {
+    var count = 0;
+
+    while (this.scanner.isDelim(QUESTIONMARK)) {
+        if (++count > max) {
+            this.error('Too many question marks');
+        }
+
+        this.scanner.next();
+    }
+}
+
+function startsWith(code) {
+    if (this.scanner.source.charCodeAt(this.scanner.tokenStart) !== code) {
+        this.error(NAME[code] + ' is expected');
+    }
+}
+
+// https://drafts.csswg.org/css-syntax/#urange
+// Informally, the <urange> production has three forms:
+// U+0001
+//      Defines a range consisting of a single code point, in this case the code point "1".
+// U+0001-00ff
+//      Defines a range of codepoints between the first and the second value, in this case
+//      the range between "1" and "ff" (255 in decimal) inclusive.
+// U+00??
+//      Defines a range of codepoints where the "?" characters range over all hex digits,
+//      in this case defining the same as the value U+0000-00ff.
+// In each form, a maximum of 6 digits is allowed for each hexadecimal number (if you treat "?" as a hexadecimal digit).
+//
+// <urange> =
+//   u '+' <ident-token> '?'* |
+//   u <dimension-token> '?'* |
+//   u <number-token> '?'* |
+//   u <number-token> <dimension-token> |
+//   u <number-token> <number-token> |
+//   u '+' '?'+
+function scanUnicodeRange() {
+    var hexLength = 0;
+
+    // u '+' <ident-token> '?'*
+    // u '+' '?'+
+    if (this.scanner.isDelim(PLUSSIGN)) {
+        this.scanner.next();
+
+        if (this.scanner.tokenType === IDENT) {
+            hexLength = eatHexSequence.call(this, 0, true);
+            if (hexLength > 0) {
+                eatQuestionMarkSequence.call(this, 6 - hexLength);
+            }
+            return;
+        }
+
+        if (this.scanner.isDelim(QUESTIONMARK)) {
+            this.scanner.next();
+            eatQuestionMarkSequence.call(this, 5);
+            return;
+        }
+
+        this.error('Hex digit or question mark is expected');
+        return;
+    }
+
+    // u <number-token> '?'*
+    // u <number-token> <dimension-token>
+    // u <number-token> <number-token>
+    if (this.scanner.tokenType === NUMBER) {
+        startsWith.call(this, PLUSSIGN);
+        hexLength = eatHexSequence.call(this, 1, true);
+
+        if (this.scanner.isDelim(QUESTIONMARK)) {
+            eatQuestionMarkSequence.call(this, 6 - hexLength);
+            return;
+        }
+
+        if (this.scanner.tokenType === DIMENSION ||
+            this.scanner.tokenType === NUMBER) {
+            startsWith.call(this, HYPHENMINUS);
+            eatHexSequence.call(this, 1, false);
+            return;
+        }
+
+        return;
+    }
+
+    // u <dimension-token> '?'*
+    if (this.scanner.tokenType === DIMENSION) {
+        startsWith.call(this, PLUSSIGN);
+        hexLength = eatHexSequence.call(this, 1, true);
+
+        if (hexLength > 0) {
+            eatQuestionMarkSequence.call(this, 6 - hexLength);
+        }
+
+        return;
+    }
+
+    this.error();
+}
+
+module.exports = {
+    name: 'UnicodeRange',
+    structure: {
+        value: String
+    },
+    parse: function() {
+        var start = this.scanner.tokenStart;
+
+        // U or u
+        if (!cmpChar(this.scanner.source, start, U)) {
+            this.error('U is expected');
+        }
+
+        if (!cmpChar(this.scanner.source, start + 1, PLUSSIGN)) {
+            this.error('Plus sign is expected');
+        }
+
+        this.scanner.next();
+        scanUnicodeRange.call(this);
+
+        return {
+            type: 'UnicodeRange',
+            loc: this.getLocation(start, this.scanner.tokenStart),
+            value: this.scanner.substrToCursor(start)
+        };
+    },
+    generate: function(node) {
+        this.chunk(node.value);
+    }
+};

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

@@ -0,0 +1,69 @@
+var isWhiteSpace = require('../../tokenizer').isWhiteSpace;
+var cmpStr = require('../../tokenizer').cmpStr;
+var TYPE = require('../../tokenizer').TYPE;
+
+var FUNCTION = TYPE.Function;
+var URL = TYPE.Url;
+var RIGHTPARENTHESIS = TYPE.RightParenthesis;
+
+// <url-token> | <function-token> <string> )
+module.exports = {
+    name: 'Url',
+    structure: {
+        value: ['String', 'Raw']
+    },
+    parse: function() {
+        var start = this.scanner.tokenStart;
+        var value;
+
+        switch (this.scanner.tokenType) {
+            case URL:
+                var rawStart = start + 4;
+                var rawEnd = this.scanner.tokenEnd - 1;
+
+                while (rawStart < rawEnd && isWhiteSpace(this.scanner.source.charCodeAt(rawStart))) {
+                    rawStart++;
+                }
+
+                while (rawStart < rawEnd && isWhiteSpace(this.scanner.source.charCodeAt(rawEnd - 1))) {
+                    rawEnd--;
+                }
+
+                value = {
+                    type: 'Raw',
+                    loc: this.getLocation(rawStart, rawEnd),
+                    value: this.scanner.source.substring(rawStart, rawEnd)
+                };
+
+                this.eat(URL);
+                break;
+
+            case FUNCTION:
+                if (!cmpStr(this.scanner.source, this.scanner.tokenStart, this.scanner.tokenEnd, 'url(')) {
+                    this.error('Function name must be `url`');
+                }
+
+                this.eat(FUNCTION);
+                this.scanner.skipSC();
+                value = this.String();
+                this.scanner.skipSC();
+                this.eat(RIGHTPARENTHESIS);
+                break;
+
+            default:
+                this.error('Url or Function is expected');
+        }
+
+        return {
+            type: 'Url',
+            loc: this.getLocation(start, this.scanner.tokenStart),
+            value: value
+        };
+    },
+    generate: function(node) {
+        this.chunk('url');
+        this.chunk('(');
+        this.node(node.value);
+        this.chunk(')');
+    }
+};

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

@@ -0,0 +1,19 @@
+module.exports = {
+    name: 'Value',
+    structure: {
+        children: [[]]
+    },
+    parse: function() {
+        var start = this.scanner.tokenStart;
+        var children = this.readSequence(this.scope.Value);
+
+        return {
+            type: 'Value',
+            loc: this.getLocation(start, this.scanner.tokenStart),
+            children: children
+        };
+    },
+    generate: function(node) {
+        this.children(node);
+    }
+};

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

@@ -0,0 +1,26 @@
+var WHITESPACE = require('../../tokenizer').TYPE.WhiteSpace;
+var SPACE = Object.freeze({
+    type: 'WhiteSpace',
+    loc: null,
+    value: ' '
+});
+
+module.exports = {
+    name: 'WhiteSpace',
+    structure: {
+        value: String
+    },
+    parse: function() {
+        this.eat(WHITESPACE);
+        return SPACE;
+
+        // return {
+        //     type: 'WhiteSpace',
+        //     loc: this.getLocation(this.scanner.tokenStart, this.scanner.tokenEnd),
+        //     value: this.consume(WHITESPACE)
+        // };
+    },
+    generate: function(node) {
+        this.chunk(node.value);
+    }
+};

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

@@ -0,0 +1,42 @@
+module.exports = {
+    AnPlusB: require('./AnPlusB'),
+    Atrule: require('./Atrule'),
+    AtrulePrelude: require('./AtrulePrelude'),
+    AttributeSelector: require('./AttributeSelector'),
+    Block: require('./Block'),
+    Brackets: require('./Brackets'),
+    CDC: require('./CDC'),
+    CDO: require('./CDO'),
+    ClassSelector: require('./ClassSelector'),
+    Combinator: require('./Combinator'),
+    Comment: require('./Comment'),
+    Declaration: require('./Declaration'),
+    DeclarationList: require('./DeclarationList'),
+    Dimension: require('./Dimension'),
+    Function: require('./Function'),
+    Hash: require('./Hash'),
+    Identifier: require('./Identifier'),
+    IdSelector: require('./IdSelector'),
+    MediaFeature: require('./MediaFeature'),
+    MediaQuery: require('./MediaQuery'),
+    MediaQueryList: require('./MediaQueryList'),
+    Nth: require('./Nth'),
+    Number: require('./Number'),
+    Operator: require('./Operator'),
+    Parentheses: require('./Parentheses'),
+    Percentage: require('./Percentage'),
+    PseudoClassSelector: require('./PseudoClassSelector'),
+    PseudoElementSelector: require('./PseudoElementSelector'),
+    Ratio: require('./Ratio'),
+    Raw: require('./Raw'),
+    Rule: require('./Rule'),
+    Selector: require('./Selector'),
+    SelectorList: require('./SelectorList'),
+    String: require('./String'),
+    StyleSheet: require('./StyleSheet'),
+    TypeSelector: require('./TypeSelector'),
+    UnicodeRange: require('./UnicodeRange'),
+    Url: require('./Url'),
+    Value: require('./Value'),
+    WhiteSpace: require('./WhiteSpace')
+};

package/dist/collection/node_modules/css-tree/lib/syntax/pseudo/common/nth.js

@@ -0,0 +1,9 @@
+var DISALLOW_OF_CLAUSE = false;
+
+module.exports = {
+    parse: function nth() {
+        return this.createSingleNodeList(
+            this.Nth(DISALLOW_OF_CLAUSE)
+        );
+    }
+};

package/dist/collection/node_modules/css-tree/lib/syntax/pseudo/common/nthWithOfClause.js

@@ -0,0 +1,9 @@
+var ALLOW_OF_CLAUSE = true;
+
+module.exports = {
+    parse: function nthWithOfClause() {
+        return this.createSingleNodeList(
+            this.Nth(ALLOW_OF_CLAUSE)
+        );
+    }
+};

package/dist/collection/node_modules/css-tree/lib/syntax/pseudo/common/selectorList.js

@@ -0,0 +1,7 @@
+module.exports = {
+    parse: function selectorList() {
+        return this.createSingleNodeList(
+            this.SelectorList()
+        );
+    }
+};

package/dist/collection/node_modules/css-tree/lib/syntax/pseudo/dir.js

@@ -0,0 +1,7 @@
+module.exports = {
+    parse: function() {
+        return this.createSingleNodeList(
+            this.Identifier()
+        );
+    }
+};

package/dist/collection/node_modules/css-tree/lib/syntax/pseudo/has.js

@@ -0,0 +1,7 @@
+module.exports = {
+    parse: function() {
+        return this.createSingleNodeList(
+            this.SelectorList()
+        );
+    }
+};

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

@@ -0,0 +1,12 @@
+module.exports = {
+    'dir': require('./dir'),
+    'has': require('./has'),
+    'lang': require('./lang'),
+    'matches': require('./matches'),
+    'not': require('./not'),
+    'nth-child': require('./nth-child'),
+    'nth-last-child': require('./nth-last-child'),
+    'nth-last-of-type': require('./nth-last-of-type'),
+    'nth-of-type': require('./nth-of-type'),
+    'slotted': require('./slotted')
+};

package/dist/collection/node_modules/css-tree/lib/syntax/pseudo/lang.js

@@ -0,0 +1,7 @@
+module.exports = {
+    parse: function() {
+        return this.createSingleNodeList(
+            this.Identifier()
+        );
+    }
+};

package/dist/collection/node_modules/css-tree/lib/syntax/pseudo/matches.js

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

package/dist/collection/node_modules/css-tree/lib/syntax/pseudo/not.js

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

package/dist/collection/node_modules/css-tree/lib/syntax/pseudo/nth-child.js

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

package/dist/collection/node_modules/css-tree/lib/syntax/pseudo/nth-last-child.js

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

package/dist/collection/node_modules/css-tree/lib/syntax/pseudo/nth-last-of-type.js

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

package/dist/collection/node_modules/css-tree/lib/syntax/pseudo/nth-of-type.js

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

package/dist/collection/node_modules/css-tree/lib/syntax/pseudo/slotted.js

@@ -0,0 +1,7 @@
+module.exports = {
+    parse: function compoundSelector() {
+        return this.createSingleNodeList(
+            this.Selector()
+        );
+    }
+};

package/dist/collection/node_modules/css-tree/lib/syntax/scope/atrulePrelude.js

@@ -0,0 +1,3 @@
+module.exports = {
+    getNode: require('./default')
+};

package/dist/collection/node_modules/css-tree/lib/syntax/scope/default.js

@@ -0,0 +1,87 @@
+var cmpChar = require('../../tokenizer').cmpChar;
+var cmpStr = require('../../tokenizer').cmpStr;
+var TYPE = require('../../tokenizer').TYPE;
+
+var IDENT = TYPE.Ident;
+var STRING = TYPE.String;
+var NUMBER = TYPE.Number;
+var FUNCTION = TYPE.Function;
+var URL = TYPE.Url;
+var HASH = TYPE.Hash;
+var DIMENSION = TYPE.Dimension;
+var PERCENTAGE = TYPE.Percentage;
+var LEFTPARENTHESIS = TYPE.LeftParenthesis;
+var LEFTSQUAREBRACKET = TYPE.LeftSquareBracket;
+var COMMA = TYPE.Comma;
+var DELIM = TYPE.Delim;
+var NUMBERSIGN = 0x0023;  // U+0023 NUMBER SIGN (#)
+var ASTERISK = 0x002A;    // U+002A ASTERISK (*)
+var PLUSSIGN = 0x002B;    // U+002B PLUS SIGN (+)
+var HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-)
+var SOLIDUS = 0x002F;     // U+002F SOLIDUS (/)
+var U = 0x0075;           // U+0075 LATIN SMALL LETTER U (u)
+
+module.exports = function defaultRecognizer(context) {
+    switch (this.scanner.tokenType) {
+        case HASH:
+            return this.Hash();
+
+        case COMMA:
+            context.space = null;
+            context.ignoreWSAfter = true;
+            return this.Operator();
+
+        case LEFTPARENTHESIS:
+            return this.Parentheses(this.readSequence, context.recognizer);
+
+        case LEFTSQUAREBRACKET:
+            return this.Brackets(this.readSequence, context.recognizer);
+
+        case STRING:
+            return this.String();
+
+        case DIMENSION:
+            return this.Dimension();
+
+        case PERCENTAGE:
+            return this.Percentage();
+
+        case NUMBER:
+            return this.Number();
+
+        case FUNCTION:
+            return cmpStr(this.scanner.source, this.scanner.tokenStart, this.scanner.tokenEnd, 'url(')
+                ? this.Url()
+                : this.Function(this.readSequence, context.recognizer);
+
+        case URL:
+            return this.Url();
+
+        case IDENT:
+            // check for unicode range, it should start with u+ or U+
+            if (cmpChar(this.scanner.source, this.scanner.tokenStart, U) &&
+                cmpChar(this.scanner.source, this.scanner.tokenStart + 1, PLUSSIGN)) {
+                return this.UnicodeRange();
+            } else {
+                return this.Identifier();
+            }
+
+        case DELIM:
+            var code = this.scanner.source.charCodeAt(this.scanner.tokenStart);
+
+            if (code === SOLIDUS ||
+                code === ASTERISK ||
+                code === PLUSSIGN ||
+                code === HYPHENMINUS) {
+                return this.Operator(); // TODO: replace with Delim
+            }
+
+            // TODO: produce a node with Delim node type
+
+            if (code === NUMBERSIGN) {
+                this.error('Hex or identifier is expected', this.scanner.tokenStart + 1);
+            }
+
+            break;
+    }
+};

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

@@ -0,0 +1,5 @@
+module.exports = {
+    AtrulePrelude: require('./atrulePrelude'),
+    Selector: require('./selector'),
+    Value: require('./value')
+};