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

package/dist/collection/node_modules/css-tree/lib/common/SyntaxError.js

@@ -0,0 +1,82 @@
+var createCustomError = require('../utils/createCustomError');
+var MAX_LINE_LENGTH = 100;
+var OFFSET_CORRECTION = 60;
+var TAB_REPLACEMENT = '    ';
+
+function sourceFragment(error, extraLines) {
+    function processLines(start, end) {
+        return lines.slice(start, end).map(function(line, idx) {
+            var num = String(start + idx + 1);
+
+            while (num.length < maxNumLength) {
+                num = ' ' + num;
+            }
+
+            return num + ' |' + line;
+        }).join('\n');
+    }
+
+    var lines = error.source.split(/\r\n?|\n|\f/);
+    var line = error.line;
+    var column = error.column;
+    var startLine = Math.max(1, line - extraLines) - 1;
+    var endLine = Math.min(line + extraLines, lines.length + 1);
+    var maxNumLength = Math.max(4, String(endLine).length) + 1;
+    var cutLeft = 0;
+
+    // column correction according to replaced tab before column
+    column += (TAB_REPLACEMENT.length - 1) * (lines[line - 1].substr(0, column - 1).match(/\t/g) || []).length;
+
+    if (column > MAX_LINE_LENGTH) {
+        cutLeft = column - OFFSET_CORRECTION + 3;
+        column = OFFSET_CORRECTION - 2;
+    }
+
+    for (var i = startLine; i <= endLine; i++) {
+        if (i >= 0 && i < lines.length) {
+            lines[i] = lines[i].replace(/\t/g, TAB_REPLACEMENT);
+            lines[i] =
+                (cutLeft > 0 && lines[i].length > cutLeft ? '\u2026' : '') +
+                lines[i].substr(cutLeft, MAX_LINE_LENGTH - 2) +
+                (lines[i].length > cutLeft + MAX_LINE_LENGTH - 1 ? '\u2026' : '');
+        }
+    }
+
+    return [
+        processLines(startLine, line),
+        new Array(column + maxNumLength + 2).join('-') + '^',
+        processLines(line, endLine)
+    ].filter(Boolean).join('\n');
+}
+
+var SyntaxError = function(message, source, offset, line, column) {
+    var error = createCustomError('SyntaxError', message);
+
+    error.source = source;
+    error.offset = offset;
+    error.line = line;
+    error.column = column;
+
+    error.sourceFragment = function(extraLines) {
+        return sourceFragment(error, isNaN(extraLines) ? 0 : extraLines);
+    };
+    Object.defineProperty(error, 'formattedMessage', {
+        get: function() {
+            return (
+                'Parse error: ' + error.message + '\n' +
+                sourceFragment(error, 2)
+            );
+        }
+    });
+
+    // for backward capability
+    error.parseError = {
+        offset: offset,
+        line: line,
+        column: column
+    };
+
+    return error;
+};
+
+module.exports = SyntaxError;

package/dist/collection/node_modules/css-tree/lib/common/TokenStream.js

@@ -0,0 +1,219 @@
+var constants = require('../tokenizer/const');
+var TYPE = constants.TYPE;
+var NAME = constants.NAME;
+
+var utils = require('../tokenizer/utils');
+var cmpStr = utils.cmpStr;
+
+var EOF = TYPE.EOF;
+var WHITESPACE = TYPE.WhiteSpace;
+var COMMENT = TYPE.Comment;
+
+var OFFSET_MASK = 0x00FFFFFF;
+var TYPE_SHIFT = 24;
+
+var TokenStream = function() {
+    this.offsetAndType = null;
+    this.balance = null;
+
+    this.reset();
+};
+
+TokenStream.prototype = {
+    reset: function() {
+        this.eof = false;
+        this.tokenIndex = -1;
+        this.tokenType = 0;
+        this.tokenStart = this.firstCharOffset;
+        this.tokenEnd = this.firstCharOffset;
+    },
+
+    lookupType: function(offset) {
+        offset += this.tokenIndex;
+
+        if (offset < this.tokenCount) {
+            return this.offsetAndType[offset] >> TYPE_SHIFT;
+        }
+
+        return EOF;
+    },
+    lookupOffset: function(offset) {
+        offset += this.tokenIndex;
+
+        if (offset < this.tokenCount) {
+            return this.offsetAndType[offset - 1] & OFFSET_MASK;
+        }
+
+        return this.source.length;
+    },
+    lookupValue: function(offset, referenceStr) {
+        offset += this.tokenIndex;
+
+        if (offset < this.tokenCount) {
+            return cmpStr(
+                this.source,
+                this.offsetAndType[offset - 1] & OFFSET_MASK,
+                this.offsetAndType[offset] & OFFSET_MASK,
+                referenceStr
+            );
+        }
+
+        return false;
+    },
+    getTokenStart: function(tokenIndex) {
+        if (tokenIndex === this.tokenIndex) {
+            return this.tokenStart;
+        }
+
+        if (tokenIndex > 0) {
+            return tokenIndex < this.tokenCount
+                ? this.offsetAndType[tokenIndex - 1] & OFFSET_MASK
+                : this.offsetAndType[this.tokenCount] & OFFSET_MASK;
+        }
+
+        return this.firstCharOffset;
+    },
+
+    // TODO: -> skipUntilBalanced
+    getRawLength: function(startToken, mode) {
+        var cursor = startToken;
+        var balanceEnd;
+        var offset = this.offsetAndType[Math.max(cursor - 1, 0)] & OFFSET_MASK;
+        var type;
+
+        loop:
+        for (; cursor < this.tokenCount; cursor++) {
+            balanceEnd = this.balance[cursor];
+
+            // stop scanning on balance edge that points to offset before start token
+            if (balanceEnd < startToken) {
+                break loop;
+            }
+
+            type = this.offsetAndType[cursor] >> TYPE_SHIFT;
+
+            // check token is stop type
+            switch (mode(type, this.source, offset)) {
+                case 1:
+                    break loop;
+
+                case 2:
+                    cursor++;
+                    break loop;
+
+                default:
+                    // fast forward to the end of balanced block
+                    if (this.balance[balanceEnd] === cursor) {
+                        cursor = balanceEnd;
+                    }
+
+                    offset = this.offsetAndType[cursor] & OFFSET_MASK;
+            }
+        }
+
+        return cursor - this.tokenIndex;
+    },
+    isBalanceEdge: function(pos) {
+        return this.balance[this.tokenIndex] < pos;
+    },
+    isDelim: function(code, offset) {
+        if (offset) {
+            return (
+                this.lookupType(offset) === TYPE.Delim &&
+                this.source.charCodeAt(this.lookupOffset(offset)) === code
+            );
+        }
+
+        return (
+            this.tokenType === TYPE.Delim &&
+            this.source.charCodeAt(this.tokenStart) === code
+        );
+    },
+
+    getTokenValue: function() {
+        return this.source.substring(this.tokenStart, this.tokenEnd);
+    },
+    getTokenLength: function() {
+        return this.tokenEnd - this.tokenStart;
+    },
+    substrToCursor: function(start) {
+        return this.source.substring(start, this.tokenStart);
+    },
+
+    skipWS: function() {
+        for (var i = this.tokenIndex, skipTokenCount = 0; i < this.tokenCount; i++, skipTokenCount++) {
+            if ((this.offsetAndType[i] >> TYPE_SHIFT) !== WHITESPACE) {
+                break;
+            }
+        }
+
+        if (skipTokenCount > 0) {
+            this.skip(skipTokenCount);
+        }
+    },
+    skipSC: function() {
+        while (this.tokenType === WHITESPACE || this.tokenType === COMMENT) {
+            this.next();
+        }
+    },
+    skip: function(tokenCount) {
+        var next = this.tokenIndex + tokenCount;
+
+        if (next < this.tokenCount) {
+            this.tokenIndex = next;
+            this.tokenStart = this.offsetAndType[next - 1] & OFFSET_MASK;
+            next = this.offsetAndType[next];
+            this.tokenType = next >> TYPE_SHIFT;
+            this.tokenEnd = next & OFFSET_MASK;
+        } else {
+            this.tokenIndex = this.tokenCount;
+            this.next();
+        }
+    },
+    next: function() {
+        var next = this.tokenIndex + 1;
+
+        if (next < this.tokenCount) {
+            this.tokenIndex = next;
+            this.tokenStart = this.tokenEnd;
+            next = this.offsetAndType[next];
+            this.tokenType = next >> TYPE_SHIFT;
+            this.tokenEnd = next & OFFSET_MASK;
+        } else {
+            this.tokenIndex = this.tokenCount;
+            this.eof = true;
+            this.tokenType = EOF;
+            this.tokenStart = this.tokenEnd = this.source.length;
+        }
+    },
+
+    forEachToken(fn) {
+        for (var i = 0, offset = this.firstCharOffset; i < this.tokenCount; i++) {
+            var start = offset;
+            var item = this.offsetAndType[i];
+            var end = item & OFFSET_MASK;
+            var type = item >> TYPE_SHIFT;
+
+            offset = end;
+
+            fn(type, start, end, i);
+        }
+    },
+
+    dump() {
+        var tokens = new Array(this.tokenCount);
+
+        this.forEachToken((type, start, end, index) => {
+            tokens[index] = {
+                idx: index,
+                type: NAME[type],
+                chunk: this.source.substring(start, end),
+                balance: this.balance[index]
+            };
+        });
+
+        return tokens;
+    }
+};
+
+module.exports = TokenStream;

package/dist/collection/node_modules/css-tree/lib/common/adopt-buffer.js

@@ -0,0 +1,10 @@
+var MIN_SIZE = 16 * 1024;
+var SafeUint32Array = typeof Uint32Array !== 'undefined' ? Uint32Array : Array; // fallback on Array when TypedArray is not supported
+
+module.exports = function adoptBuffer(buffer, size) {
+    if (buffer === null || buffer.length < size) {
+        return new SafeUint32Array(Math.max(size + 1024, MIN_SIZE));
+    }
+
+    return buffer;
+};

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

@@ -0,0 +1,28 @@
+var List = require('../common/List');
+
+module.exports = function createConvertors(walk) {
+    return {
+        fromPlainObject: function(ast) {
+            walk(ast, {
+                enter: function(node) {
+                    if (node.children && node.children instanceof List === false) {
+                        node.children = new List().fromArray(node.children);
+                    }
+                }
+            });
+
+            return ast;
+        },
+        toPlainObject: function(ast) {
+            walk(ast, {
+                leave: function(node) {
+                    if (node.children && node.children instanceof List) {
+                        node.children = node.children.toArray();
+                    }
+                }
+            });
+
+            return ast;
+        }
+    };
+};

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

@@ -0,0 +1,3 @@
+var createConvertor = require('./create');
+
+module.exports = createConvertor(require('../walker'));

package/dist/collection/node_modules/css-tree/lib/definition-syntax/SyntaxError.js

@@ -0,0 +1,14 @@
+var createCustomError = require('../utils/createCustomError');
+
+module.exports = function SyntaxError(message, input, offset) {
+    var error = createCustomError('SyntaxError', message);
+
+    error.input = input;
+    error.offset = offset;
+    error.rawMessage = message;
+    error.message = error.rawMessage + '\n' +
+        '  ' + error.input + '\n' +
+        '--' + new Array((error.offset || error.input.length) + 1).join('-') + '^';
+
+    return error;
+};

package/dist/collection/node_modules/css-tree/lib/definition-syntax/generate.js

@@ -0,0 +1,129 @@
+function noop(value) {
+    return value;
+}
+
+function generateMultiplier(multiplier) {
+    if (multiplier.min === 0 && multiplier.max === 0) {
+        return '*';
+    }
+
+    if (multiplier.min === 0 && multiplier.max === 1) {
+        return '?';
+    }
+
+    if (multiplier.min === 1 && multiplier.max === 0) {
+        return multiplier.comma ? '#' : '+';
+    }
+
+    if (multiplier.min === 1 && multiplier.max === 1) {
+        return '';
+    }
+
+    return (
+        (multiplier.comma ? '#' : '') +
+        (multiplier.min === multiplier.max
+            ? '{' + multiplier.min + '}'
+            : '{' + multiplier.min + ',' + (multiplier.max !== 0 ? multiplier.max : '') + '}'
+        )
+    );
+}
+
+function generateTypeOpts(node) {
+    switch (node.type) {
+        case 'Range':
+            return (
+                ' [' +
+                (node.min === null ? '-∞' : node.min) +
+                ',' +
+                (node.max === null ? '∞' : node.max) +
+                ']'
+            );
+
+        default:
+            throw new Error('Unknown node type `' + node.type + '`');
+    }
+}
+
+function generateSequence(node, decorate, forceBraces, compact) {
+    var combinator = node.combinator === ' ' || compact ? node.combinator : ' ' + node.combinator + ' ';
+    var result = node.terms.map(function(term) {
+        return generate(term, decorate, forceBraces, compact);
+    }).join(combinator);
+
+    if (node.explicit || forceBraces) {
+        result = (compact || result[0] === ',' ? '[' : '[ ') + result + (compact ? ']' : ' ]');
+    }
+
+    return result;
+}
+
+function generate(node, decorate, forceBraces, compact) {
+    var result;
+
+    switch (node.type) {
+        case 'Group':
+            result =
+                generateSequence(node, decorate, forceBraces, compact) +
+                (node.disallowEmpty ? '!' : '');
+            break;
+
+        case 'Multiplier':
+            // return since node is a composition
+            return (
+                generate(node.term, decorate, forceBraces, compact) +
+                decorate(generateMultiplier(node), node)
+            );
+
+        case 'Type':
+            result = '<' + node.name + (node.opts ? decorate(generateTypeOpts(node.opts), node.opts) : '') + '>';
+            break;
+
+        case 'Property':
+            result = '<\'' + node.name + '\'>';
+            break;
+
+        case 'Keyword':
+            result = node.name;
+            break;
+
+        case 'AtKeyword':
+            result = '@' + node.name;
+            break;
+
+        case 'Function':
+            result = node.name + '(';
+            break;
+
+        case 'String':
+        case 'Token':
+            result = node.value;
+            break;
+
+        case 'Comma':
+            result = ',';
+            break;
+
+        default:
+            throw new Error('Unknown node type `' + node.type + '`');
+    }
+
+    return decorate(result, node);
+}
+
+module.exports = function(node, options) {
+    var decorate = noop;
+    var forceBraces = false;
+    var compact = false;
+
+    if (typeof options === 'function') {
+        decorate = options;
+    } else if (options) {
+        forceBraces = Boolean(options.forceBraces);
+        compact = Boolean(options.compact);
+        if (typeof options.decorate === 'function') {
+            decorate = options.decorate;
+        }
+    }
+
+    return generate(node, decorate, forceBraces, compact);
+};

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

@@ -0,0 +1,6 @@
+module.exports = {
+    SyntaxError: require('./SyntaxError'),
+    parse: require('./parse'),
+    generate: require('./generate'),
+    walk: require('./walk')
+};