isomorfeus-preact 10.5.0 → 10.5.4

data/node_modules/css-tree/lib/syntax/node/Raw.js

@@ -0,0 +1,87 @@
+var tokenizer = require('../../tokenizer');
+var TYPE = tokenizer.TYPE;
+
+var WhiteSpace = TYPE.WhiteSpace;
+var Semicolon = TYPE.Semicolon;
+var LeftCurlyBracket = TYPE.LeftCurlyBracket;
+var Delim = TYPE.Delim;
+var EXCLAMATIONMARK = 0x0021; // U+0021 EXCLAMATION MARK (!)
+
+function getOffsetExcludeWS() {
+    if (this.scanner.tokenIndex > 0) {
+        if (this.scanner.lookupType(-1) === WhiteSpace) {
+            return this.scanner.tokenIndex > 1
+                ? this.scanner.getTokenStart(this.scanner.tokenIndex - 1)
+                : this.scanner.firstCharOffset;
+        }
+    }
+
+    return this.scanner.tokenStart;
+}
+
+// 0, 0, false
+function balanceEnd() {
+    return 0;
+}
+
+// LEFTCURLYBRACKET, 0, false
+function leftCurlyBracket(tokenType) {
+    return tokenType === LeftCurlyBracket ? 1 : 0;
+}
+
+// LEFTCURLYBRACKET, SEMICOLON, false
+function leftCurlyBracketOrSemicolon(tokenType) {
+    return tokenType === LeftCurlyBracket || tokenType === Semicolon ? 1 : 0;
+}
+
+// EXCLAMATIONMARK, SEMICOLON, false
+function exclamationMarkOrSemicolon(tokenType, source, offset) {
+    if (tokenType === Delim && source.charCodeAt(offset) === EXCLAMATIONMARK) {
+        return 1;
+    }
+
+    return tokenType === Semicolon ? 1 : 0;
+}
+
+// 0, SEMICOLON, true
+function semicolonIncluded(tokenType) {
+    return tokenType === Semicolon ? 2 : 0;
+}
+
+module.exports = {
+    name: 'Raw',
+    structure: {
+        value: String
+    },
+    parse: function(startToken, mode, excludeWhiteSpace) {
+        var startOffset = this.scanner.getTokenStart(startToken);
+        var endOffset;
+
+        this.scanner.skip(
+            this.scanner.getRawLength(startToken, mode || balanceEnd)
+        );
+
+        if (excludeWhiteSpace && this.scanner.tokenStart > startOffset) {
+            endOffset = getOffsetExcludeWS.call(this);
+        } else {
+            endOffset = this.scanner.tokenStart;
+        }
+
+        return {
+            type: 'Raw',
+            loc: this.getLocation(startOffset, endOffset),
+            value: this.scanner.source.substring(startOffset, endOffset)
+        };
+    },
+    generate: function(node) {
+        this.chunk(node.value);
+    },
+
+    mode: {
+        default: balanceEnd,
+        leftCurlyBracket: leftCurlyBracket,
+        leftCurlyBracketOrSemicolon: leftCurlyBracketOrSemicolon,
+        exclamationMarkOrSemicolon: exclamationMarkOrSemicolon,
+        semicolonIncluded: semicolonIncluded
+    }
+};

data/node_modules/css-tree/lib/syntax/node/Rule.js

@@ -0,0 +1,54 @@
+var TYPE = require('../../tokenizer').TYPE;
+var rawMode = require('./Raw').mode;
+
+var LEFTCURLYBRACKET = TYPE.LeftCurlyBracket;
+
+function consumeRaw(startToken) {
+    return this.Raw(startToken, rawMode.leftCurlyBracket, true);
+}
+
+function consumePrelude() {
+    var prelude = this.SelectorList();
+
+    if (prelude.type !== 'Raw' &&
+        this.scanner.eof === false &&
+        this.scanner.tokenType !== LEFTCURLYBRACKET) {
+        this.error();
+    }
+
+    return prelude;
+}
+
+module.exports = {
+    name: 'Rule',
+    structure: {
+        prelude: ['SelectorList', 'Raw'],
+        block: ['Block']
+    },
+    parse: function() {
+        var startToken = this.scanner.tokenIndex;
+        var startOffset = this.scanner.tokenStart;
+        var prelude;
+        var block;
+
+        if (this.parseRulePrelude) {
+            prelude = this.parseWithFallback(consumePrelude, consumeRaw);
+        } else {
+            prelude = consumeRaw.call(this, startToken);
+        }
+
+        block = this.Block(true);
+
+        return {
+            type: 'Rule',
+            loc: this.getLocation(startOffset, this.scanner.tokenStart),
+            prelude: prelude,
+            block: block
+        };
+    },
+    generate: function(node) {
+        this.node(node.prelude);
+        this.node(node.block);
+    },
+    walkContext: 'rule'
+};

data/node_modules/css-tree/lib/syntax/node/Selector.js

@@ -0,0 +1,32 @@
+module.exports = {
+    name: 'Selector',
+    structure: {
+        children: [[
+            'TypeSelector',
+            'IdSelector',
+            'ClassSelector',
+            'AttributeSelector',
+            'PseudoClassSelector',
+            'PseudoElementSelector',
+            'Combinator',
+            'WhiteSpace'
+        ]]
+    },
+    parse: function() {
+        var children = this.readSequence(this.scope.Selector);
+
+        // nothing were consumed
+        if (this.getFirstListNode(children) === null) {
+            this.error('Selector is expected');
+        }
+
+        return {
+            type: 'Selector',
+            loc: this.getLocationFromList(children),
+            children: children
+        };
+    },
+    generate: function(node) {
+        this.children(node);
+    }
+};

data/node_modules/css-tree/lib/syntax/node/SelectorList.js

@@ -0,0 +1,39 @@
+var TYPE = require('../../tokenizer').TYPE;
+
+var COMMA = TYPE.Comma;
+
+module.exports = {
+    name: 'SelectorList',
+    structure: {
+        children: [[
+            'Selector',
+            'Raw'
+        ]]
+    },
+    parse: function() {
+        var children = this.createList();
+
+        while (!this.scanner.eof) {
+            children.push(this.Selector());
+
+            if (this.scanner.tokenType === COMMA) {
+                this.scanner.next();
+                continue;
+            }
+
+            break;
+        }
+
+        return {
+            type: 'SelectorList',
+            loc: this.getLocationFromList(children),
+            children: children
+        };
+    },
+    generate: function(node) {
+        this.children(node, function() {
+            this.chunk(',');
+        });
+    },
+    walkContext: 'selector'
+};

data/node_modules/css-tree/lib/syntax/node/String.js

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

data/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'
+};

data/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);
+    }
+};

data/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);
+    }
+};