diff options
Diffstat (limited to 'node_modules/css-tree/cjs/syntax')
76 files changed, 4233 insertions, 0 deletions
diff --git a/node_modules/css-tree/cjs/syntax/atrule/font-face.cjs b/node_modules/css-tree/cjs/syntax/atrule/font-face.cjs new file mode 100644 index 00000000..fc7f64a6 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/atrule/font-face.cjs @@ -0,0 +1,12 @@ +'use strict'; + +const fontFace = { + parse: { + prelude: null, + block() { + return this.Block(true); + } + } +}; + +module.exports = fontFace; diff --git a/node_modules/css-tree/cjs/syntax/atrule/import.cjs b/node_modules/css-tree/cjs/syntax/atrule/import.cjs new file mode 100644 index 00000000..bb4402b4 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/atrule/import.cjs @@ -0,0 +1,37 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const importAtrule = { + parse: { + prelude() { + const children = this.createList(); + + this.skipSC(); + + switch (this.tokenType) { + case types.String: + children.push(this.String()); + break; + + case types.Url: + case types.Function: + children.push(this.Url()); + break; + + default: + this.error('String or url() is expected'); + } + + if (this.lookupNonWSType(0) === types.Ident || + this.lookupNonWSType(0) === types.LeftParenthesis) { + children.push(this.MediaQueryList()); + } + + return children; + }, + block: null + } +}; + +module.exports = importAtrule; diff --git a/node_modules/css-tree/cjs/syntax/atrule/index.cjs b/node_modules/css-tree/cjs/syntax/atrule/index.cjs new file mode 100644 index 00000000..0cfe83d1 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/atrule/index.cjs @@ -0,0 +1,19 @@ +'use strict'; + +const fontFace = require('./font-face.cjs'); +const _import = require('./import.cjs'); +const media = require('./media.cjs'); +const nest = require('./nest.cjs'); +const page = require('./page.cjs'); +const supports = require('./supports.cjs'); + +const atrule = { + 'font-face': fontFace, + 'import': _import, + media, + nest, + page, + supports +}; + +module.exports = atrule; diff --git a/node_modules/css-tree/cjs/syntax/atrule/media.cjs b/node_modules/css-tree/cjs/syntax/atrule/media.cjs new file mode 100644 index 00000000..77214d1c --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/atrule/media.cjs @@ -0,0 +1,16 @@ +'use strict'; + +const media = { + parse: { + prelude() { + return this.createSingleNodeList( + this.MediaQueryList() + ); + }, + block(isStyleBlock = false) { + return this.Block(isStyleBlock); + } + } +}; + +module.exports = media; diff --git a/node_modules/css-tree/cjs/syntax/atrule/nest.cjs b/node_modules/css-tree/cjs/syntax/atrule/nest.cjs new file mode 100644 index 00000000..5cd66720 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/atrule/nest.cjs @@ -0,0 +1,16 @@ +'use strict'; + +const nest = { + parse: { + prelude() { + return this.createSingleNodeList( + this.SelectorList() + ); + }, + block() { + return this.Block(true); + } + } +}; + +module.exports = nest; diff --git a/node_modules/css-tree/cjs/syntax/atrule/page.cjs b/node_modules/css-tree/cjs/syntax/atrule/page.cjs new file mode 100644 index 00000000..ffef0d17 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/atrule/page.cjs @@ -0,0 +1,16 @@ +'use strict'; + +const page = { + parse: { + prelude() { + return this.createSingleNodeList( + this.SelectorList() + ); + }, + block() { + return this.Block(true); + } + } +}; + +module.exports = page; diff --git a/node_modules/css-tree/cjs/syntax/atrule/supports.cjs b/node_modules/css-tree/cjs/syntax/atrule/supports.cjs new file mode 100644 index 00000000..bf30f034 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/atrule/supports.cjs @@ -0,0 +1,77 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +function consumeRaw() { + return this.createSingleNodeList( + this.Raw(this.tokenIndex, null, false) + ); +} + +function parentheses() { + this.skipSC(); + + if (this.tokenType === types.Ident && + this.lookupNonWSType(1) === types.Colon) { + return this.createSingleNodeList( + this.Declaration() + ); + } + + return readSequence.call(this); +} + +function readSequence() { + const children = this.createList(); + let child; + + this.skipSC(); + + scan: + while (!this.eof) { + switch (this.tokenType) { + case types.Comment: + case types.WhiteSpace: + this.next(); + continue; + + case types.Function: + child = this.Function(consumeRaw, this.scope.AtrulePrelude); + break; + + case types.Ident: + child = this.Identifier(); + break; + + case types.LeftParenthesis: + child = this.Parentheses(parentheses, this.scope.AtrulePrelude); + break; + + default: + break scan; + } + + children.push(child); + } + + return children; +} + +const supports = { + parse: { + prelude() { + const children = readSequence.call(this); + + if (this.getFirstListNode(children) === null) { + this.error('Condition is expected'); + } + + return children; + }, + block(isStyleBlock = false) { + return this.Block(isStyleBlock); + } + } +}; + +module.exports = supports; diff --git a/node_modules/css-tree/cjs/syntax/config/generator.cjs b/node_modules/css-tree/cjs/syntax/config/generator.cjs new file mode 100644 index 00000000..c0924580 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/config/generator.cjs @@ -0,0 +1,9 @@ +'use strict'; + +const indexGenerate = require('../node/index-generate.cjs'); + +const config = { + node: indexGenerate +}; + +module.exports = config; diff --git a/node_modules/css-tree/cjs/syntax/config/lexer.cjs b/node_modules/css-tree/cjs/syntax/config/lexer.cjs new file mode 100644 index 00000000..083c74cd --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/config/lexer.cjs @@ -0,0 +1,12 @@ +'use strict'; + +const data = require('../../data.cjs'); +const index = require('../node/index.cjs'); + +const lexerConfig = { + generic: true, + ...data, + node: index +}; + +module.exports = lexerConfig; diff --git a/node_modules/css-tree/cjs/syntax/config/mix.cjs b/node_modules/css-tree/cjs/syntax/config/mix.cjs new file mode 100644 index 00000000..2d03af71 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/config/mix.cjs @@ -0,0 +1,119 @@ +'use strict'; + +function appendOrSet(a, b) { + if (typeof b === 'string' && /^\s*\|/.test(b)) { + return typeof a === 'string' + ? a + b + : b.replace(/^\s*\|\s*/, ''); + } + + return b || null; +} + +function sliceProps(obj, props) { + const result = Object.create(null); + + for (const [key, value] of Object.entries(obj)) { + if (value) { + result[key] = {}; + for (const prop of Object.keys(value)) { + if (props.includes(prop)) { + result[key][prop] = value[prop]; + } + } + } + } + + return result; +} + +function mix(dest, src) { + const result = { ...dest }; + + for (const [prop, value] of Object.entries(src)) { + switch (prop) { + case 'generic': + result[prop] = Boolean(value); + break; + + case 'units': + result[prop] = { ...dest[prop] }; + for (const [name, patch] of Object.entries(value)) { + result[prop][name] = Array.isArray(patch) ? patch : []; + } + break; + + case 'atrules': + result[prop] = { ...dest[prop] }; + + for (const [name, atrule] of Object.entries(value)) { + const exists = result[prop][name] || {}; + const current = result[prop][name] = { + prelude: exists.prelude || null, + descriptors: { + ...exists.descriptors + } + }; + + if (!atrule) { + continue; + } + + current.prelude = atrule.prelude + ? appendOrSet(current.prelude, atrule.prelude) + : current.prelude || null; + + for (const [descriptorName, descriptorValue] of Object.entries(atrule.descriptors || {})) { + current.descriptors[descriptorName] = descriptorValue + ? appendOrSet(current.descriptors[descriptorName], descriptorValue) + : null; + } + + if (!Object.keys(current.descriptors).length) { + current.descriptors = null; + } + } + break; + + case 'types': + case 'properties': + result[prop] = { ...dest[prop] }; + for (const [name, syntax] of Object.entries(value)) { + result[prop][name] = appendOrSet(result[prop][name], syntax); + } + break; + + case 'scope': + result[prop] = { ...dest[prop] }; + for (const [name, props] of Object.entries(value)) { + result[prop][name] = { ...result[prop][name], ...props }; + } + break; + + case 'parseContext': + result[prop] = { + ...dest[prop], + ...value + }; + break; + + case 'atrule': + case 'pseudo': + result[prop] = { + ...dest[prop], + ...sliceProps(value, ['parse']) }; + break; + + case 'node': + result[prop] = { + ...dest[prop], + ...sliceProps(value, ['name', 'structure', 'parse', 'generate', 'walkContext']) + }; + break; + } + } + + return result; +} + +module.exports = mix; diff --git a/node_modules/css-tree/cjs/syntax/config/parser-selector.cjs b/node_modules/css-tree/cjs/syntax/config/parser-selector.cjs new file mode 100644 index 00000000..03b1683b --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/config/parser-selector.cjs @@ -0,0 +1,19 @@ +'use strict'; + +const index = require('../pseudo/index.cjs'); +const indexParseSelector = require('../node/index-parse-selector.cjs'); +const selector = require('../scope/selector.cjs'); + +const config = { + parseContext: { + default: 'SelectorList', + selectorList: 'SelectorList', + selector: 'Selector' + }, + scope: { Selector: selector }, + atrule: {}, + pseudo: index, + node: indexParseSelector +}; + +module.exports = config; diff --git a/node_modules/css-tree/cjs/syntax/config/parser.cjs b/node_modules/css-tree/cjs/syntax/config/parser.cjs new file mode 100644 index 00000000..af65e801 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/config/parser.cjs @@ -0,0 +1,34 @@ +'use strict'; + +const index = require('../scope/index.cjs'); +const index$1 = require('../atrule/index.cjs'); +const index$2 = require('../pseudo/index.cjs'); +const indexParse = require('../node/index-parse.cjs'); + +const config = { + parseContext: { + default: 'StyleSheet', + stylesheet: 'StyleSheet', + atrule: 'Atrule', + atrulePrelude(options) { + return this.AtrulePrelude(options.atrule ? String(options.atrule) : null); + }, + mediaQueryList: 'MediaQueryList', + mediaQuery: 'MediaQuery', + rule: 'Rule', + selectorList: 'SelectorList', + selector: 'Selector', + block() { + return this.Block(true); + }, + declarationList: 'DeclarationList', + declaration: 'Declaration', + value: 'Value' + }, + scope: index, + atrule: index$1, + pseudo: index$2, + node: indexParse +}; + +module.exports = config; diff --git a/node_modules/css-tree/cjs/syntax/config/walker.cjs b/node_modules/css-tree/cjs/syntax/config/walker.cjs new file mode 100644 index 00000000..95c8f7df --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/config/walker.cjs @@ -0,0 +1,9 @@ +'use strict'; + +const index = require('../node/index.cjs'); + +const config = { + node: index +}; + +module.exports = config; diff --git a/node_modules/css-tree/cjs/syntax/create.cjs b/node_modules/css-tree/cjs/syntax/create.cjs new file mode 100644 index 00000000..aee487fb --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/create.cjs @@ -0,0 +1,57 @@ +'use strict'; + +const index = require('../tokenizer/index.cjs'); +const create = require('../parser/create.cjs'); +const create$2 = require('../generator/create.cjs'); +const create$3 = require('../convertor/create.cjs'); +const create$1 = require('../walker/create.cjs'); +const Lexer = require('../lexer/Lexer.cjs'); +const mix = require('./config/mix.cjs'); + +function createSyntax(config) { + const parse = create.createParser(config); + const walk = create$1.createWalker(config); + const generate = create$2.createGenerator(config); + const { fromPlainObject, toPlainObject } = create$3.createConvertor(walk); + + const syntax = { + lexer: null, + createLexer: config => new Lexer.Lexer(config, syntax, syntax.lexer.structure), + + tokenize: index.tokenize, + parse, + generate, + + walk, + find: walk.find, + findLast: walk.findLast, + findAll: walk.findAll, + + fromPlainObject, + toPlainObject, + + fork(extension) { + const base = mix({}, config); // copy of config + + return createSyntax( + typeof extension === 'function' + ? extension(base, Object.assign) + : mix(base, extension) + ); + } + }; + + syntax.lexer = new Lexer.Lexer({ + generic: true, + units: config.units, + types: config.types, + atrules: config.atrules, + properties: config.properties, + node: config.node + }, syntax); + + return syntax; +} +const createSyntax$1 = config => createSyntax(mix({}, config)); + +module.exports = createSyntax$1; diff --git a/node_modules/css-tree/cjs/syntax/function/expression.cjs b/node_modules/css-tree/cjs/syntax/function/expression.cjs new file mode 100644 index 00000000..43d81374 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/function/expression.cjs @@ -0,0 +1,11 @@ +'use strict'; + +// legacy IE function +// expression( <any-value> ) +function expressionFn() { + return this.createSingleNodeList( + this.Raw(this.tokenIndex, null, false) + ); +} + +module.exports = expressionFn; diff --git a/node_modules/css-tree/cjs/syntax/function/var.cjs b/node_modules/css-tree/cjs/syntax/function/var.cjs new file mode 100644 index 00000000..96729706 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/function/var.cjs @@ -0,0 +1,43 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +// var( <ident> , <value>? ) +function varFn() { + const children = this.createList(); + + this.skipSC(); + + // NOTE: Don't check more than a first argument is an ident, rest checks are for lexer + children.push(this.Identifier()); + + this.skipSC(); + + if (this.tokenType === types.Comma) { + children.push(this.Operator()); + + const startIndex = this.tokenIndex; + const value = this.parseCustomProperty + ? this.Value(null) + : this.Raw(this.tokenIndex, this.consumeUntilExclamationMarkOrSemicolon, false); + + if (value.type === 'Value' && value.children.isEmpty) { + for (let offset = startIndex - this.tokenIndex; offset <= 0; offset++) { + if (this.lookupType(offset) === types.WhiteSpace) { + value.children.appendData({ + type: 'WhiteSpace', + loc: null, + value: ' ' + }); + break; + } + } + } + + children.push(value); + } + + return children; +} + +module.exports = varFn; diff --git a/node_modules/css-tree/cjs/syntax/index.cjs b/node_modules/css-tree/cjs/syntax/index.cjs new file mode 100644 index 00000000..24de4957 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/index.cjs @@ -0,0 +1,14 @@ +'use strict'; + +const create = require('./create.cjs'); +const lexer = require('./config/lexer.cjs'); +const parser = require('./config/parser.cjs'); +const walker = require('./config/walker.cjs'); + +const syntax = create({ + ...lexer, + ...parser, + ...walker +}); + +module.exports = syntax; diff --git a/node_modules/css-tree/cjs/syntax/node/AnPlusB.cjs b/node_modules/css-tree/cjs/syntax/node/AnPlusB.cjs new file mode 100644 index 00000000..cd59927a --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/AnPlusB.cjs @@ -0,0 +1,293 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); +const charCodeDefinitions = require('../../tokenizer/char-code-definitions.cjs'); + +const PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+) +const HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-) +const N = 0x006E; // U+006E LATIN SMALL LETTER N (n) +const DISALLOW_SIGN = true; +const ALLOW_SIGN = false; + +function checkInteger(offset, disallowSign) { + let pos = this.tokenStart + offset; + const code = this.charCodeAt(pos); + + if (code === PLUSSIGN || code === HYPHENMINUS) { + if (disallowSign) { + this.error('Number sign is not allowed'); + } + pos++; + } + + for (; pos < this.tokenEnd; pos++) { + if (!charCodeDefinitions.isDigit(this.charCodeAt(pos))) { + this.error('Integer is expected', pos); + } + } +} + +function checkTokenIsInteger(disallowSign) { + return checkInteger.call(this, 0, disallowSign); +} + +function expectCharCode(offset, code) { + if (!this.cmpChar(this.tokenStart + offset, code)) { + let msg = ''; + + switch (code) { + case N: + msg = 'N is expected'; + break; + case HYPHENMINUS: + msg = 'HyphenMinus is expected'; + break; + } + + this.error(msg, this.tokenStart + offset); + } +} + +// ... <signed-integer> +// ... ['+' | '-'] <signless-integer> +function consumeB() { + let offset = 0; + let sign = 0; + let type = this.tokenType; + + while (type === types.WhiteSpace || type === types.Comment) { + type = this.lookupType(++offset); + } + + if (type !== types.Number) { + if (this.isDelim(PLUSSIGN, offset) || + this.isDelim(HYPHENMINUS, offset)) { + sign = this.isDelim(PLUSSIGN, offset) ? PLUSSIGN : HYPHENMINUS; + + do { + type = this.lookupType(++offset); + } while (type === types.WhiteSpace || type === types.Comment); + + if (type !== types.Number) { + this.skip(offset); + checkTokenIsInteger.call(this, DISALLOW_SIGN); + } + } else { + return null; + } + } + + if (offset > 0) { + this.skip(offset); + } + + if (sign === 0) { + type = this.charCodeAt(this.tokenStart); + if (type !== PLUSSIGN && type !== HYPHENMINUS) { + this.error('Number sign is expected'); + } + } + + checkTokenIsInteger.call(this, sign !== 0); + return sign === HYPHENMINUS ? '-' + this.consume(types.Number) : this.consume(types.Number); +} + +// An+B microsyntax https://www.w3.org/TR/css-syntax-3/#anb +const name = 'AnPlusB'; +const structure = { + a: [String, null], + b: [String, null] +}; + +function parse() { + /* eslint-disable brace-style*/ + const start = this.tokenStart; + let a = null; + let b = null; + + // <integer> + if (this.tokenType === types.Number) { + checkTokenIsInteger.call(this, ALLOW_SIGN); + b = this.consume(types.Number); + } + + // -n + // -n <signed-integer> + // -n ['+' | '-'] <signless-integer> + // -n- <signless-integer> + // <dashndashdigit-ident> + else if (this.tokenType === types.Ident && this.cmpChar(this.tokenStart, HYPHENMINUS)) { + a = '-1'; + + expectCharCode.call(this, 1, N); + + switch (this.tokenEnd - this.tokenStart) { + // -n + // -n <signed-integer> + // -n ['+' | '-'] <signless-integer> + case 2: + this.next(); + b = consumeB.call(this); + break; + + // -n- <signless-integer> + case 3: + expectCharCode.call(this, 2, HYPHENMINUS); + + this.next(); + this.skipSC(); + + checkTokenIsInteger.call(this, DISALLOW_SIGN); + + b = '-' + this.consume(types.Number); + break; + + // <dashndashdigit-ident> + default: + expectCharCode.call(this, 2, HYPHENMINUS); + checkInteger.call(this, 3, DISALLOW_SIGN); + this.next(); + + b = this.substrToCursor(start + 2); + } + } + + // '+'? n + // '+'? n <signed-integer> + // '+'? n ['+' | '-'] <signless-integer> + // '+'? n- <signless-integer> + // '+'? <ndashdigit-ident> + else if (this.tokenType === types.Ident || (this.isDelim(PLUSSIGN) && this.lookupType(1) === types.Ident)) { + let sign = 0; + a = '1'; + + // just ignore a plus + if (this.isDelim(PLUSSIGN)) { + sign = 1; + this.next(); + } + + expectCharCode.call(this, 0, N); + + switch (this.tokenEnd - this.tokenStart) { + // '+'? n + // '+'? n <signed-integer> + // '+'? n ['+' | '-'] <signless-integer> + case 1: + this.next(); + b = consumeB.call(this); + break; + + // '+'? n- <signless-integer> + case 2: + expectCharCode.call(this, 1, HYPHENMINUS); + + this.next(); + this.skipSC(); + + checkTokenIsInteger.call(this, DISALLOW_SIGN); + + b = '-' + this.consume(types.Number); + break; + + // '+'? <ndashdigit-ident> + default: + expectCharCode.call(this, 1, HYPHENMINUS); + checkInteger.call(this, 2, DISALLOW_SIGN); + this.next(); + + b = this.substrToCursor(start + sign + 1); + } + } + + // <ndashdigit-dimension> + // <ndash-dimension> <signless-integer> + // <n-dimension> + // <n-dimension> <signed-integer> + // <n-dimension> ['+' | '-'] <signless-integer> + else if (this.tokenType === types.Dimension) { + const code = this.charCodeAt(this.tokenStart); + const sign = code === PLUSSIGN || code === HYPHENMINUS; + let i = this.tokenStart + sign; + + for (; i < this.tokenEnd; i++) { + if (!charCodeDefinitions.isDigit(this.charCodeAt(i))) { + break; + } + } + + if (i === this.tokenStart + sign) { + this.error('Integer is expected', this.tokenStart + sign); + } + + expectCharCode.call(this, i - this.tokenStart, N); + a = this.substring(start, i); + + // <n-dimension> + // <n-dimension> <signed-integer> + // <n-dimension> ['+' | '-'] <signless-integer> + if (i + 1 === this.tokenEnd) { + this.next(); + b = consumeB.call(this); + } else { + expectCharCode.call(this, i - this.tokenStart + 1, HYPHENMINUS); + + // <ndash-dimension> <signless-integer> + if (i + 2 === this.tokenEnd) { + this.next(); + this.skipSC(); + checkTokenIsInteger.call(this, DISALLOW_SIGN); + b = '-' + this.consume(types.Number); + } + // <ndashdigit-dimension> + else { + checkInteger.call(this, i - this.tokenStart + 2, DISALLOW_SIGN); + this.next(); + b = this.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.tokenStart), + a, + b + }; +} + +function generate(node) { + if (node.a) { + const a = + node.a === '+1' && 'n' || + node.a === '1' && 'n' || + node.a === '-1' && '-n' || + node.a + 'n'; + + if (node.b) { + const b = node.b[0] === '-' || node.b[0] === '+' + ? node.b + : '+' + node.b; + this.tokenize(a + b); + } else { + this.tokenize(a); + } + } else { + this.tokenize(node.b); + } +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Atrule.cjs b/node_modules/css-tree/cjs/syntax/node/Atrule.cjs new file mode 100644 index 00000000..44746306 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Atrule.cjs @@ -0,0 +1,103 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +function consumeRaw(startToken) { + return this.Raw(startToken, this.consumeUntilLeftCurlyBracketOrSemicolon, true); +} + +function isDeclarationBlockAtrule() { + for (let offset = 1, type; type = this.lookupType(offset); offset++) { + if (type === types.RightCurlyBracket) { + return true; + } + + if (type === types.LeftCurlyBracket || + type === types.AtKeyword) { + return false; + } + } + + return false; +} + + +const name = 'Atrule'; +const walkContext = 'atrule'; +const structure = { + name: String, + prelude: ['AtrulePrelude', 'Raw', null], + block: ['Block', null] +}; + +function parse(isDeclaration = false) { + const start = this.tokenStart; + let name; + let nameLowerCase; + let prelude = null; + let block = null; + + this.eat(types.AtKeyword); + + name = this.substrToCursor(start + 1); + nameLowerCase = name.toLowerCase(); + this.skipSC(); + + // parse prelude + if (this.eof === false && + this.tokenType !== types.LeftCurlyBracket && + this.tokenType !== types.Semicolon) { + if (this.parseAtrulePrelude) { + prelude = this.parseWithFallback(this.AtrulePrelude.bind(this, name, isDeclaration), consumeRaw); + } else { + prelude = consumeRaw.call(this, this.tokenIndex); + } + + this.skipSC(); + } + + switch (this.tokenType) { + case types.Semicolon: + this.next(); + break; + + case types.LeftCurlyBracket: + if (hasOwnProperty.call(this.atrule, nameLowerCase) && + typeof this.atrule[nameLowerCase].block === 'function') { + block = this.atrule[nameLowerCase].block.call(this, isDeclaration); + } else { + // TODO: should consume block content as Raw? + block = this.Block(isDeclarationBlockAtrule.call(this)); + } + + break; + } + + return { + type: 'Atrule', + loc: this.getLocation(start, this.tokenStart), + name, + prelude, + block + }; +} + +function generate(node) { + this.token(types.AtKeyword, '@' + node.name); + + if (node.prelude !== null) { + this.node(node.prelude); + } + + if (node.block) { + this.node(node.block); + } else { + this.token(types.Semicolon, ';'); + } +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; +exports.walkContext = walkContext; diff --git a/node_modules/css-tree/cjs/syntax/node/AtrulePrelude.cjs b/node_modules/css-tree/cjs/syntax/node/AtrulePrelude.cjs new file mode 100644 index 00000000..0db69b67 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/AtrulePrelude.cjs @@ -0,0 +1,52 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'AtrulePrelude'; +const walkContext = 'atrulePrelude'; +const structure = { + children: [[]] +}; + +function parse(name) { + let children = null; + + if (name !== null) { + name = name.toLowerCase(); + } + + this.skipSC(); + + if (hasOwnProperty.call(this.atrule, 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.skipSC(); + + if (this.eof !== true && + this.tokenType !== types.LeftCurlyBracket && + this.tokenType !== types.Semicolon) { + this.error('Semicolon or block is expected'); + } + + return { + type: 'AtrulePrelude', + loc: this.getLocationFromList(children), + children + }; +} + +function generate(node) { + this.children(node); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; +exports.walkContext = walkContext; diff --git a/node_modules/css-tree/cjs/syntax/node/AttributeSelector.cjs b/node_modules/css-tree/cjs/syntax/node/AttributeSelector.cjs new file mode 100644 index 00000000..757d4ebf --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/AttributeSelector.cjs @@ -0,0 +1,148 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const DOLLARSIGN = 0x0024; // U+0024 DOLLAR SIGN ($) +const ASTERISK = 0x002A; // U+002A ASTERISK (*) +const EQUALSSIGN = 0x003D; // U+003D EQUALS SIGN (=) +const CIRCUMFLEXACCENT = 0x005E; // U+005E (^) +const VERTICALLINE = 0x007C; // U+007C VERTICAL LINE (|) +const TILDE = 0x007E; // U+007E TILDE (~) + +function getAttributeName() { + if (this.eof) { + this.error('Unexpected end of input'); + } + + const start = this.tokenStart; + let expectIdent = false; + + if (this.isDelim(ASTERISK)) { + expectIdent = true; + this.next(); + } else if (!this.isDelim(VERTICALLINE)) { + this.eat(types.Ident); + } + + if (this.isDelim(VERTICALLINE)) { + if (this.charCodeAt(this.tokenStart + 1) !== EQUALSSIGN) { + this.next(); + this.eat(types.Ident); + } else if (expectIdent) { + this.error('Identifier is expected', this.tokenEnd); + } + } else if (expectIdent) { + this.error('Vertical line is expected'); + } + + return { + type: 'Identifier', + loc: this.getLocation(start, this.tokenStart), + name: this.substrToCursor(start) + }; +} + +function getOperator() { + const start = this.tokenStart; + const code = this.charCodeAt(start); + + if (code !== EQUALSSIGN && // = + code !== TILDE && // ~= + code !== CIRCUMFLEXACCENT && // ^= + code !== DOLLARSIGN && // $= + code !== ASTERISK && // *= + code !== VERTICALLINE // |= + ) { + this.error('Attribute selector (=, ~=, ^=, $=, *=, |=) is expected'); + } + + this.next(); + + if (code !== EQUALSSIGN) { + if (!this.isDelim(EQUALSSIGN)) { + this.error('Equal sign is expected'); + } + + this.next(); + } + + return this.substrToCursor(start); +} + +// '[' <wq-name> ']' +// '[' <wq-name> <attr-matcher> [ <string-token> | <ident-token> ] <attr-modifier>? ']' +const name = 'AttributeSelector'; +const structure = { + name: 'Identifier', + matcher: [String, null], + value: ['String', 'Identifier', null], + flags: [String, null] +}; + +function parse() { + const start = this.tokenStart; + let name; + let matcher = null; + let value = null; + let flags = null; + + this.eat(types.LeftSquareBracket); + this.skipSC(); + + name = getAttributeName.call(this); + this.skipSC(); + + if (this.tokenType !== types.RightSquareBracket) { + // avoid case `[name i]` + if (this.tokenType !== types.Ident) { + matcher = getOperator.call(this); + + this.skipSC(); + + value = this.tokenType === types.String + ? this.String() + : this.Identifier(); + + this.skipSC(); + } + + // attribute flags + if (this.tokenType === types.Ident) { + flags = this.consume(types.Ident); + + this.skipSC(); + } + } + + this.eat(types.RightSquareBracket); + + return { + type: 'AttributeSelector', + loc: this.getLocation(start, this.tokenStart), + name, + matcher, + value, + flags + }; +} + +function generate(node) { + this.token(types.Delim, '['); + this.node(node.name); + + if (node.matcher !== null) { + this.tokenize(node.matcher); + this.node(node.value); + } + + if (node.flags !== null) { + this.token(types.Ident, node.flags); + } + + this.token(types.Delim, ']'); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Block.cjs b/node_modules/css-tree/cjs/syntax/node/Block.cjs new file mode 100644 index 00000000..ce1058f1 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Block.cjs @@ -0,0 +1,96 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const AMPERSAND = 0x0026; // U+0026 AMPERSAND (&) + +function consumeRaw(startToken) { + return this.Raw(startToken, null, true); +} +function consumeRule() { + return this.parseWithFallback(this.Rule, consumeRaw); +} +function consumeRawDeclaration(startToken) { + return this.Raw(startToken, this.consumeUntilSemicolonIncluded, true); +} +function consumeDeclaration() { + if (this.tokenType === types.Semicolon) { + return consumeRawDeclaration.call(this, this.tokenIndex); + } + + const node = this.parseWithFallback(this.Declaration, consumeRawDeclaration); + + if (this.tokenType === types.Semicolon) { + this.next(); + } + + return node; +} + +const name = 'Block'; +const walkContext = 'block'; +const structure = { + children: [[ + 'Atrule', + 'Rule', + 'Declaration' + ]] +}; + +function parse(isStyleBlock) { + const consumer = isStyleBlock ? consumeDeclaration : consumeRule; + const start = this.tokenStart; + let children = this.createList(); + + this.eat(types.LeftCurlyBracket); + + scan: + while (!this.eof) { + switch (this.tokenType) { + case types.RightCurlyBracket: + break scan; + + case types.WhiteSpace: + case types.Comment: + this.next(); + break; + + case types.AtKeyword: + children.push(this.parseWithFallback(this.Atrule.bind(this, isStyleBlock), consumeRaw)); + break; + + default: + if (isStyleBlock && this.isDelim(AMPERSAND)) { + children.push(consumeRule.call(this)); + } else { + children.push(consumer.call(this)); + } + } + } + + if (!this.eof) { + this.eat(types.RightCurlyBracket); + } + + return { + type: 'Block', + loc: this.getLocation(start, this.tokenStart), + children + }; +} + +function generate(node) { + this.token(types.LeftCurlyBracket, '{'); + this.children(node, prev => { + if (prev.type === 'Declaration') { + this.token(types.Semicolon, ';'); + } + }); + this.token(types.RightCurlyBracket, '}'); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; +exports.walkContext = walkContext; diff --git a/node_modules/css-tree/cjs/syntax/node/Brackets.cjs b/node_modules/css-tree/cjs/syntax/node/Brackets.cjs new file mode 100644 index 00000000..eb181318 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Brackets.cjs @@ -0,0 +1,38 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'Brackets'; +const structure = { + children: [[]] +}; + +function parse(readSequence, recognizer) { + const start = this.tokenStart; + let children = null; + + this.eat(types.LeftSquareBracket); + + children = readSequence.call(this, recognizer); + + if (!this.eof) { + this.eat(types.RightSquareBracket); + } + + return { + type: 'Brackets', + loc: this.getLocation(start, this.tokenStart), + children + }; +} + +function generate(node) { + this.token(types.Delim, '['); + this.children(node); + this.token(types.Delim, ']'); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/CDC.cjs b/node_modules/css-tree/cjs/syntax/node/CDC.cjs new file mode 100644 index 00000000..aadf3ad7 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/CDC.cjs @@ -0,0 +1,26 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'CDC'; +const structure = []; + +function parse() { + const start = this.tokenStart; + + this.eat(types.CDC); // --> + + return { + type: 'CDC', + loc: this.getLocation(start, this.tokenStart) + }; +} + +function generate() { + this.token(types.CDC, '-->'); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/CDO.cjs b/node_modules/css-tree/cjs/syntax/node/CDO.cjs new file mode 100644 index 00000000..0e982178 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/CDO.cjs @@ -0,0 +1,26 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'CDO'; +const structure = []; + +function parse() { + const start = this.tokenStart; + + this.eat(types.CDO); // <!-- + + return { + type: 'CDO', + loc: this.getLocation(start, this.tokenStart) + }; +} + +function generate() { + this.token(types.CDO, '<!--'); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/ClassSelector.cjs b/node_modules/css-tree/cjs/syntax/node/ClassSelector.cjs new file mode 100644 index 00000000..ff3de5cf --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/ClassSelector.cjs @@ -0,0 +1,31 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const FULLSTOP = 0x002E; // U+002E FULL STOP (.) + +// '.' ident +const name = 'ClassSelector'; +const structure = { + name: String +}; + +function parse() { + this.eatDelim(FULLSTOP); + + return { + type: 'ClassSelector', + loc: this.getLocation(this.tokenStart - 1, this.tokenEnd), + name: this.consume(types.Ident) + }; +} + +function generate(node) { + this.token(types.Delim, '.'); + this.token(types.Ident, node.name); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Combinator.cjs b/node_modules/css-tree/cjs/syntax/node/Combinator.cjs new file mode 100644 index 00000000..1a242788 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Combinator.cjs @@ -0,0 +1,61 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+) +const SOLIDUS = 0x002F; // U+002F SOLIDUS (/) +const GREATERTHANSIGN = 0x003E; // U+003E GREATER-THAN SIGN (>) +const TILDE = 0x007E; // U+007E TILDE (~) + +const name = 'Combinator'; +const structure = { + name: String +}; + +// + | > | ~ | /deep/ +function parse() { + const start = this.tokenStart; + let name; + + switch (this.tokenType) { + case types.WhiteSpace: + name = ' '; + break; + + case types.Delim: + switch (this.charCodeAt(this.tokenStart)) { + case GREATERTHANSIGN: + case PLUSSIGN: + case TILDE: + this.next(); + break; + + case SOLIDUS: + this.next(); + this.eatIdent('deep'); + this.eatDelim(SOLIDUS); + break; + + default: + this.error('Combinator is expected'); + } + + name = this.substrToCursor(start); + break; + } + + return { + type: 'Combinator', + loc: this.getLocation(start, this.tokenStart), + name + }; +} + +function generate(node) { + this.tokenize(node.name); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Comment.cjs b/node_modules/css-tree/cjs/syntax/node/Comment.cjs new file mode 100644 index 00000000..083e950b --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Comment.cjs @@ -0,0 +1,40 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const ASTERISK = 0x002A; // U+002A ASTERISK (*) +const SOLIDUS = 0x002F; // U+002F SOLIDUS (/) + + +const name = 'Comment'; +const structure = { + value: String +}; + +function parse() { + const start = this.tokenStart; + let end = this.tokenEnd; + + this.eat(types.Comment); + + if ((end - start + 2) >= 2 && + this.charCodeAt(end - 2) === ASTERISK && + this.charCodeAt(end - 1) === SOLIDUS) { + end -= 2; + } + + return { + type: 'Comment', + loc: this.getLocation(start, this.tokenStart), + value: this.substring(start + 2, end) + }; +} + +function generate(node) { + this.token(types.Comment, '/*' + node.value + '*/'); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Condition.cjs b/node_modules/css-tree/cjs/syntax/node/Condition.cjs new file mode 100644 index 00000000..a49b9989 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Condition.cjs @@ -0,0 +1,127 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const MediaFeatureToken = new Set([types.Colon, types.RightParenthesis, types.EOF]); +const SupportsFeatureToken = new Set([types.Colon, types.EOF]); + +const name = 'Condition'; +const structure = { + kind: String, + children: [[ + 'Identifier', + 'Feature', + 'FeatureRange' + ]] +}; + +const conditions = { + media() { + if (this.tokenType === types.LeftParenthesis) { + const firstToken = this.lookupTypeNonSC(1); + if (firstToken === types.Ident && MediaFeatureToken.has(this.lookupTypeNonSC(2))) { + return this.Feature('media'); + } else if (firstToken !== types.LeftParenthesis) { + return this.parseWithFallback(() => this.FeatureRange('media'), (startIndex) => { + this.skip(startIndex - this.tokenIndex); + }); + } + } + }, + supports() { + if (this.tokenType === types.LeftParenthesis) { + if (this.lookupTypeNonSC(1) === types.Ident && SupportsFeatureToken.has(this.lookupTypeNonSC(2))) { + return this.Declaration(); + } + } + }, + container() { + if (this.tokenType === types.LeftParenthesis) { + if (this.lookupTypeNonSC(1) === types.Ident && MediaFeatureToken.has(this.lookupTypeNonSC(2))) { + return this.Feature('size'); + } else if (this.lookupTypeNonSC(1) !== types.LeftParenthesis) { + return this.FeatureRange('size'); + } + } + } +}; + +function parse(kind = 'media') { + const children = this.createList(); + const termParser = conditions[kind]; + + scan: while (!this.eof) { + switch (this.tokenType) { + case types.Comment: + case types.WhiteSpace: + this.next(); + continue; + + case types.Ident: + children.push(this.Identifier()); + break; + + case types.LeftParenthesis: { + let term = termParser.call(this); + + if (!term) { + term = this.parseWithFallback(() => { + this.next(); + const res = this.Condition(kind); + this.eat(types.RightParenthesis); + return res; + }, (startIndex) => { + this.skip(startIndex - this.tokenIndex); + return this.GeneralEnclosed(); + }); + } + + children.push(term); + break; + } + + case types.Function: { + let term = termParser.call(this); + + if (!term) { + term = this.GeneralEnclosed(); + } + + children.push(term); + break; + } + + default: + break scan; + } + } + + if (children.isEmpty) { + this.error('Condition can\'t be empty'); + } + + return { + type: 'Condition', + loc: this.getLocationFromList(children), + kind, + children + }; +} + +function generate(node) { + node.children.forEach(child => { + if (child.type === 'Condition') { + this.token(types.LeftParenthesis, '('); + this.node(child); + this.token(types.RightParenthesis, ')'); + } else { + this.node(child); + } + }); +} + +exports.conditions = conditions; +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Declaration.cjs b/node_modules/css-tree/cjs/syntax/node/Declaration.cjs new file mode 100644 index 00000000..c0075770 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Declaration.cjs @@ -0,0 +1,166 @@ +'use strict'; + +const names = require('../../utils/names.cjs'); +const types = require('../../tokenizer/types.cjs'); + +const EXCLAMATIONMARK = 0x0021; // U+0021 EXCLAMATION MARK (!) +const NUMBERSIGN = 0x0023; // U+0023 NUMBER SIGN (#) +const DOLLARSIGN = 0x0024; // U+0024 DOLLAR SIGN ($) +const AMPERSAND = 0x0026; // U+0026 AMPERSAND (&) +const ASTERISK = 0x002A; // U+002A ASTERISK (*) +const PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+) +const SOLIDUS = 0x002F; // U+002F SOLIDUS (/) + +function consumeValueRaw(startToken) { + return this.Raw(startToken, this.consumeUntilExclamationMarkOrSemicolon, true); +} + +function consumeCustomPropertyRaw(startToken) { + return this.Raw(startToken, this.consumeUntilExclamationMarkOrSemicolon, false); +} + +function consumeValue() { + const startValueToken = this.tokenIndex; + const value = this.Value(); + + if (value.type !== 'Raw' && + this.eof === false && + this.tokenType !== types.Semicolon && + this.isDelim(EXCLAMATIONMARK) === false && + this.isBalanceEdge(startValueToken) === false) { + this.error(); + } + + return value; +} + +const name = 'Declaration'; +const walkContext = 'declaration'; +const structure = { + important: [Boolean, String], + property: String, + value: ['Value', 'Raw'] +}; + +function parse() { + const start = this.tokenStart; + const startToken = this.tokenIndex; + const property = readProperty.call(this); + const customProperty = names.isCustomProperty(property); + const parseValue = customProperty ? this.parseCustomProperty : this.parseValue; + const consumeRaw = customProperty ? consumeCustomPropertyRaw : consumeValueRaw; + let important = false; + let value; + + this.skipSC(); + this.eat(types.Colon); + + const valueStart = this.tokenIndex; + + if (!customProperty) { + this.skipSC(); + } + + if (parseValue) { + value = this.parseWithFallback(consumeValue, consumeRaw); + } else { + value = consumeRaw.call(this, this.tokenIndex); + } + + if (customProperty && value.type === 'Value' && value.children.isEmpty) { + for (let offset = valueStart - this.tokenIndex; offset <= 0; offset++) { + if (this.lookupType(offset) === types.WhiteSpace) { + value.children.appendData({ + type: 'WhiteSpace', + loc: null, + value: ' ' + }); + break; + } + } + } + + if (this.isDelim(EXCLAMATIONMARK)) { + important = getImportant.call(this); + this.skipSC(); + } + + // Do not include semicolon to range per spec + // https://drafts.csswg.org/css-syntax/#declaration-diagram + + if (this.eof === false && + this.tokenType !== types.Semicolon && + this.isBalanceEdge(startToken) === false) { + this.error(); + } + + return { + type: 'Declaration', + loc: this.getLocation(start, this.tokenStart), + important, + property, + value + }; +} + +function generate(node) { + this.token(types.Ident, node.property); + this.token(types.Colon, ':'); + this.node(node.value); + + if (node.important) { + this.token(types.Delim, '!'); + this.token(types.Ident, node.important === true ? 'important' : node.important); + } +} + +function readProperty() { + const start = this.tokenStart; + + // hacks + if (this.tokenType === types.Delim) { + switch (this.charCodeAt(this.tokenStart)) { + case ASTERISK: + case DOLLARSIGN: + case PLUSSIGN: + case NUMBERSIGN: + case AMPERSAND: + this.next(); + break; + + // TODO: not sure we should support this hack + case SOLIDUS: + this.next(); + if (this.isDelim(SOLIDUS)) { + this.next(); + } + break; + } + } + + if (this.tokenType === types.Hash) { + this.eat(types.Hash); + } else { + this.eat(types.Ident); + } + + return this.substrToCursor(start); +} + +// ! ws* important +function getImportant() { + this.eat(types.Delim); + this.skipSC(); + + const important = this.consume(types.Ident); + + // store original value in case it differ from `important` + // for better original source restoring and hacks like `!ie` support + return important === 'important' ? true : important; +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; +exports.walkContext = walkContext; diff --git a/node_modules/css-tree/cjs/syntax/node/DeclarationList.cjs b/node_modules/css-tree/cjs/syntax/node/DeclarationList.cjs new file mode 100644 index 00000000..9df4dc3a --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/DeclarationList.cjs @@ -0,0 +1,62 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const AMPERSAND = 0x0026; // U+0026 AMPERSAND (&) + +function consumeRaw(startToken) { + return this.Raw(startToken, this.consumeUntilSemicolonIncluded, true); +} + +const name = 'DeclarationList'; +const structure = { + children: [[ + 'Declaration', + 'Atrule', + 'Rule' + ]] +}; + +function parse() { + const children = this.createList(); + + while (!this.eof) { + switch (this.tokenType) { + case types.WhiteSpace: + case types.Comment: + case types.Semicolon: + this.next(); + break; + + case types.AtKeyword: + children.push(this.parseWithFallback(this.Atrule.bind(this, true), consumeRaw)); + break; + + default: + if (this.isDelim(AMPERSAND)) { + children.push(this.parseWithFallback(this.Rule, consumeRaw)); + } else { + children.push(this.parseWithFallback(this.Declaration, consumeRaw)); + } + } + } + + return { + type: 'DeclarationList', + loc: this.getLocationFromList(children), + children + }; +} + +function generate(node) { + this.children(node, prev => { + if (prev.type === 'Declaration') { + this.token(types.Semicolon, ';'); + } + }); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Dimension.cjs b/node_modules/css-tree/cjs/syntax/node/Dimension.cjs new file mode 100644 index 00000000..227184cc --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Dimension.cjs @@ -0,0 +1,30 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'Dimension'; +const structure = { + value: String, + unit: String +}; + +function parse() { + const start = this.tokenStart; + const value = this.consumeNumber(types.Dimension); + + return { + type: 'Dimension', + loc: this.getLocation(start, this.tokenStart), + value, + unit: this.substring(start + value.length, this.tokenStart) + }; +} + +function generate(node) { + this.token(types.Dimension, node.value + node.unit); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Feature.cjs b/node_modules/css-tree/cjs/syntax/node/Feature.cjs new file mode 100644 index 00000000..23fc356d --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Feature.cjs @@ -0,0 +1,78 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'Feature'; +const structure = { + kind: String, + name: String, + value: ['Identifier', 'Number', 'Dimension', 'Ratio', null] +}; + +function parse(kind = 'unknown') { + const start = this.tokenStart; + let name; + let value = null; + + this.eat(types.LeftParenthesis); + this.skipSC(); + + name = this.consume(types.Ident); + this.skipSC(); + + if (this.tokenType !== types.RightParenthesis) { + this.eat(types.Colon); + this.skipSC(); + + switch (this.tokenType) { + case types.Number: + if (this.lookupNonWSType(1) === types.Delim) { + value = this.Ratio(); + } else { + value = this.Number(); + } + + break; + + case types.Dimension: + value = this.Dimension(); + break; + + case types.Ident: + value = this.Identifier(); + break; + + default: + this.error('Number, dimension, ratio or identifier is expected'); + } + + this.skipSC(); + } + + this.eat(types.RightParenthesis); + + return { + type: 'Feature', + loc: this.getLocation(start, this.tokenStart), + kind, + name, + value + }; +} + +function generate(node) { + this.token(types.LeftParenthesis, '('); + this.token(types.Ident, node.name); + + if (node.value !== null) { + this.token(types.Colon, ':'); + this.node(node.value); + } + + this.token(types.RightParenthesis, ')'); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/FeatureRange.cjs b/node_modules/css-tree/cjs/syntax/node/FeatureRange.cjs new file mode 100644 index 00000000..1db82596 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/FeatureRange.cjs @@ -0,0 +1,114 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const LESSTHANSIGN = 60; // < +const EQUALSIGN = 61; // = +const GREATERTHANSIGN = 62; // > + +const name = 'FeatureRange'; +const structure = { + kind: String, + left: ['Identifier', 'Number', 'Dimension', 'Ratio'], + leftComparison: String, + middle: ['Identifier', 'Number', 'Dimension', 'Ratio'], + rightComparison: [String, null], + right: ['Identifier', 'Number', 'Dimension', 'Ratio', null] +}; + +function readTerm() { + this.skipSC(); + + switch (this.tokenType) { + case types.Number: + if (this.lookupNonWSType(1) === types.Delim) { + return this.Ratio(); + } else { + return this.Number(); + } + + case types.Dimension: + return this.Dimension(); + + case types.Ident: + return this.Identifier(); + + default: + this.error('Number, dimension, ratio or identifier is expected'); + } +} + +function readComparison(expectColon) { + this.skipSC(); + + if (this.isDelim(LESSTHANSIGN) || + this.isDelim(GREATERTHANSIGN)) { + const value = this.source[this.tokenStart]; + + this.next(); + + if (this.isDelim(EQUALSIGN)) { + this.next(); + return value + '='; + } + + return value; + } + + if (this.isDelim(EQUALSIGN)) { + return '='; + } + + this.error(`Expected ${expectColon ? '":", ' : ''}"<", ">", "=" or ")"`); +} + +function parse(kind = 'unknown') { + const start = this.tokenStart; + + this.skipSC(); + this.eat(types.LeftParenthesis); + + const left = readTerm.call(this); + const leftComparison = readComparison.call(this, left.type === 'Identifier'); + const middle = readTerm.call(this); + let rightComparison = null; + let right = null; + + if (this.lookupNonWSType(0) !== types.RightParenthesis) { + rightComparison = readComparison.call(this); + right = readTerm.call(this); + } + + this.skipSC(); + this.eat(types.RightParenthesis); + + return { + type: 'FeatureRange', + loc: this.getLocation(start, this.tokenStart), + kind, + left, + leftComparison, + middle, + rightComparison, + right + }; +} + +function generate(node) { + this.token(types.LeftParenthesis, '('); + this.node(node.left); + this.tokenize(node.leftComparison); + this.node(node.middle); + + if (node.right) { + this.tokenize(node.rightComparison); + this.node(node.right); + } + + this.token(types.RightParenthesis, ')'); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Function.cjs b/node_modules/css-tree/cjs/syntax/node/Function.cjs new file mode 100644 index 00000000..b5e3b57e --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Function.cjs @@ -0,0 +1,45 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'Function'; +const walkContext = 'function'; +const structure = { + name: String, + children: [[]] +}; + +// <function-token> <sequence> ) +function parse(readSequence, recognizer) { + const start = this.tokenStart; + const name = this.consumeFunctionName(); + const nameLowerCase = name.toLowerCase(); + let children; + + children = recognizer.hasOwnProperty(nameLowerCase) + ? recognizer[nameLowerCase].call(this, recognizer) + : readSequence.call(this, recognizer); + + if (!this.eof) { + this.eat(types.RightParenthesis); + } + + return { + type: 'Function', + loc: this.getLocation(start, this.tokenStart), + name, + children + }; +} + +function generate(node) { + this.token(types.Function, node.name + '('); + this.children(node); + this.token(types.RightParenthesis, ')'); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; +exports.walkContext = walkContext; diff --git a/node_modules/css-tree/cjs/syntax/node/GeneralEnclosed.cjs b/node_modules/css-tree/cjs/syntax/node/GeneralEnclosed.cjs new file mode 100644 index 00000000..5e919c8e --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/GeneralEnclosed.cjs @@ -0,0 +1,51 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'GeneralEnclosed'; +const structure = { + function: [String, null], + children: [[]] +}; + +// <function-token> <any-value> ) +// ( <any-value> ) +function parse() { + const start = this.tokenStart; + let functionName = null; + + if (this.tokenType === types.Function) { + functionName = this.consumeFunctionName(); + } else { + this.eat(types.LeftParenthesis); + } + + const children = this.readSequence(this.scope.Value); + + if (!this.eof) { + this.eat(types.RightParenthesis); + } + + return { + type: 'GeneralEnclosed', + loc: this.getLocation(start, this.tokenStart), + function: functionName, + children + }; +} + +function generate(node) { + if (node.function) { + this.token(types.Function, node.function + '('); + } else { + this.token(types.LeftParenthesis, '('); + } + + this.children(node); + this.token(types.RightParenthesis, ')'); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Hash.cjs b/node_modules/css-tree/cjs/syntax/node/Hash.cjs new file mode 100644 index 00000000..8b5f3753 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Hash.cjs @@ -0,0 +1,30 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +// '#' ident +const xxx = 'XXX'; +const name = 'Hash'; +const structure = { + value: String +}; +function parse() { + const start = this.tokenStart; + + this.eat(types.Hash); + + return { + type: 'Hash', + loc: this.getLocation(start, this.tokenStart), + value: this.substrToCursor(start + 1) + }; +} +function generate(node) { + this.token(types.Hash, '#' + node.value); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; +exports.xxx = xxx; diff --git a/node_modules/css-tree/cjs/syntax/node/IdSelector.cjs b/node_modules/css-tree/cjs/syntax/node/IdSelector.cjs new file mode 100644 index 00000000..264525db --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/IdSelector.cjs @@ -0,0 +1,33 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'IdSelector'; +const structure = { + name: String +}; + +function parse() { + const start = this.tokenStart; + + // TODO: check value is an ident + this.eat(types.Hash); + + return { + type: 'IdSelector', + loc: this.getLocation(start, this.tokenStart), + name: this.substrToCursor(start + 1) + }; +} + +function generate(node) { + // Using Delim instead of Hash is a hack to avoid for a whitespace between ident and id-selector + // in safe mode (e.g. "a#id"), because IE11 doesn't allow a sequence <ident-token> <hash-token> + // without a whitespace in values (e.g. "1px solid#000") + this.token(types.Delim, '#' + node.name); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Identifier.cjs b/node_modules/css-tree/cjs/syntax/node/Identifier.cjs new file mode 100644 index 00000000..8928cf8c --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Identifier.cjs @@ -0,0 +1,25 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'Identifier'; +const structure = { + name: String +}; + +function parse() { + return { + type: 'Identifier', + loc: this.getLocation(this.tokenStart, this.tokenEnd), + name: this.consume(types.Ident) + }; +} + +function generate(node) { + this.token(types.Ident, node.name); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/MediaCondition.cjs b/node_modules/css-tree/cjs/syntax/node/MediaCondition.cjs new file mode 100644 index 00000000..c98fdc8f --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/MediaCondition.cjs @@ -0,0 +1,70 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const MediaFeatureToken = new Set([types.Colon, types.RightParenthesis, types.EOF]); + +const name = 'MediaCondition'; +const structure = { + children: [[ + 'Identifier', + 'MediaFeature', + 'MediaFeatureRange' + ]] +}; + +function parse() { + const children = this.createList(); + + scan: while (!this.eof) { + switch (this.tokenType) { + case types.Comment: + case types.WhiteSpace: + this.next(); + continue; + + case types.Ident: + children.push(this.Identifier()); + break; + + case types.LeftParenthesis: + if (this.lookupTypeNonSC(1) === types.Ident && MediaFeatureToken.has(this.lookupTypeNonSC(2))) { + children.push(this.MediaFeature()); + } else if (this.lookupTypeNonSC(1) === types.LeftParenthesis || this.lookupTypeNonSC(2) === types.LeftParenthesis) { + this.next(); + children.push(this.MediaCondition()); + this.eat(types.RightParenthesis); + } else { + children.push(this.MediaFeatureRange()); + } + + break; + + default: + break scan; + } + } + + return { + type: 'MediaCondition', + loc: this.getLocationFromList(children), + children + }; +} + +function generate(node) { + node.children.forEach(child => { + if (child.type === 'MediaCondition') { + this.token(types.LeftParenthesis, '('); + this.node(child); + this.token(types.RightParenthesis, ')'); + } else { + this.node(child); + } + }); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/MediaFeature.cjs b/node_modules/css-tree/cjs/syntax/node/MediaFeature.cjs new file mode 100644 index 00000000..90e8d5a8 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/MediaFeature.cjs @@ -0,0 +1,76 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'MediaFeature'; +const structure = { + name: String, + value: ['Identifier', 'Number', 'Dimension', 'Ratio', null] +}; + +function parse() { + const start = this.tokenStart; + let name; + let value = null; + + this.eat(types.LeftParenthesis); + this.skipSC(); + + name = this.consume(types.Ident); + this.skipSC(); + + if (this.tokenType !== types.RightParenthesis) { + this.eat(types.Colon); + this.skipSC(); + + switch (this.tokenType) { + case types.Number: + if (this.lookupNonWSType(1) === types.Delim) { + value = this.Ratio(); + } else { + value = this.Number(); + } + + break; + + case types.Dimension: + value = this.Dimension(); + break; + + case types.Ident: + value = this.Identifier(); + break; + + default: + this.error('Number, dimension, ratio or identifier is expected'); + } + + this.skipSC(); + } + + this.eat(types.RightParenthesis); + + return { + type: 'MediaFeature', + loc: this.getLocation(start, this.tokenStart), + name, + value + }; +} + +function generate(node) { + this.token(types.LeftParenthesis, '('); + this.token(types.Ident, node.name); + + if (node.value !== null) { + this.token(types.Colon, ':'); + this.node(node.value); + } + + this.token(types.RightParenthesis, ')'); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/MediaFeatureRange.cjs b/node_modules/css-tree/cjs/syntax/node/MediaFeatureRange.cjs new file mode 100644 index 00000000..8be899f4 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/MediaFeatureRange.cjs @@ -0,0 +1,11 @@ +'use strict'; + +const featureRange = require('./common/feature-range.cjs'); + +const name = 'MediaFeatureRange'; +const parse = featureRange.createParse(name); + +exports.generate = featureRange.generate; +exports.structure = featureRange.structure; +exports.name = name; +exports.parse = parse; diff --git a/node_modules/css-tree/cjs/syntax/node/MediaQuery.cjs b/node_modules/css-tree/cjs/syntax/node/MediaQuery.cjs new file mode 100644 index 00000000..0b99d960 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/MediaQuery.cjs @@ -0,0 +1,61 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'MediaQuery'; +const structure = { + children: [[ + 'Identifier', + 'MediaFeature', + 'WhiteSpace' + ]] +}; + +function parse() { + const children = this.createList(); + let child = null; + + this.skipSC(); + + scan: + while (!this.eof) { + switch (this.tokenType) { + case types.Comment: + case types.WhiteSpace: + this.next(); + continue; + + case types.Ident: + child = this.Identifier(); + break; + + case types.LeftParenthesis: + child = this.MediaFeature(); + break; + + default: + break scan; + } + + children.push(child); + } + + if (child === null) { + this.error('Identifier or parenthesis is expected'); + } + + return { + type: 'MediaQuery', + loc: this.getLocationFromList(children), + children + }; +} + +function generate(node) { + this.children(node); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/MediaQueryList.cjs b/node_modules/css-tree/cjs/syntax/node/MediaQueryList.cjs new file mode 100644 index 00000000..38779477 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/MediaQueryList.cjs @@ -0,0 +1,41 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'MediaQueryList'; +const structure = { + children: [[ + 'MediaQuery' + ]] +}; + +function parse() { + const children = this.createList(); + + this.skipSC(); + + while (!this.eof) { + children.push(this.MediaQuery()); + + if (this.tokenType !== types.Comma) { + break; + } + + this.next(); + } + + return { + type: 'MediaQueryList', + loc: this.getLocationFromList(children), + children + }; +} + +function generate(node) { + this.children(node, () => this.token(types.Comma, ',')); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/NestingSelector.cjs b/node_modules/css-tree/cjs/syntax/node/NestingSelector.cjs new file mode 100644 index 00000000..9850a9c1 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/NestingSelector.cjs @@ -0,0 +1,29 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const AMPERSAND = 0x0026; // U+0026 AMPERSAND (&) + +const name = 'NestingSelector'; +const structure = { +}; + +function parse() { + const start = this.tokenStart; + + this.eatDelim(AMPERSAND); + + return { + type: 'NestingSelector', + loc: this.getLocation(start, this.tokenStart) + }; +} + +function generate() { + this.token(types.Delim, '&'); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Nth.cjs b/node_modules/css-tree/cjs/syntax/node/Nth.cjs new file mode 100644 index 00000000..709312f4 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Nth.cjs @@ -0,0 +1,54 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'Nth'; +const structure = { + nth: ['AnPlusB', 'Identifier'], + selector: ['SelectorList', null] +}; + +function parse() { + this.skipSC(); + + const start = this.tokenStart; + let end = start; + let selector = null; + let nth; + + if (this.lookupValue(0, 'odd') || this.lookupValue(0, 'even')) { + nth = this.Identifier(); + } else { + nth = this.AnPlusB(); + } + + end = this.tokenStart; + this.skipSC(); + + if (this.lookupValue(0, 'of')) { + this.next(); + + selector = this.SelectorList(); + end = this.tokenStart; + } + + return { + type: 'Nth', + loc: this.getLocation(start, end), + nth, + selector + }; +} + +function generate(node) { + this.node(node.nth); + if (node.selector !== null) { + this.token(types.Ident, 'of'); + this.node(node.selector); + } +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Number.cjs b/node_modules/css-tree/cjs/syntax/node/Number.cjs new file mode 100644 index 00000000..8abd9ae9 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Number.cjs @@ -0,0 +1,25 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'Number'; +const structure = { + value: String +}; + +function parse() { + return { + type: 'Number', + loc: this.getLocation(this.tokenStart, this.tokenEnd), + value: this.consume(types.Number) + }; +} + +function generate(node) { + this.token(types.Number, node.value); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Operator.cjs b/node_modules/css-tree/cjs/syntax/node/Operator.cjs new file mode 100644 index 00000000..c5a513bf --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Operator.cjs @@ -0,0 +1,28 @@ +'use strict'; + +// '/' | '*' | ',' | ':' | '+' | '-' +const name = 'Operator'; +const structure = { + value: String +}; + +function parse() { + const start = this.tokenStart; + + this.next(); + + return { + type: 'Operator', + loc: this.getLocation(start, this.tokenStart), + value: this.substrToCursor(start) + }; +} + +function generate(node) { + this.tokenize(node.value); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Parentheses.cjs b/node_modules/css-tree/cjs/syntax/node/Parentheses.cjs new file mode 100644 index 00000000..7c14bc67 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Parentheses.cjs @@ -0,0 +1,38 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'Parentheses'; +const structure = { + children: [[]] +}; + +function parse(readSequence, recognizer) { + const start = this.tokenStart; + let children = null; + + this.eat(types.LeftParenthesis); + + children = readSequence.call(this, recognizer); + + if (!this.eof) { + this.eat(types.RightParenthesis); + } + + return { + type: 'Parentheses', + loc: this.getLocation(start, this.tokenStart), + children + }; +} + +function generate(node) { + this.token(types.LeftParenthesis, '('); + this.children(node); + this.token(types.RightParenthesis, ')'); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Percentage.cjs b/node_modules/css-tree/cjs/syntax/node/Percentage.cjs new file mode 100644 index 00000000..38cc1d5e --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Percentage.cjs @@ -0,0 +1,25 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'Percentage'; +const structure = { + value: String +}; + +function parse() { + return { + type: 'Percentage', + loc: this.getLocation(this.tokenStart, this.tokenEnd), + value: this.consumeNumber(types.Percentage) + }; +} + +function generate(node) { + this.token(types.Percentage, node.value + '%'); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/PseudoClassSelector.cjs b/node_modules/css-tree/cjs/syntax/node/PseudoClassSelector.cjs new file mode 100644 index 00000000..ad58371e --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/PseudoClassSelector.cjs @@ -0,0 +1,65 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'PseudoClassSelector'; +const walkContext = 'function'; +const structure = { + name: String, + children: [['Raw'], null] +}; + +// : [ <ident> | <function-token> <any-value>? ) ] +function parse() { + const start = this.tokenStart; + let children = null; + let name; + let nameLowerCase; + + this.eat(types.Colon); + + if (this.tokenType === types.Function) { + name = this.consumeFunctionName(); + nameLowerCase = name.toLowerCase(); + + if (hasOwnProperty.call(this.pseudo, nameLowerCase)) { + this.skipSC(); + children = this.pseudo[nameLowerCase].call(this); + this.skipSC(); + } else { + children = this.createList(); + children.push( + this.Raw(this.tokenIndex, null, false) + ); + } + + this.eat(types.RightParenthesis); + } else { + name = this.consume(types.Ident); + } + + return { + type: 'PseudoClassSelector', + loc: this.getLocation(start, this.tokenStart), + name, + children + }; +} + +function generate(node) { + this.token(types.Colon, ':'); + + if (node.children === null) { + this.token(types.Ident, node.name); + } else { + this.token(types.Function, node.name + '('); + this.children(node); + this.token(types.RightParenthesis, ')'); + } +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; +exports.walkContext = walkContext; diff --git a/node_modules/css-tree/cjs/syntax/node/PseudoElementSelector.cjs b/node_modules/css-tree/cjs/syntax/node/PseudoElementSelector.cjs new file mode 100644 index 00000000..a3c1f12f --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/PseudoElementSelector.cjs @@ -0,0 +1,67 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'PseudoElementSelector'; +const walkContext = 'function'; +const structure = { + name: String, + children: [['Raw'], null] +}; + +// :: [ <ident> | <function-token> <any-value>? ) ] +function parse() { + const start = this.tokenStart; + let children = null; + let name; + let nameLowerCase; + + this.eat(types.Colon); + this.eat(types.Colon); + + if (this.tokenType === types.Function) { + name = this.consumeFunctionName(); + nameLowerCase = name.toLowerCase(); + + if (hasOwnProperty.call(this.pseudo, nameLowerCase)) { + this.skipSC(); + children = this.pseudo[nameLowerCase].call(this); + this.skipSC(); + } else { + children = this.createList(); + children.push( + this.Raw(this.tokenIndex, null, false) + ); + } + + this.eat(types.RightParenthesis); + } else { + name = this.consume(types.Ident); + } + + return { + type: 'PseudoElementSelector', + loc: this.getLocation(start, this.tokenStart), + name, + children + }; +} + +function generate(node) { + this.token(types.Colon, ':'); + this.token(types.Colon, ':'); + + if (node.children === null) { + this.token(types.Ident, node.name); + } else { + this.token(types.Function, node.name + '('); + this.children(node); + this.token(types.RightParenthesis, ')'); + } +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; +exports.walkContext = walkContext; diff --git a/node_modules/css-tree/cjs/syntax/node/Ratio.cjs b/node_modules/css-tree/cjs/syntax/node/Ratio.cjs new file mode 100644 index 00000000..8bdf2dcc --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Ratio.cjs @@ -0,0 +1,67 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); +const charCodeDefinitions = require('../../tokenizer/char-code-definitions.cjs'); + +const SOLIDUS = 0x002F; // U+002F SOLIDUS (/) +const FULLSTOP = 0x002E; // U+002E FULL STOP (.) + +// Terms of <ratio> should be a positive numbers (not zero or negative) +// (see https://drafts.csswg.org/mediaqueries-3/#values) +// However, -o-min-device-pixel-ratio takes fractional values as a ratio's term +// and this is using by various sites. Therefore we relax checking on parse +// to test a term is unsigned number without an exponent part. +// Additional checking may be applied on lexer validation. +function consumeNumber() { + this.skipSC(); + + const value = this.consume(types.Number); + + for (let i = 0; i < value.length; i++) { + const code = value.charCodeAt(i); + if (!charCodeDefinitions.isDigit(code) && code !== FULLSTOP) { + this.error('Unsigned number is expected', this.tokenStart - value.length + i); + } + } + + if (Number(value) === 0) { + this.error('Zero number is not allowed', this.tokenStart - value.length); + } + + return value; +} + +const name = 'Ratio'; +const structure = { + left: String, + right: String +}; + +// <positive-integer> S* '/' S* <positive-integer> +function parse() { + const start = this.tokenStart; + const left = consumeNumber.call(this); + let right; + + this.skipSC(); + this.eatDelim(SOLIDUS); + right = consumeNumber.call(this); + + return { + type: 'Ratio', + loc: this.getLocation(start, this.tokenStart), + left, + right + }; +} + +function generate(node) { + this.token(types.Number, node.left); + this.token(types.Delim, '/'); + this.token(types.Number, node.right); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Raw.cjs b/node_modules/css-tree/cjs/syntax/node/Raw.cjs new file mode 100644 index 00000000..505b5266 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Raw.cjs @@ -0,0 +1,48 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +function getOffsetExcludeWS() { + if (this.tokenIndex > 0) { + if (this.lookupType(-1) === types.WhiteSpace) { + return this.tokenIndex > 1 + ? this.getTokenStart(this.tokenIndex - 1) + : this.firstCharOffset; + } + } + + return this.tokenStart; +} + +const name = 'Raw'; +const structure = { + value: String +}; + +function parse(startToken, consumeUntil, excludeWhiteSpace) { + const startOffset = this.getTokenStart(startToken); + let endOffset; + + this.skipUntilBalanced(startToken, consumeUntil || this.consumeUntilBalanceEnd); + + if (excludeWhiteSpace && this.tokenStart > startOffset) { + endOffset = getOffsetExcludeWS.call(this); + } else { + endOffset = this.tokenStart; + } + + return { + type: 'Raw', + loc: this.getLocation(startOffset, endOffset), + value: this.substring(startOffset, endOffset) + }; +} + +function generate(node) { + this.tokenize(node.value); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Rule.cjs b/node_modules/css-tree/cjs/syntax/node/Rule.cjs new file mode 100644 index 00000000..a76ce712 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Rule.cjs @@ -0,0 +1,58 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +function consumeRaw(startToken) { + return this.Raw(startToken, this.consumeUntilLeftCurlyBracket, true); +} + +function consumePrelude() { + const prelude = this.SelectorList(); + + if (prelude.type !== 'Raw' && + this.eof === false && + this.tokenType !== types.LeftCurlyBracket) { + this.error(); + } + + return prelude; +} + +const name = 'Rule'; +const walkContext = 'rule'; +const structure = { + prelude: ['SelectorList', 'Raw'], + block: ['Block'] +}; + +function parse() { + const startToken = this.tokenIndex; + const startOffset = this.tokenStart; + let prelude; + let 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.tokenStart), + prelude, + block + }; +} +function generate(node) { + this.node(node.prelude); + this.node(node.block); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; +exports.walkContext = walkContext; diff --git a/node_modules/css-tree/cjs/syntax/node/Selector.cjs b/node_modules/css-tree/cjs/syntax/node/Selector.cjs new file mode 100644 index 00000000..c6cafd1e --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Selector.cjs @@ -0,0 +1,39 @@ +'use strict'; + +const name = 'Selector'; +const structure = { + children: [[ + 'TypeSelector', + 'IdSelector', + 'ClassSelector', + 'AttributeSelector', + 'PseudoClassSelector', + 'PseudoElementSelector', + 'Combinator', + 'WhiteSpace' + ]] +}; + +function parse() { + const 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 + }; +} + +function generate(node) { + this.children(node); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/SelectorList.cjs b/node_modules/css-tree/cjs/syntax/node/SelectorList.cjs new file mode 100644 index 00000000..7ecf09b2 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/SelectorList.cjs @@ -0,0 +1,43 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const name = 'SelectorList'; +const walkContext = 'selector'; +const structure = { + children: [[ + 'Selector', + 'Raw' + ]] +}; + +function parse() { + const children = this.createList(); + + while (!this.eof) { + children.push(this.Selector()); + + if (this.tokenType === types.Comma) { + this.next(); + continue; + } + + break; + } + + return { + type: 'SelectorList', + loc: this.getLocationFromList(children), + children + }; +} + +function generate(node) { + this.children(node, () => this.token(types.Comma, ',')); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; +exports.walkContext = walkContext; diff --git a/node_modules/css-tree/cjs/syntax/node/String.cjs b/node_modules/css-tree/cjs/syntax/node/String.cjs new file mode 100644 index 00000000..8a7801e5 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/String.cjs @@ -0,0 +1,26 @@ +'use strict'; + +const string = require('../../utils/string.cjs'); +const types = require('../../tokenizer/types.cjs'); + +const name = 'String'; +const structure = { + value: String +}; + +function parse() { + return { + type: 'String', + loc: this.getLocation(this.tokenStart, this.tokenEnd), + value: string.decode(this.consume(types.String)) + }; +} + +function generate(node) { + this.token(types.String, string.encode(node.value)); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/StyleSheet.cjs b/node_modules/css-tree/cjs/syntax/node/StyleSheet.cjs new file mode 100644 index 00000000..60276185 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/StyleSheet.cjs @@ -0,0 +1,83 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const EXCLAMATIONMARK = 0x0021; // U+0021 EXCLAMATION MARK (!) + +function consumeRaw(startToken) { + return this.Raw(startToken, null, false); +} + +const name = 'StyleSheet'; +const walkContext = 'stylesheet'; +const structure = { + children: [[ + 'Comment', + 'CDO', + 'CDC', + 'Atrule', + 'Rule', + 'Raw' + ]] +}; + +function parse() { + const start = this.tokenStart; + const children = this.createList(); + let child; + + while (!this.eof) { + switch (this.tokenType) { + case types.WhiteSpace: + this.next(); + continue; + + case types.Comment: + // ignore comments except exclamation comments (i.e. /*! .. */) on top level + if (this.charCodeAt(this.tokenStart + 2) !== EXCLAMATIONMARK) { + this.next(); + continue; + } + + child = this.Comment(); + break; + + case types.CDO: // <!-- + child = this.CDO(); + break; + + case types.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 types.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.tokenStart), + children + }; +} + +function generate(node) { + this.children(node); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; +exports.walkContext = walkContext; diff --git a/node_modules/css-tree/cjs/syntax/node/TypeSelector.cjs b/node_modules/css-tree/cjs/syntax/node/TypeSelector.cjs new file mode 100644 index 00000000..1d152703 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/TypeSelector.cjs @@ -0,0 +1,59 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const ASTERISK = 0x002A; // U+002A ASTERISK (*) +const VERTICALLINE = 0x007C; // U+007C VERTICAL LINE (|) + +function eatIdentifierOrAsterisk() { + if (this.tokenType !== types.Ident && + this.isDelim(ASTERISK) === false) { + this.error('Identifier or asterisk is expected'); + } + + this.next(); +} + +const name = 'TypeSelector'; +const structure = { + name: String +}; + +// ident +// ident|ident +// ident|* +// * +// *|ident +// *|* +// |ident +// |* +function parse() { + const start = this.tokenStart; + + if (this.isDelim(VERTICALLINE)) { + this.next(); + eatIdentifierOrAsterisk.call(this); + } else { + eatIdentifierOrAsterisk.call(this); + + if (this.isDelim(VERTICALLINE)) { + this.next(); + eatIdentifierOrAsterisk.call(this); + } + } + + return { + type: 'TypeSelector', + loc: this.getLocation(start, this.tokenStart), + name: this.substrToCursor(start) + }; +} + +function generate(node) { + this.tokenize(node.name); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/UnicodeRange.cjs b/node_modules/css-tree/cjs/syntax/node/UnicodeRange.cjs new file mode 100644 index 00000000..5585e8fd --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/UnicodeRange.cjs @@ -0,0 +1,158 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); +const charCodeDefinitions = require('../../tokenizer/char-code-definitions.cjs'); + +const PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+) +const HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-) +const QUESTIONMARK = 0x003F; // U+003F QUESTION MARK (?) + +function eatHexSequence(offset, allowDash) { + let len = 0; + + for (let pos = this.tokenStart + offset; pos < this.tokenEnd; pos++) { + const code = this.charCodeAt(pos); + + if (code === HYPHENMINUS && allowDash && len !== 0) { + eatHexSequence.call(this, offset + len + 1, false); + return -1; + } + + if (!charCodeDefinitions.isHexDigit(code)) { + this.error( + allowDash && len !== 0 + ? 'Hyphen minus' + (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.next(); + return len; +} + +function eatQuestionMarkSequence(max) { + let count = 0; + + while (this.isDelim(QUESTIONMARK)) { + if (++count > max) { + this.error('Too many question marks'); + } + + this.next(); + } +} + +function startsWith(code) { + if (this.charCodeAt(this.tokenStart) !== code) { + this.error((code === PLUSSIGN ? 'Plus sign' : 'Hyphen minus') + ' 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() { + let hexLength = 0; + + switch (this.tokenType) { + case types.Number: + // u <number-token> '?'* + // u <number-token> <dimension-token> + // u <number-token> <number-token> + hexLength = eatHexSequence.call(this, 1, true); + + if (this.isDelim(QUESTIONMARK)) { + eatQuestionMarkSequence.call(this, 6 - hexLength); + break; + } + + if (this.tokenType === types.Dimension || + this.tokenType === types.Number) { + startsWith.call(this, HYPHENMINUS); + eatHexSequence.call(this, 1, false); + break; + } + + break; + + case types.Dimension: + // u <dimension-token> '?'* + hexLength = eatHexSequence.call(this, 1, true); + + if (hexLength > 0) { + eatQuestionMarkSequence.call(this, 6 - hexLength); + } + + break; + + default: + // u '+' <ident-token> '?'* + // u '+' '?'+ + this.eatDelim(PLUSSIGN); + + if (this.tokenType === types.Ident) { + hexLength = eatHexSequence.call(this, 0, true); + if (hexLength > 0) { + eatQuestionMarkSequence.call(this, 6 - hexLength); + } + break; + } + + if (this.isDelim(QUESTIONMARK)) { + this.next(); + eatQuestionMarkSequence.call(this, 5); + break; + } + + this.error('Hex digit or question mark is expected'); + } +} + +const name = 'UnicodeRange'; +const structure = { + value: String +}; + +function parse() { + const start = this.tokenStart; + + // U or u + this.eatIdent('u'); + scanUnicodeRange.call(this); + + return { + type: 'UnicodeRange', + loc: this.getLocation(start, this.tokenStart), + value: this.substrToCursor(start) + }; +} + +function generate(node) { + this.tokenize(node.value); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Url.cjs b/node_modules/css-tree/cjs/syntax/node/Url.cjs new file mode 100644 index 00000000..6a394577 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Url.cjs @@ -0,0 +1,54 @@ +'use strict'; + +const url = require('../../utils/url.cjs'); +const string = require('../../utils/string.cjs'); +const types = require('../../tokenizer/types.cjs'); + +const name = 'Url'; +const structure = { + value: String +}; + +// <url-token> | <function-token> <string> ) +function parse() { + const start = this.tokenStart; + let value; + + switch (this.tokenType) { + case types.Url: + value = url.decode(this.consume(types.Url)); + break; + + case types.Function: + if (!this.cmpStr(this.tokenStart, this.tokenEnd, 'url(')) { + this.error('Function name must be `url`'); + } + + this.eat(types.Function); + this.skipSC(); + value = string.decode(this.consume(types.String)); + this.skipSC(); + if (!this.eof) { + this.eat(types.RightParenthesis); + } + break; + + default: + this.error('Url or Function is expected'); + } + + return { + type: 'Url', + loc: this.getLocation(start, this.tokenStart), + value + }; +} + +function generate(node) { + this.token(types.Url, url.encode(node.value)); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/Value.cjs b/node_modules/css-tree/cjs/syntax/node/Value.cjs new file mode 100644 index 00000000..bdb322e7 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/Value.cjs @@ -0,0 +1,26 @@ +'use strict'; + +const name = 'Value'; +const structure = { + children: [[]] +}; + +function parse() { + const start = this.tokenStart; + const children = this.readSequence(this.scope.Value); + + return { + type: 'Value', + loc: this.getLocation(start, this.tokenStart), + children + }; +} + +function generate(node) { + this.children(node); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/WhiteSpace.cjs b/node_modules/css-tree/cjs/syntax/node/WhiteSpace.cjs new file mode 100644 index 00000000..50c19826 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/WhiteSpace.cjs @@ -0,0 +1,34 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const SPACE = Object.freeze({ + type: 'WhiteSpace', + loc: null, + value: ' ' +}); + +const name = 'WhiteSpace'; +const structure = { + value: String +}; + +function parse() { + this.eat(types.WhiteSpace); + return SPACE; + + // return { + // type: 'WhiteSpace', + // loc: this.getLocation(this.tokenStart, this.tokenEnd), + // value: this.consume(WHITESPACE) + // }; +} + +function generate(node) { + this.token(types.WhiteSpace, node.value); +} + +exports.generate = generate; +exports.name = name; +exports.parse = parse; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/common/feature-range.cjs b/node_modules/css-tree/cjs/syntax/node/common/feature-range.cjs new file mode 100644 index 00000000..7589b563 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/common/feature-range.cjs @@ -0,0 +1,112 @@ +'use strict'; + +const types = require('../../../tokenizer/types.cjs'); + +const LESSTHANSIGN = 60; // < +const EQUALSIGN = 61; // = +const GREATERTHANSIGN = 62; // > + +const structure = { + left: ['Identifier', 'Number', 'Dimension', 'Ratio'], + leftComparison: String, + middle: ['Identifier', 'Number', 'Dimension', 'Ratio'], + rightComparison: [String, null], + right: ['Identifier', 'Number', 'Dimension', 'Ratio', null] +}; + +function readTerm() { + this.skipSC(); + + switch (this.tokenType) { + case types.Number: + if (this.lookupNonWSType(1) === types.Delim) { + return this.Ratio(); + } else { + return this.Number(); + } + + case types.Dimension: + return this.Dimension(); + + case types.Ident: + return this.Identifier(); + + default: + this.error('Number, dimension, ratio or identifier is expected'); + } +} + +function readComparison(expectColon) { + this.skipSC(); + + if (this.isDelim(LESSTHANSIGN) || + this.isDelim(GREATERTHANSIGN)) { + const value = this.source[this.tokenStart]; + + this.next(); + + if (this.isDelim(EQUALSIGN)) { + this.next(); + return value + '='; + } + + return value; + } + + if (this.isDelim(EQUALSIGN)) { + return '='; + } + + this.error(`Expected ${expectColon ? '":", ' : ''}"<", ">", "=" or ")"`); +} + +function createParse(type) { + return function parse() { + const start = this.tokenStart; + + this.skipSC(); + this.eat(types.LeftParenthesis); + + const left = readTerm.call(this); + const leftComparison = readComparison.call(this, left.type === 'Identifier'); + const middle = readTerm.call(this); + let rightComparison = null; + let right = null; + + if (this.lookupNonWSType(0) !== types.RightParenthesis) { + rightComparison = readComparison.call(this); + right = readTerm.call(this); + } + + this.skipSC(); + this.eat(types.RightParenthesis); + + return { + type, + loc: this.getLocation(start, this.tokenStart), + left, + leftComparison, + middle, + rightComparison, + right + }; + }; +} + +function generate(node) { + this.token(types.LeftParenthesis, '('); + this.node(node.left); + this.tokenize(node.leftComparison); + this.node(node.middle); + + if (node.right) { + this.tokenize(node.rightComparison); + this.node(node.right); + } + + this.token(types.RightParenthesis, ')'); +} + +exports.createParse = createParse; +exports.generate = generate; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/common/feature.cjs b/node_modules/css-tree/cjs/syntax/node/common/feature.cjs new file mode 100644 index 00000000..fa5de4ed --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/common/feature.cjs @@ -0,0 +1,76 @@ +'use strict'; + +const types = require('../../../tokenizer/types.cjs'); + +const structure = { + name: String, + value: ['Identifier', 'Number', 'Dimension', 'Ratio', null] +}; + +function createParse(type) { + return function parse() { + const start = this.tokenStart; + let name; + let value = null; + + this.eat(types.LeftParenthesis); + this.skipSC(); + + name = this.consume(types.Ident); + this.skipSC(); + + if (this.tokenType !== types.RightParenthesis) { + this.eat(types.Colon); + this.skipSC(); + + switch (this.tokenType) { + case types.Number: + if (this.lookupNonWSType(1) === types.Delim) { + value = this.Ratio(); + } else { + value = this.Number(); + } + + break; + + case types.Dimension: + value = this.Dimension(); + break; + + case types.Ident: + value = this.Identifier(); + break; + + default: + this.error('Number, dimension, ratio or identifier is expected'); + } + + this.skipSC(); + } + + this.eat(types.RightParenthesis); + + return { + type, + loc: this.getLocation(start, this.tokenStart), + name, + value + }; + }; +} + +function generate(node) { + this.token(types.LeftParenthesis, '('); + this.token(types.Ident, node.name); + + if (node.value !== null) { + this.token(types.Colon, ':'); + this.node(node.value); + } + + this.token(types.RightParenthesis, ')'); +} + +exports.createParse = createParse; +exports.generate = generate; +exports.structure = structure; diff --git a/node_modules/css-tree/cjs/syntax/node/index-generate.cjs b/node_modules/css-tree/cjs/syntax/node/index-generate.cjs new file mode 100644 index 00000000..4af11ccb --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/index-generate.cjs @@ -0,0 +1,87 @@ +'use strict'; + +const AnPlusB = require('./AnPlusB.cjs'); +const Atrule = require('./Atrule.cjs'); +const AtrulePrelude = require('./AtrulePrelude.cjs'); +const AttributeSelector = require('./AttributeSelector.cjs'); +const Block = require('./Block.cjs'); +const Brackets = require('./Brackets.cjs'); +const CDC = require('./CDC.cjs'); +const CDO = require('./CDO.cjs'); +const ClassSelector = require('./ClassSelector.cjs'); +const Combinator = require('./Combinator.cjs'); +const Comment = require('./Comment.cjs'); +const Declaration = require('./Declaration.cjs'); +const DeclarationList = require('./DeclarationList.cjs'); +const Dimension = require('./Dimension.cjs'); +const Function = require('./Function.cjs'); +const Hash = require('./Hash.cjs'); +const Identifier = require('./Identifier.cjs'); +const IdSelector = require('./IdSelector.cjs'); +const MediaFeature = require('./MediaFeature.cjs'); +const MediaQuery = require('./MediaQuery.cjs'); +const MediaQueryList = require('./MediaQueryList.cjs'); +const NestingSelector = require('./NestingSelector.cjs'); +const Nth = require('./Nth.cjs'); +const Number = require('./Number.cjs'); +const Operator = require('./Operator.cjs'); +const Parentheses = require('./Parentheses.cjs'); +const Percentage = require('./Percentage.cjs'); +const PseudoClassSelector = require('./PseudoClassSelector.cjs'); +const PseudoElementSelector = require('./PseudoElementSelector.cjs'); +const Ratio = require('./Ratio.cjs'); +const Raw = require('./Raw.cjs'); +const Rule = require('./Rule.cjs'); +const Selector = require('./Selector.cjs'); +const SelectorList = require('./SelectorList.cjs'); +const String = require('./String.cjs'); +const StyleSheet = require('./StyleSheet.cjs'); +const TypeSelector = require('./TypeSelector.cjs'); +const UnicodeRange = require('./UnicodeRange.cjs'); +const Url = require('./Url.cjs'); +const Value = require('./Value.cjs'); +const WhiteSpace = require('./WhiteSpace.cjs'); + + + +exports.AnPlusB = AnPlusB.generate; +exports.Atrule = Atrule.generate; +exports.AtrulePrelude = AtrulePrelude.generate; +exports.AttributeSelector = AttributeSelector.generate; +exports.Block = Block.generate; +exports.Brackets = Brackets.generate; +exports.CDC = CDC.generate; +exports.CDO = CDO.generate; +exports.ClassSelector = ClassSelector.generate; +exports.Combinator = Combinator.generate; +exports.Comment = Comment.generate; +exports.Declaration = Declaration.generate; +exports.DeclarationList = DeclarationList.generate; +exports.Dimension = Dimension.generate; +exports.Function = Function.generate; +exports.Hash = Hash.generate; +exports.Identifier = Identifier.generate; +exports.IdSelector = IdSelector.generate; +exports.MediaFeature = MediaFeature.generate; +exports.MediaQuery = MediaQuery.generate; +exports.MediaQueryList = MediaQueryList.generate; +exports.NestingSelector = NestingSelector.generate; +exports.Nth = Nth.generate; +exports.Number = Number.generate; +exports.Operator = Operator.generate; +exports.Parentheses = Parentheses.generate; +exports.Percentage = Percentage.generate; +exports.PseudoClassSelector = PseudoClassSelector.generate; +exports.PseudoElementSelector = PseudoElementSelector.generate; +exports.Ratio = Ratio.generate; +exports.Raw = Raw.generate; +exports.Rule = Rule.generate; +exports.Selector = Selector.generate; +exports.SelectorList = SelectorList.generate; +exports.String = String.generate; +exports.StyleSheet = StyleSheet.generate; +exports.TypeSelector = TypeSelector.generate; +exports.UnicodeRange = UnicodeRange.generate; +exports.Url = Url.generate; +exports.Value = Value.generate; +exports.WhiteSpace = WhiteSpace.generate; diff --git a/node_modules/css-tree/cjs/syntax/node/index-parse-selector.cjs b/node_modules/css-tree/cjs/syntax/node/index-parse-selector.cjs new file mode 100644 index 00000000..92c4934e --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/index-parse-selector.cjs @@ -0,0 +1,37 @@ +'use strict'; + +const AnPlusB = require('./AnPlusB.cjs'); +const AttributeSelector = require('./AttributeSelector.cjs'); +const ClassSelector = require('./ClassSelector.cjs'); +const Combinator = require('./Combinator.cjs'); +const Identifier = require('./Identifier.cjs'); +const IdSelector = require('./IdSelector.cjs'); +const NestingSelector = require('./NestingSelector.cjs'); +const Nth = require('./Nth.cjs'); +const Percentage = require('./Percentage.cjs'); +const PseudoClassSelector = require('./PseudoClassSelector.cjs'); +const PseudoElementSelector = require('./PseudoElementSelector.cjs'); +const Raw = require('./Raw.cjs'); +const Selector = require('./Selector.cjs'); +const SelectorList = require('./SelectorList.cjs'); +const String = require('./String.cjs'); +const TypeSelector = require('./TypeSelector.cjs'); + + + +exports.AnPlusB = AnPlusB.parse; +exports.AttributeSelector = AttributeSelector.parse; +exports.ClassSelector = ClassSelector.parse; +exports.Combinator = Combinator.parse; +exports.Identifier = Identifier.parse; +exports.IdSelector = IdSelector.parse; +exports.NestingSelector = NestingSelector.parse; +exports.Nth = Nth.parse; +exports.Percentage = Percentage.parse; +exports.PseudoClassSelector = PseudoClassSelector.parse; +exports.PseudoElementSelector = PseudoElementSelector.parse; +exports.Raw = Raw.parse; +exports.Selector = Selector.parse; +exports.SelectorList = SelectorList.parse; +exports.String = String.parse; +exports.TypeSelector = TypeSelector.parse; diff --git a/node_modules/css-tree/cjs/syntax/node/index-parse.cjs b/node_modules/css-tree/cjs/syntax/node/index-parse.cjs new file mode 100644 index 00000000..60e73043 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/index-parse.cjs @@ -0,0 +1,87 @@ +'use strict'; + +const AnPlusB = require('./AnPlusB.cjs'); +const Atrule = require('./Atrule.cjs'); +const AtrulePrelude = require('./AtrulePrelude.cjs'); +const AttributeSelector = require('./AttributeSelector.cjs'); +const Block = require('./Block.cjs'); +const Brackets = require('./Brackets.cjs'); +const CDC = require('./CDC.cjs'); +const CDO = require('./CDO.cjs'); +const ClassSelector = require('./ClassSelector.cjs'); +const Combinator = require('./Combinator.cjs'); +const Comment = require('./Comment.cjs'); +const Declaration = require('./Declaration.cjs'); +const DeclarationList = require('./DeclarationList.cjs'); +const Dimension = require('./Dimension.cjs'); +const Function = require('./Function.cjs'); +const Hash = require('./Hash.cjs'); +const Identifier = require('./Identifier.cjs'); +const IdSelector = require('./IdSelector.cjs'); +const MediaFeature = require('./MediaFeature.cjs'); +const MediaQuery = require('./MediaQuery.cjs'); +const MediaQueryList = require('./MediaQueryList.cjs'); +const NestingSelector = require('./NestingSelector.cjs'); +const Nth = require('./Nth.cjs'); +const Number = require('./Number.cjs'); +const Operator = require('./Operator.cjs'); +const Parentheses = require('./Parentheses.cjs'); +const Percentage = require('./Percentage.cjs'); +const PseudoClassSelector = require('./PseudoClassSelector.cjs'); +const PseudoElementSelector = require('./PseudoElementSelector.cjs'); +const Ratio = require('./Ratio.cjs'); +const Raw = require('./Raw.cjs'); +const Rule = require('./Rule.cjs'); +const Selector = require('./Selector.cjs'); +const SelectorList = require('./SelectorList.cjs'); +const String = require('./String.cjs'); +const StyleSheet = require('./StyleSheet.cjs'); +const TypeSelector = require('./TypeSelector.cjs'); +const UnicodeRange = require('./UnicodeRange.cjs'); +const Url = require('./Url.cjs'); +const Value = require('./Value.cjs'); +const WhiteSpace = require('./WhiteSpace.cjs'); + + + +exports.AnPlusB = AnPlusB.parse; +exports.Atrule = Atrule.parse; +exports.AtrulePrelude = AtrulePrelude.parse; +exports.AttributeSelector = AttributeSelector.parse; +exports.Block = Block.parse; +exports.Brackets = Brackets.parse; +exports.CDC = CDC.parse; +exports.CDO = CDO.parse; +exports.ClassSelector = ClassSelector.parse; +exports.Combinator = Combinator.parse; +exports.Comment = Comment.parse; +exports.Declaration = Declaration.parse; +exports.DeclarationList = DeclarationList.parse; +exports.Dimension = Dimension.parse; +exports.Function = Function.parse; +exports.Hash = Hash.parse; +exports.Identifier = Identifier.parse; +exports.IdSelector = IdSelector.parse; +exports.MediaFeature = MediaFeature.parse; +exports.MediaQuery = MediaQuery.parse; +exports.MediaQueryList = MediaQueryList.parse; +exports.NestingSelector = NestingSelector.parse; +exports.Nth = Nth.parse; +exports.Number = Number.parse; +exports.Operator = Operator.parse; +exports.Parentheses = Parentheses.parse; +exports.Percentage = Percentage.parse; +exports.PseudoClassSelector = PseudoClassSelector.parse; +exports.PseudoElementSelector = PseudoElementSelector.parse; +exports.Ratio = Ratio.parse; +exports.Raw = Raw.parse; +exports.Rule = Rule.parse; +exports.Selector = Selector.parse; +exports.SelectorList = SelectorList.parse; +exports.String = String.parse; +exports.StyleSheet = StyleSheet.parse; +exports.TypeSelector = TypeSelector.parse; +exports.UnicodeRange = UnicodeRange.parse; +exports.Url = Url.parse; +exports.Value = Value.parse; +exports.WhiteSpace = WhiteSpace.parse; diff --git a/node_modules/css-tree/cjs/syntax/node/index.cjs b/node_modules/css-tree/cjs/syntax/node/index.cjs new file mode 100644 index 00000000..45c10a66 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/node/index.cjs @@ -0,0 +1,87 @@ +'use strict'; + +const AnPlusB = require('./AnPlusB.cjs'); +const Atrule = require('./Atrule.cjs'); +const AtrulePrelude = require('./AtrulePrelude.cjs'); +const AttributeSelector = require('./AttributeSelector.cjs'); +const Block = require('./Block.cjs'); +const Brackets = require('./Brackets.cjs'); +const CDC = require('./CDC.cjs'); +const CDO = require('./CDO.cjs'); +const ClassSelector = require('./ClassSelector.cjs'); +const Combinator = require('./Combinator.cjs'); +const Comment = require('./Comment.cjs'); +const Declaration = require('./Declaration.cjs'); +const DeclarationList = require('./DeclarationList.cjs'); +const Dimension = require('./Dimension.cjs'); +const Function = require('./Function.cjs'); +const Hash = require('./Hash.cjs'); +const Identifier = require('./Identifier.cjs'); +const IdSelector = require('./IdSelector.cjs'); +const MediaFeature = require('./MediaFeature.cjs'); +const MediaQuery = require('./MediaQuery.cjs'); +const MediaQueryList = require('./MediaQueryList.cjs'); +const NestingSelector = require('./NestingSelector.cjs'); +const Nth = require('./Nth.cjs'); +const Number$1 = require('./Number.cjs'); +const Operator = require('./Operator.cjs'); +const Parentheses = require('./Parentheses.cjs'); +const Percentage = require('./Percentage.cjs'); +const PseudoClassSelector = require('./PseudoClassSelector.cjs'); +const PseudoElementSelector = require('./PseudoElementSelector.cjs'); +const Ratio = require('./Ratio.cjs'); +const Raw = require('./Raw.cjs'); +const Rule = require('./Rule.cjs'); +const Selector = require('./Selector.cjs'); +const SelectorList = require('./SelectorList.cjs'); +const String$1 = require('./String.cjs'); +const StyleSheet = require('./StyleSheet.cjs'); +const TypeSelector = require('./TypeSelector.cjs'); +const UnicodeRange = require('./UnicodeRange.cjs'); +const Url = require('./Url.cjs'); +const Value = require('./Value.cjs'); +const WhiteSpace = require('./WhiteSpace.cjs'); + + + +exports.AnPlusB = AnPlusB; +exports.Atrule = Atrule; +exports.AtrulePrelude = AtrulePrelude; +exports.AttributeSelector = AttributeSelector; +exports.Block = Block; +exports.Brackets = Brackets; +exports.CDC = CDC; +exports.CDO = CDO; +exports.ClassSelector = ClassSelector; +exports.Combinator = Combinator; +exports.Comment = Comment; +exports.Declaration = Declaration; +exports.DeclarationList = DeclarationList; +exports.Dimension = Dimension; +exports.Function = Function; +exports.Hash = Hash; +exports.Identifier = Identifier; +exports.IdSelector = IdSelector; +exports.MediaFeature = MediaFeature; +exports.MediaQuery = MediaQuery; +exports.MediaQueryList = MediaQueryList; +exports.NestingSelector = NestingSelector; +exports.Nth = Nth; +exports.Number = Number$1; +exports.Operator = Operator; +exports.Parentheses = Parentheses; +exports.Percentage = Percentage; +exports.PseudoClassSelector = PseudoClassSelector; +exports.PseudoElementSelector = PseudoElementSelector; +exports.Ratio = Ratio; +exports.Raw = Raw; +exports.Rule = Rule; +exports.Selector = Selector; +exports.SelectorList = SelectorList; +exports.String = String$1; +exports.StyleSheet = StyleSheet; +exports.TypeSelector = TypeSelector; +exports.UnicodeRange = UnicodeRange; +exports.Url = Url; +exports.Value = Value; +exports.WhiteSpace = WhiteSpace; diff --git a/node_modules/css-tree/cjs/syntax/pseudo/index.cjs b/node_modules/css-tree/cjs/syntax/pseudo/index.cjs new file mode 100644 index 00000000..760905d1 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/pseudo/index.cjs @@ -0,0 +1,54 @@ +'use strict'; + +const selectorList = { + parse() { + return this.createSingleNodeList( + this.SelectorList() + ); + } +}; + +const selector = { + parse() { + return this.createSingleNodeList( + this.Selector() + ); + } +}; + +const identList = { + parse() { + return this.createSingleNodeList( + this.Identifier() + ); + } +}; + +const nth = { + parse() { + return this.createSingleNodeList( + this.Nth() + ); + } +}; + +const pseudo = { + 'dir': identList, + 'has': selectorList, + 'lang': identList, + 'matches': selectorList, + 'is': selectorList, + '-moz-any': selectorList, + '-webkit-any': selectorList, + 'where': selectorList, + 'not': selectorList, + 'nth-child': nth, + 'nth-last-child': nth, + 'nth-last-of-type': nth, + 'nth-of-type': nth, + 'slotted': selector, + 'host': selector, + 'host-context': selector +}; + +module.exports = pseudo; diff --git a/node_modules/css-tree/cjs/syntax/scope/atrulePrelude.cjs b/node_modules/css-tree/cjs/syntax/scope/atrulePrelude.cjs new file mode 100644 index 00000000..65a15447 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/scope/atrulePrelude.cjs @@ -0,0 +1,9 @@ +'use strict'; + +const _default = require('./default.cjs'); + +const atrulePrelude = { + getNode: _default +}; + +module.exports = atrulePrelude; diff --git a/node_modules/css-tree/cjs/syntax/scope/default.cjs b/node_modules/css-tree/cjs/syntax/scope/default.cjs new file mode 100644 index 00000000..43b5c188 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/scope/default.cjs @@ -0,0 +1,76 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const NUMBERSIGN = 0x0023; // U+0023 NUMBER SIGN (#) +const ASTERISK = 0x002A; // U+002A ASTERISK (*) +const PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+) +const HYPHENMINUS = 0x002D; // U+002D HYPHEN-MINUS (-) +const SOLIDUS = 0x002F; // U+002F SOLIDUS (/) +const U = 0x0075; // U+0075 LATIN SMALL LETTER U (u) + +function defaultRecognizer(context) { + switch (this.tokenType) { + case types.Hash: + return this.Hash(); + + case types.Comma: + return this.Operator(); + + case types.LeftParenthesis: + return this.Parentheses(this.readSequence, context.recognizer); + + case types.LeftSquareBracket: + return this.Brackets(this.readSequence, context.recognizer); + + case types.String: + return this.String(); + + case types.Dimension: + return this.Dimension(); + + case types.Percentage: + return this.Percentage(); + + case types.Number: + return this.Number(); + + case types.Function: + return this.cmpStr(this.tokenStart, this.tokenEnd, 'url(') + ? this.Url() + : this.Function(this.readSequence, context.recognizer); + + case types.Url: + return this.Url(); + + case types.Ident: + // check for unicode range, it should start with u+ or U+ + if (this.cmpChar(this.tokenStart, U) && + this.cmpChar(this.tokenStart + 1, PLUSSIGN)) { + return this.UnicodeRange(); + } else { + return this.Identifier(); + } + + case types.Delim: { + const code = this.charCodeAt(this.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.tokenStart + 1); + } + + break; + } + } +} + +module.exports = defaultRecognizer; diff --git a/node_modules/css-tree/cjs/syntax/scope/index.cjs b/node_modules/css-tree/cjs/syntax/scope/index.cjs new file mode 100644 index 00000000..78391281 --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/scope/index.cjs @@ -0,0 +1,11 @@ +'use strict'; + +const atrulePrelude = require('./atrulePrelude.cjs'); +const selector = require('./selector.cjs'); +const value = require('./value.cjs'); + + + +exports.AtrulePrelude = atrulePrelude; +exports.Selector = selector; +exports.Value = value; diff --git a/node_modules/css-tree/cjs/syntax/scope/selector.cjs b/node_modules/css-tree/cjs/syntax/scope/selector.cjs new file mode 100644 index 00000000..6b915aeb --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/scope/selector.cjs @@ -0,0 +1,88 @@ +'use strict'; + +const types = require('../../tokenizer/types.cjs'); + +const NUMBERSIGN = 0x0023; // U+0023 NUMBER SIGN (#) +const AMPERSAND = 0x0026; // U+0026 AMPERSAND (&) +const ASTERISK = 0x002A; // U+002A ASTERISK (*) +const PLUSSIGN = 0x002B; // U+002B PLUS SIGN (+) +const SOLIDUS = 0x002F; // U+002F SOLIDUS (/) +const FULLSTOP = 0x002E; // U+002E FULL STOP (.) +const GREATERTHANSIGN = 0x003E; // U+003E GREATER-THAN SIGN (>) +const VERTICALLINE = 0x007C; // U+007C VERTICAL LINE (|) +const TILDE = 0x007E; // U+007E TILDE (~) + +function onWhiteSpace(next, children) { + if (children.last !== null && children.last.type !== 'Combinator' && + next !== null && next.type !== 'Combinator') { + children.push({ // FIXME: this.Combinator() should be used instead + type: 'Combinator', + loc: null, + name: ' ' + }); + } +} + +function getNode() { + switch (this.tokenType) { + case types.LeftSquareBracket: + return this.AttributeSelector(); + + case types.Hash: + return this.IdSelector(); + + case types.Colon: + if (this.lookupType(1) === types.Colon) { + return this.PseudoElementSelector(); + } else { + return this.PseudoClassSelector(); + } + + case types.Ident: + return this.TypeSelector(); + + case types.Number: + case types.Percentage: + return this.Percentage(); + + case types.Dimension: + // throws when .123ident + if (this.charCodeAt(this.tokenStart) === FULLSTOP) { + this.error('Identifier is expected', this.tokenStart + 1); + } + break; + + case types.Delim: { + const code = this.charCodeAt(this.tokenStart); + + switch (code) { + case PLUSSIGN: + case GREATERTHANSIGN: + case TILDE: + case SOLIDUS: // /deep/ + return this.Combinator(); + + case FULLSTOP: + return this.ClassSelector(); + + case ASTERISK: + case VERTICALLINE: + return this.TypeSelector(); + + case NUMBERSIGN: + return this.IdSelector(); + + case AMPERSAND: + return this.NestingSelector(); + } + + break; + } + } +} +const Selector = { + onWhiteSpace, + getNode +}; + +module.exports = Selector; diff --git a/node_modules/css-tree/cjs/syntax/scope/value.cjs b/node_modules/css-tree/cjs/syntax/scope/value.cjs new file mode 100644 index 00000000..a9900a1c --- /dev/null +++ b/node_modules/css-tree/cjs/syntax/scope/value.cjs @@ -0,0 +1,29 @@ +'use strict'; + +const _default = require('./default.cjs'); +const expression = require('../function/expression.cjs'); +const _var = require('../function/var.cjs'); + +function isPlusMinusOperator(node) { + return ( + node !== null && + node.type === 'Operator' && + (node.value[node.value.length - 1] === '-' || node.value[node.value.length - 1] === '+') + ); +} + +const value = { + getNode: _default, + onWhiteSpace(next, children) { + if (isPlusMinusOperator(next)) { + next.value = ' ' + next.value; + } + if (isPlusMinusOperator(children.last)) { + children.last.value += ' '; + } + }, + 'expression': expression, + 'var': _var +}; + +module.exports = value; |