(function (factory) { if (typeof module === "object" && typeof module.exports === "object") { var v = factory(require, exports); if (v !== undefined) module.exports = v; } else if (typeof define === "function" && define.amd) { define('vscode-css-languageservice/parser/cssScanner',["require", "exports"], factory); } })(function (require, exports) { /*--------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); var TokenType; (function (TokenType) { TokenType[TokenType["Ident"] = 0] = "Ident"; TokenType[TokenType["AtKeyword"] = 1] = "AtKeyword"; TokenType[TokenType["String"] = 2] = "String"; TokenType[TokenType["BadString"] = 3] = "BadString"; TokenType[TokenType["UnquotedString"] = 4] = "UnquotedString"; TokenType[TokenType["Hash"] = 5] = "Hash"; TokenType[TokenType["Num"] = 6] = "Num"; TokenType[TokenType["Percentage"] = 7] = "Percentage"; TokenType[TokenType["Dimension"] = 8] = "Dimension"; TokenType[TokenType["UnicodeRange"] = 9] = "UnicodeRange"; TokenType[TokenType["CDO"] = 10] = "CDO"; TokenType[TokenType["CDC"] = 11] = "CDC"; TokenType[TokenType["Colon"] = 12] = "Colon"; TokenType[TokenType["SemiColon"] = 13] = "SemiColon"; TokenType[TokenType["CurlyL"] = 14] = "CurlyL"; TokenType[TokenType["CurlyR"] = 15] = "CurlyR"; TokenType[TokenType["ParenthesisL"] = 16] = "ParenthesisL"; TokenType[TokenType["ParenthesisR"] = 17] = "ParenthesisR"; TokenType[TokenType["BracketL"] = 18] = "BracketL"; TokenType[TokenType["BracketR"] = 19] = "BracketR"; TokenType[TokenType["Whitespace"] = 20] = "Whitespace"; TokenType[TokenType["Includes"] = 21] = "Includes"; TokenType[TokenType["Dashmatch"] = 22] = "Dashmatch"; TokenType[TokenType["SubstringOperator"] = 23] = "SubstringOperator"; TokenType[TokenType["PrefixOperator"] = 24] = "PrefixOperator"; TokenType[TokenType["SuffixOperator"] = 25] = "SuffixOperator"; TokenType[TokenType["Delim"] = 26] = "Delim"; TokenType[TokenType["EMS"] = 27] = "EMS"; TokenType[TokenType["EXS"] = 28] = "EXS"; TokenType[TokenType["Length"] = 29] = "Length"; TokenType[TokenType["Angle"] = 30] = "Angle"; TokenType[TokenType["Time"] = 31] = "Time"; TokenType[TokenType["Freq"] = 32] = "Freq"; TokenType[TokenType["Exclamation"] = 33] = "Exclamation"; TokenType[TokenType["Resolution"] = 34] = "Resolution"; TokenType[TokenType["Comma"] = 35] = "Comma"; TokenType[TokenType["Charset"] = 36] = "Charset"; TokenType[TokenType["EscapedJavaScript"] = 37] = "EscapedJavaScript"; TokenType[TokenType["BadEscapedJavaScript"] = 38] = "BadEscapedJavaScript"; TokenType[TokenType["Comment"] = 39] = "Comment"; TokenType[TokenType["SingleLineComment"] = 40] = "SingleLineComment"; TokenType[TokenType["EOF"] = 41] = "EOF"; TokenType[TokenType["CustomToken"] = 42] = "CustomToken"; })(TokenType = exports.TokenType || (exports.TokenType = {})); var MultiLineStream = /** @class */ (function () { function MultiLineStream(source) { this.source = source; this.len = source.length; this.position = 0; } MultiLineStream.prototype.substring = function (from, to) { if (to === void 0) { to = this.position; } return this.source.substring(from, to); }; MultiLineStream.prototype.eos = function () { return this.len <= this.position; }; MultiLineStream.prototype.pos = function () { return this.position; }; MultiLineStream.prototype.goBackTo = function (pos) { this.position = pos; }; MultiLineStream.prototype.goBack = function (n) { this.position -= n; }; MultiLineStream.prototype.advance = function (n) { this.position += n; }; MultiLineStream.prototype.nextChar = function () { return this.source.charCodeAt(this.position++) || 0; }; MultiLineStream.prototype.peekChar = function (n) { if (n === void 0) { n = 0; } return this.source.charCodeAt(this.position + n) || 0; }; MultiLineStream.prototype.lookbackChar = function (n) { if (n === void 0) { n = 0; } return this.source.charCodeAt(this.position - n) || 0; }; MultiLineStream.prototype.advanceIfChar = function (ch) { if (ch === this.source.charCodeAt(this.position)) { this.position++; return true; } return false; }; MultiLineStream.prototype.advanceIfChars = function (ch) { if (this.position + ch.length > this.source.length) { return false; } var i = 0; for (; i < ch.length; i++) { if (this.source.charCodeAt(this.position + i) !== ch[i]) { return false; } } this.advance(i); return true; }; MultiLineStream.prototype.advanceWhileChar = function (condition) { var posNow = this.position; while (this.position < this.len && condition(this.source.charCodeAt(this.position))) { this.position++; } return this.position - posNow; }; return MultiLineStream; }()); exports.MultiLineStream = MultiLineStream; var _a = 'a'.charCodeAt(0); var _f = 'f'.charCodeAt(0); var _z = 'z'.charCodeAt(0); var _A = 'A'.charCodeAt(0); var _F = 'F'.charCodeAt(0); var _Z = 'Z'.charCodeAt(0); var _0 = '0'.charCodeAt(0); var _9 = '9'.charCodeAt(0); var _TLD = '~'.charCodeAt(0); var _HAT = '^'.charCodeAt(0); var _EQS = '='.charCodeAt(0); var _PIP = '|'.charCodeAt(0); var _MIN = '-'.charCodeAt(0); var _USC = '_'.charCodeAt(0); var _PRC = '%'.charCodeAt(0); var _MUL = '*'.charCodeAt(0); var _LPA = '('.charCodeAt(0); var _RPA = ')'.charCodeAt(0); var _LAN = '<'.charCodeAt(0); var _RAN = '>'.charCodeAt(0); var _ATS = '@'.charCodeAt(0); var _HSH = '#'.charCodeAt(0); var _DLR = '$'.charCodeAt(0); var _BSL = '\\'.charCodeAt(0); var _FSL = '/'.charCodeAt(0); var _NWL = '\n'.charCodeAt(0); var _CAR = '\r'.charCodeAt(0); var _LFD = '\f'.charCodeAt(0); var _DQO = '"'.charCodeAt(0); var _SQO = '\''.charCodeAt(0); var _WSP = ' '.charCodeAt(0); var _TAB = '\t'.charCodeAt(0); var _SEM = ';'.charCodeAt(0); var _COL = ':'.charCodeAt(0); var _CUL = '{'.charCodeAt(0); var _CUR = '}'.charCodeAt(0); var _BRL = '['.charCodeAt(0); var _BRR = ']'.charCodeAt(0); var _CMA = ','.charCodeAt(0); var _DOT = '.'.charCodeAt(0); var _BNG = '!'.charCodeAt(0); var staticTokenTable = {}; staticTokenTable[_SEM] = TokenType.SemiColon; staticTokenTable[_COL] = TokenType.Colon; staticTokenTable[_CUL] = TokenType.CurlyL; staticTokenTable[_CUR] = TokenType.CurlyR; staticTokenTable[_BRR] = TokenType.BracketR; staticTokenTable[_BRL] = TokenType.BracketL; staticTokenTable[_LPA] = TokenType.ParenthesisL; staticTokenTable[_RPA] = TokenType.ParenthesisR; staticTokenTable[_CMA] = TokenType.Comma; var staticUnitTable = {}; staticUnitTable['em'] = TokenType.EMS; staticUnitTable['ex'] = TokenType.EXS; staticUnitTable['px'] = TokenType.Length; staticUnitTable['cm'] = TokenType.Length; staticUnitTable['mm'] = TokenType.Length; staticUnitTable['in'] = TokenType.Length; staticUnitTable['pt'] = TokenType.Length; staticUnitTable['pc'] = TokenType.Length; staticUnitTable['deg'] = TokenType.Angle; staticUnitTable['rad'] = TokenType.Angle; staticUnitTable['grad'] = TokenType.Angle; staticUnitTable['ms'] = TokenType.Time; staticUnitTable['s'] = TokenType.Time; staticUnitTable['hz'] = TokenType.Freq; staticUnitTable['khz'] = TokenType.Freq; staticUnitTable['%'] = TokenType.Percentage; staticUnitTable['fr'] = TokenType.Percentage; staticUnitTable['dpi'] = TokenType.Resolution; staticUnitTable['dpcm'] = TokenType.Resolution; var Scanner = /** @class */ (function () { function Scanner() { this.stream = new MultiLineStream(''); this.ignoreComment = true; this.ignoreWhitespace = true; this.inURL = false; } Scanner.prototype.setSource = function (input) { this.stream = new MultiLineStream(input); }; Scanner.prototype.finishToken = function (offset, type, text) { return { offset: offset, len: this.stream.pos() - offset, type: type, text: text || this.stream.substring(offset) }; }; Scanner.prototype.substring = function (offset, len) { return this.stream.substring(offset, offset + len); }; Scanner.prototype.pos = function () { return this.stream.pos(); }; Scanner.prototype.goBackTo = function (pos) { this.stream.goBackTo(pos); }; Scanner.prototype.scanUnquotedString = function () { var offset = this.stream.pos(); var content = []; if (this._unquotedString(content)) { return this.finishToken(offset, TokenType.UnquotedString, content.join('')); } return null; }; Scanner.prototype.scan = function () { // processes all whitespaces and comments var triviaToken = this.trivia(); if (triviaToken !== null) { return triviaToken; } var offset = this.stream.pos(); // End of file/input if (this.stream.eos()) { return this.finishToken(offset, TokenType.EOF); } return this.scanNext(offset); }; Scanner.prototype.scanNext = function (offset) { // CDO if (this.stream.advanceIfChars([_MIN, _MIN, _RAN])) { return this.finishToken(offset, TokenType.CDC); } var content = []; if (this.ident(content)) { return this.finishToken(offset, TokenType.Ident, content.join('')); } // at-keyword if (this.stream.advanceIfChar(_ATS)) { content = ['@']; if (this._name(content)) { var keywordText = content.join(''); if (keywordText === '@charset') { return this.finishToken(offset, TokenType.Charset, keywordText); } return this.finishToken(offset, TokenType.AtKeyword, keywordText); } else { return this.finishToken(offset, TokenType.Delim); } } // hash if (this.stream.advanceIfChar(_HSH)) { content = ['#']; if (this._name(content)) { return this.finishToken(offset, TokenType.Hash, content.join('')); } else { return this.finishToken(offset, TokenType.Delim); } } // Important if (this.stream.advanceIfChar(_BNG)) { return this.finishToken(offset, TokenType.Exclamation); } // Numbers if (this._number()) { var pos = this.stream.pos(); content = [this.stream.substring(offset, pos)]; if (this.stream.advanceIfChar(_PRC)) { // Percentage 43% return this.finishToken(offset, TokenType.Percentage); } else if (this.ident(content)) { var dim = this.stream.substring(pos).toLowerCase(); var tokenType_1 = staticUnitTable[dim]; if (typeof tokenType_1 !== 'undefined') { // Known dimension 43px return this.finishToken(offset, tokenType_1, content.join('')); } else { // Unknown dimension 43ft return this.finishToken(offset, TokenType.Dimension, content.join('')); } } return this.finishToken(offset, TokenType.Num); } // String, BadString content = []; var tokenType = this._string(content); if (tokenType !== null) { return this.finishToken(offset, tokenType, content.join('')); } // single character tokens tokenType = staticTokenTable[this.stream.peekChar()]; if (typeof tokenType !== 'undefined') { this.stream.advance(1); return this.finishToken(offset, tokenType); } // includes ~= if (this.stream.peekChar(0) === _TLD && this.stream.peekChar(1) === _EQS) { this.stream.advance(2); return this.finishToken(offset, TokenType.Includes); } // DashMatch |= if (this.stream.peekChar(0) === _PIP && this.stream.peekChar(1) === _EQS) { this.stream.advance(2); return this.finishToken(offset, TokenType.Dashmatch); } // Substring operator *= if (this.stream.peekChar(0) === _MUL && this.stream.peekChar(1) === _EQS) { this.stream.advance(2); return this.finishToken(offset, TokenType.SubstringOperator); } // Substring operator ^= if (this.stream.peekChar(0) === _HAT && this.stream.peekChar(1) === _EQS) { this.stream.advance(2); return this.finishToken(offset, TokenType.PrefixOperator); } // Substring operator $= if (this.stream.peekChar(0) === _DLR && this.stream.peekChar(1) === _EQS) { this.stream.advance(2); return this.finishToken(offset, TokenType.SuffixOperator); } // Delim this.stream.nextChar(); return this.finishToken(offset, TokenType.Delim); }; Scanner.prototype._matchWordAnyCase = function (characters) { var index = 0; this.stream.advanceWhileChar(function (ch) { var result = characters[index] === ch || characters[index + 1] === ch; if (result) { index += 2; } return result; }); if (index === characters.length) { return true; } else { this.stream.goBack(index / 2); return false; } }; Scanner.prototype.trivia = function () { while (true) { var offset = this.stream.pos(); if (this._whitespace()) { if (!this.ignoreWhitespace) { return this.finishToken(offset, TokenType.Whitespace); } } else if (this.comment()) { if (!this.ignoreComment) { return this.finishToken(offset, TokenType.Comment); } } else { return null; } } }; Scanner.prototype.comment = function () { if (this.stream.advanceIfChars([_FSL, _MUL])) { var success_1 = false, hot_1 = false; this.stream.advanceWhileChar(function (ch) { if (hot_1 && ch === _FSL) { success_1 = true; return false; } hot_1 = ch === _MUL; return true; }); if (success_1) { this.stream.advance(1); } return true; } return false; }; Scanner.prototype._number = function () { var npeek = 0, ch; if (this.stream.peekChar() === _DOT) { npeek = 1; } ch = this.stream.peekChar(npeek); if (ch >= _0 && ch <= _9) { this.stream.advance(npeek + 1); this.stream.advanceWhileChar(function (ch) { return ch >= _0 && ch <= _9 || npeek === 0 && ch === _DOT; }); return true; } return false; }; Scanner.prototype._newline = function (result) { var ch = this.stream.peekChar(); switch (ch) { case _CAR: case _LFD: case _NWL: this.stream.advance(1); result.push(String.fromCharCode(ch)); if (ch === _CAR && this.stream.advanceIfChar(_NWL)) { result.push('\n'); } return true; } return false; }; Scanner.prototype._escape = function (result, includeNewLines) { var ch = this.stream.peekChar(); if (ch === _BSL) { this.stream.advance(1); ch = this.stream.peekChar(); var hexNumCount = 0; while (hexNumCount < 6 && (ch >= _0 && ch <= _9 || ch >= _a && ch <= _f || ch >= _A && ch <= _F)) { this.stream.advance(1); ch = this.stream.peekChar(); hexNumCount++; } if (hexNumCount > 0) { try { var hexVal = parseInt(this.stream.substring(this.stream.pos() - hexNumCount), 16); if (hexVal) { result.push(String.fromCharCode(hexVal)); } } catch (e) { // ignore } // optional whitespace or new line, not part of result text if (ch === _WSP || ch === _TAB) { this.stream.advance(1); } else { this._newline([]); } return true; } if (ch !== _CAR && ch !== _LFD && ch !== _NWL) { this.stream.advance(1); result.push(String.fromCharCode(ch)); return true; } else if (includeNewLines) { return this._newline(result); } } return false; }; Scanner.prototype._stringChar = function (closeQuote, result) { // not closeQuote, not backslash, not newline var ch = this.stream.peekChar(); if (ch !== 0 && ch !== closeQuote && ch !== _BSL && ch !== _CAR && ch !== _LFD && ch !== _NWL) { this.stream.advance(1); result.push(String.fromCharCode(ch)); return true; } return false; }; Scanner.prototype._string = function (result) { if (this.stream.peekChar() === _SQO || this.stream.peekChar() === _DQO) { var closeQuote = this.stream.nextChar(); result.push(String.fromCharCode(closeQuote)); while (this._stringChar(closeQuote, result) || this._escape(result, true)) { // loop } if (this.stream.peekChar() === closeQuote) { this.stream.nextChar(); result.push(String.fromCharCode(closeQuote)); return TokenType.String; } else { return TokenType.BadString; } } return null; }; Scanner.prototype._unquotedChar = function (result) { // not closeQuote, not backslash, not newline var ch = this.stream.peekChar(); if (ch !== 0 && ch !== _BSL && ch !== _SQO && ch !== _DQO && ch !== _LPA && ch !== _RPA && ch !== _WSP && ch !== _TAB && ch !== _NWL && ch !== _LFD && ch !== _CAR) { this.stream.advance(1); result.push(String.fromCharCode(ch)); return true; } return false; }; Scanner.prototype._unquotedString = function (result) { var hasContent = false; while (this._unquotedChar(result) || this._escape(result)) { hasContent = true; } return hasContent; }; Scanner.prototype._whitespace = function () { var n = this.stream.advanceWhileChar(function (ch) { return ch === _WSP || ch === _TAB || ch === _NWL || ch === _LFD || ch === _CAR; }); return n > 0; }; Scanner.prototype._name = function (result) { var matched = false; while (this._identChar(result) || this._escape(result)) { matched = true; } return matched; }; Scanner.prototype.ident = function (result) { var pos = this.stream.pos(); var hasMinus = this._minus(result); if (hasMinus && this._minus(result) /* -- */) { if (this._identFirstChar(result) || this._escape(result)) { while (this._identChar(result) || this._escape(result)) { // loop } return true; } } else if (this._identFirstChar(result) || this._escape(result)) { while (this._identChar(result) || this._escape(result)) { // loop } return true; } this.stream.goBackTo(pos); return false; }; Scanner.prototype._identFirstChar = function (result) { var ch = this.stream.peekChar(); if (ch === _USC || // _ ch >= _a && ch <= _z || // a-z ch >= _A && ch <= _Z || // A-Z ch >= 0x80 && ch <= 0xFFFF) { // nonascii this.stream.advance(1); result.push(String.fromCharCode(ch)); return true; } return false; }; Scanner.prototype._minus = function (result) { var ch = this.stream.peekChar(); if (ch === _MIN) { this.stream.advance(1); result.push(String.fromCharCode(ch)); return true; } return false; }; Scanner.prototype._identChar = function (result) { var ch = this.stream.peekChar(); if (ch === _USC || // _ ch === _MIN || // - ch >= _a && ch <= _z || // a-z ch >= _A && ch <= _Z || // A-Z ch >= _0 && ch <= _9 || // 0/9 ch >= 0x80 && ch <= 0xFFFF) { // nonascii this.stream.advance(1); result.push(String.fromCharCode(ch)); return true; } return false; }; return Scanner; }()); exports.Scanner = Scanner; }); var __extends = (this && this.__extends) || (function () { var extendStatics = function (d, b) { extendStatics = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; return extendStatics(d, b); }; return function (d, b) { extendStatics(d, b); function __() { this.constructor = d; } d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); }; })(); (function (factory) { if (typeof module === "object" && typeof module.exports === "object") { var v = factory(require, exports); if (v !== undefined) module.exports = v; } else if (typeof define === "function" && define.amd) { define('vscode-css-languageservice/parser/cssNodes',["require", "exports"], factory); } })(function (require, exports) { /*--------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); /// /// Nodes for the css 2.1 specification. See for reference: /// http://www.w3.org/TR/CSS21/grammar.html#grammar /// var NodeType; (function (NodeType) { NodeType[NodeType["Undefined"] = 0] = "Undefined"; NodeType[NodeType["Identifier"] = 1] = "Identifier"; NodeType[NodeType["Stylesheet"] = 2] = "Stylesheet"; NodeType[NodeType["Ruleset"] = 3] = "Ruleset"; NodeType[NodeType["Selector"] = 4] = "Selector"; NodeType[NodeType["SimpleSelector"] = 5] = "SimpleSelector"; NodeType[NodeType["SelectorInterpolation"] = 6] = "SelectorInterpolation"; NodeType[NodeType["SelectorCombinator"] = 7] = "SelectorCombinator"; NodeType[NodeType["SelectorCombinatorParent"] = 8] = "SelectorCombinatorParent"; NodeType[NodeType["SelectorCombinatorSibling"] = 9] = "SelectorCombinatorSibling"; NodeType[NodeType["SelectorCombinatorAllSiblings"] = 10] = "SelectorCombinatorAllSiblings"; NodeType[NodeType["SelectorCombinatorShadowPiercingDescendant"] = 11] = "SelectorCombinatorShadowPiercingDescendant"; NodeType[NodeType["Page"] = 12] = "Page"; NodeType[NodeType["PageBoxMarginBox"] = 13] = "PageBoxMarginBox"; NodeType[NodeType["ClassSelector"] = 14] = "ClassSelector"; NodeType[NodeType["IdentifierSelector"] = 15] = "IdentifierSelector"; NodeType[NodeType["ElementNameSelector"] = 16] = "ElementNameSelector"; NodeType[NodeType["PseudoSelector"] = 17] = "PseudoSelector"; NodeType[NodeType["AttributeSelector"] = 18] = "AttributeSelector"; NodeType[NodeType["Declaration"] = 19] = "Declaration"; NodeType[NodeType["Declarations"] = 20] = "Declarations"; NodeType[NodeType["Property"] = 21] = "Property"; NodeType[NodeType["Expression"] = 22] = "Expression"; NodeType[NodeType["BinaryExpression"] = 23] = "BinaryExpression"; NodeType[NodeType["Term"] = 24] = "Term"; NodeType[NodeType["Operator"] = 25] = "Operator"; NodeType[NodeType["Value"] = 26] = "Value"; NodeType[NodeType["StringLiteral"] = 27] = "StringLiteral"; NodeType[NodeType["URILiteral"] = 28] = "URILiteral"; NodeType[NodeType["EscapedValue"] = 29] = "EscapedValue"; NodeType[NodeType["Function"] = 30] = "Function"; NodeType[NodeType["NumericValue"] = 31] = "NumericValue"; NodeType[NodeType["HexColorValue"] = 32] = "HexColorValue"; NodeType[NodeType["MixinDeclaration"] = 33] = "MixinDeclaration"; NodeType[NodeType["MixinReference"] = 34] = "MixinReference"; NodeType[NodeType["VariableName"] = 35] = "VariableName"; NodeType[NodeType["VariableDeclaration"] = 36] = "VariableDeclaration"; NodeType[NodeType["Prio"] = 37] = "Prio"; NodeType[NodeType["Interpolation"] = 38] = "Interpolation"; NodeType[NodeType["NestedProperties"] = 39] = "NestedProperties"; NodeType[NodeType["ExtendsReference"] = 40] = "ExtendsReference"; NodeType[NodeType["SelectorPlaceholder"] = 41] = "SelectorPlaceholder"; NodeType[NodeType["Debug"] = 42] = "Debug"; NodeType[NodeType["If"] = 43] = "If"; NodeType[NodeType["Else"] = 44] = "Else"; NodeType[NodeType["For"] = 45] = "For"; NodeType[NodeType["Each"] = 46] = "Each"; NodeType[NodeType["While"] = 47] = "While"; NodeType[NodeType["MixinContent"] = 48] = "MixinContent"; NodeType[NodeType["Media"] = 49] = "Media"; NodeType[NodeType["Keyframe"] = 50] = "Keyframe"; NodeType[NodeType["FontFace"] = 51] = "FontFace"; NodeType[NodeType["Import"] = 52] = "Import"; NodeType[NodeType["Namespace"] = 53] = "Namespace"; NodeType[NodeType["Invocation"] = 54] = "Invocation"; NodeType[NodeType["FunctionDeclaration"] = 55] = "FunctionDeclaration"; NodeType[NodeType["ReturnStatement"] = 56] = "ReturnStatement"; NodeType[NodeType["MediaQuery"] = 57] = "MediaQuery"; NodeType[NodeType["FunctionParameter"] = 58] = "FunctionParameter"; NodeType[NodeType["FunctionArgument"] = 59] = "FunctionArgument"; NodeType[NodeType["KeyframeSelector"] = 60] = "KeyframeSelector"; NodeType[NodeType["ViewPort"] = 61] = "ViewPort"; NodeType[NodeType["Document"] = 62] = "Document"; NodeType[NodeType["AtApplyRule"] = 63] = "AtApplyRule"; NodeType[NodeType["CustomPropertyDeclaration"] = 64] = "CustomPropertyDeclaration"; NodeType[NodeType["CustomPropertySet"] = 65] = "CustomPropertySet"; NodeType[NodeType["ListEntry"] = 66] = "ListEntry"; NodeType[NodeType["Supports"] = 67] = "Supports"; NodeType[NodeType["SupportsCondition"] = 68] = "SupportsCondition"; NodeType[NodeType["NamespacePrefix"] = 69] = "NamespacePrefix"; NodeType[NodeType["GridLine"] = 70] = "GridLine"; NodeType[NodeType["Plugin"] = 71] = "Plugin"; NodeType[NodeType["UnknownAtRule"] = 72] = "UnknownAtRule"; NodeType[NodeType["Use"] = 73] = "Use"; NodeType[NodeType["ModuleConfiguration"] = 74] = "ModuleConfiguration"; NodeType[NodeType["Forward"] = 75] = "Forward"; NodeType[NodeType["ForwardVisibility"] = 76] = "ForwardVisibility"; NodeType[NodeType["Module"] = 77] = "Module"; })(NodeType = exports.NodeType || (exports.NodeType = {})); var ReferenceType; (function (ReferenceType) { ReferenceType[ReferenceType["Mixin"] = 0] = "Mixin"; ReferenceType[ReferenceType["Rule"] = 1] = "Rule"; ReferenceType[ReferenceType["Variable"] = 2] = "Variable"; ReferenceType[ReferenceType["Function"] = 3] = "Function"; ReferenceType[ReferenceType["Keyframe"] = 4] = "Keyframe"; ReferenceType[ReferenceType["Unknown"] = 5] = "Unknown"; ReferenceType[ReferenceType["Module"] = 6] = "Module"; ReferenceType[ReferenceType["Forward"] = 7] = "Forward"; ReferenceType[ReferenceType["ForwardVisibility"] = 8] = "ForwardVisibility"; })(ReferenceType = exports.ReferenceType || (exports.ReferenceType = {})); function getNodeAtOffset(node, offset) { var candidate = null; if (!node || offset < node.offset || offset > node.end) { return null; } // Find the shortest node at the position node.accept(function (node) { if (node.offset === -1 && node.length === -1) { return true; } if (node.offset <= offset && node.end >= offset) { if (!candidate) { candidate = node; } else if (node.length <= candidate.length) { candidate = node; } return true; } return false; }); return candidate; } exports.getNodeAtOffset = getNodeAtOffset; function getNodePath(node, offset) { var candidate = getNodeAtOffset(node, offset); var path = []; while (candidate) { path.unshift(candidate); candidate = candidate.parent; } return path; } exports.getNodePath = getNodePath; function getParentDeclaration(node) { var decl = node.findParent(NodeType.Declaration); var value = decl && decl.getValue(); if (value && value.encloses(node)) { return decl; } return null; } exports.getParentDeclaration = getParentDeclaration; var Node = /** @class */ (function () { function Node(offset, len, nodeType) { if (offset === void 0) { offset = -1; } if (len === void 0) { len = -1; } this.parent = null; this.offset = offset; this.length = len; if (nodeType) { this.nodeType = nodeType; } } Object.defineProperty(Node.prototype, "end", { get: function () { return this.offset + this.length; }, enumerable: true, configurable: true }); Object.defineProperty(Node.prototype, "type", { get: function () { return this.nodeType || NodeType.Undefined; }, set: function (type) { this.nodeType = type; }, enumerable: true, configurable: true }); Node.prototype.getTextProvider = function () { var node = this; while (node && !node.textProvider) { node = node.parent; } if (node) { return node.textProvider; } return function () { return 'unknown'; }; }; Node.prototype.getText = function () { return this.getTextProvider()(this.offset, this.length); }; Node.prototype.matches = function (str) { return this.length === str.length && this.getTextProvider()(this.offset, this.length) === str; }; Node.prototype.startsWith = function (str) { return this.length >= str.length && this.getTextProvider()(this.offset, str.length) === str; }; Node.prototype.endsWith = function (str) { return this.length >= str.length && this.getTextProvider()(this.end - str.length, str.length) === str; }; Node.prototype.accept = function (visitor) { if (visitor(this) && this.children) { for (var _i = 0, _a = this.children; _i < _a.length; _i++) { var child = _a[_i]; child.accept(visitor); } } }; Node.prototype.acceptVisitor = function (visitor) { this.accept(visitor.visitNode.bind(visitor)); }; Node.prototype.adoptChild = function (node, index) { if (index === void 0) { index = -1; } if (node.parent && node.parent.children) { var idx = node.parent.children.indexOf(node); if (idx >= 0) { node.parent.children.splice(idx, 1); } } node.parent = this; var children = this.children; if (!children) { children = this.children = []; } if (index !== -1) { children.splice(index, 0, node); } else { children.push(node); } return node; }; Node.prototype.attachTo = function (parent, index) { if (index === void 0) { index = -1; } if (parent) { parent.adoptChild(this, index); } return this; }; Node.prototype.collectIssues = function (results) { if (this.issues) { results.push.apply(results, this.issues); } }; Node.prototype.addIssue = function (issue) { if (!this.issues) { this.issues = []; } this.issues.push(issue); }; Node.prototype.hasIssue = function (rule) { return Array.isArray(this.issues) && this.issues.some(function (i) { return i.getRule() === rule; }); }; Node.prototype.isErroneous = function (recursive) { if (recursive === void 0) { recursive = false; } if (this.issues && this.issues.length > 0) { return true; } return recursive && Array.isArray(this.children) && this.children.some(function (c) { return c.isErroneous(true); }); }; Node.prototype.setNode = function (field, node, index) { if (index === void 0) { index = -1; } if (node) { node.attachTo(this, index); this[field] = node; return true; } return false; }; Node.prototype.addChild = function (node) { if (node) { if (!this.children) { this.children = []; } node.attachTo(this); this.updateOffsetAndLength(node); return true; } return false; }; Node.prototype.updateOffsetAndLength = function (node) { if (node.offset < this.offset || this.offset === -1) { this.offset = node.offset; } var nodeEnd = node.end; if ((nodeEnd > this.end) || this.length === -1) { this.length = nodeEnd - this.offset; } }; Node.prototype.hasChildren = function () { return !!this.children && this.children.length > 0; }; Node.prototype.getChildren = function () { return this.children ? this.children.slice(0) : []; }; Node.prototype.getChild = function (index) { if (this.children && index < this.children.length) { return this.children[index]; } return null; }; Node.prototype.addChildren = function (nodes) { for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) { var node = nodes_1[_i]; this.addChild(node); } }; Node.prototype.findFirstChildBeforeOffset = function (offset) { if (this.children) { var current = null; for (var i = this.children.length - 1; i >= 0; i--) { // iterate until we find a child that has a start offset smaller than the input offset current = this.children[i]; if (current.offset <= offset) { return current; } } } return null; }; Node.prototype.findChildAtOffset = function (offset, goDeep) { var current = this.findFirstChildBeforeOffset(offset); if (current && current.end >= offset) { if (goDeep) { return current.findChildAtOffset(offset, true) || current; } return current; } return null; }; Node.prototype.encloses = function (candidate) { return this.offset <= candidate.offset && this.offset + this.length >= candidate.offset + candidate.length; }; Node.prototype.getParent = function () { var result = this.parent; while (result instanceof Nodelist) { result = result.parent; } return result; }; Node.prototype.findParent = function (type) { var result = this; while (result && result.type !== type) { result = result.parent; } return result; }; Node.prototype.findAParent = function () { var types = []; for (var _i = 0; _i < arguments.length; _i++) { types[_i] = arguments[_i]; } var result = this; while (result && !types.some(function (t) { return result.type === t; })) { result = result.parent; } return result; }; Node.prototype.setData = function (key, value) { if (!this.options) { this.options = {}; } this.options[key] = value; }; Node.prototype.getData = function (key) { if (!this.options || !this.options.hasOwnProperty(key)) { return null; } return this.options[key]; }; return Node; }()); exports.Node = Node; var Nodelist = /** @class */ (function (_super) { __extends(Nodelist, _super); function Nodelist(parent, index) { if (index === void 0) { index = -1; } var _this = _super.call(this, -1, -1) || this; _this.attachTo(parent, index); _this.offset = -1; _this.length = -1; return _this; } return Nodelist; }(Node)); exports.Nodelist = Nodelist; var Identifier = /** @class */ (function (_super) { __extends(Identifier, _super); function Identifier(offset, length) { var _this = _super.call(this, offset, length) || this; _this.isCustomProperty = false; return _this; } Object.defineProperty(Identifier.prototype, "type", { get: function () { return NodeType.Identifier; }, enumerable: true, configurable: true }); Identifier.prototype.containsInterpolation = function () { return this.hasChildren(); }; return Identifier; }(Node)); exports.Identifier = Identifier; var Stylesheet = /** @class */ (function (_super) { __extends(Stylesheet, _super); function Stylesheet(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(Stylesheet.prototype, "type", { get: function () { return NodeType.Stylesheet; }, enumerable: true, configurable: true }); return Stylesheet; }(Node)); exports.Stylesheet = Stylesheet; var Declarations = /** @class */ (function (_super) { __extends(Declarations, _super); function Declarations(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(Declarations.prototype, "type", { get: function () { return NodeType.Declarations; }, enumerable: true, configurable: true }); return Declarations; }(Node)); exports.Declarations = Declarations; var BodyDeclaration = /** @class */ (function (_super) { __extends(BodyDeclaration, _super); function BodyDeclaration(offset, length) { return _super.call(this, offset, length) || this; } BodyDeclaration.prototype.getDeclarations = function () { return this.declarations; }; BodyDeclaration.prototype.setDeclarations = function (decls) { return this.setNode('declarations', decls); }; return BodyDeclaration; }(Node)); exports.BodyDeclaration = BodyDeclaration; var RuleSet = /** @class */ (function (_super) { __extends(RuleSet, _super); function RuleSet(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(RuleSet.prototype, "type", { get: function () { return NodeType.Ruleset; }, enumerable: true, configurable: true }); RuleSet.prototype.getSelectors = function () { if (!this.selectors) { this.selectors = new Nodelist(this); } return this.selectors; }; RuleSet.prototype.isNested = function () { return !!this.parent && this.parent.findParent(NodeType.Declarations) !== null; }; return RuleSet; }(BodyDeclaration)); exports.RuleSet = RuleSet; var Selector = /** @class */ (function (_super) { __extends(Selector, _super); function Selector(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(Selector.prototype, "type", { get: function () { return NodeType.Selector; }, enumerable: true, configurable: true }); return Selector; }(Node)); exports.Selector = Selector; var SimpleSelector = /** @class */ (function (_super) { __extends(SimpleSelector, _super); function SimpleSelector(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(SimpleSelector.prototype, "type", { get: function () { return NodeType.SimpleSelector; }, enumerable: true, configurable: true }); return SimpleSelector; }(Node)); exports.SimpleSelector = SimpleSelector; var AtApplyRule = /** @class */ (function (_super) { __extends(AtApplyRule, _super); function AtApplyRule(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(AtApplyRule.prototype, "type", { get: function () { return NodeType.AtApplyRule; }, enumerable: true, configurable: true }); AtApplyRule.prototype.setIdentifier = function (node) { return this.setNode('identifier', node, 0); }; AtApplyRule.prototype.getIdentifier = function () { return this.identifier; }; AtApplyRule.prototype.getName = function () { return this.identifier ? this.identifier.getText() : ''; }; return AtApplyRule; }(Node)); exports.AtApplyRule = AtApplyRule; var AbstractDeclaration = /** @class */ (function (_super) { __extends(AbstractDeclaration, _super); function AbstractDeclaration(offset, length) { return _super.call(this, offset, length) || this; } return AbstractDeclaration; }(Node)); exports.AbstractDeclaration = AbstractDeclaration; var CustomPropertyDeclaration = /** @class */ (function (_super) { __extends(CustomPropertyDeclaration, _super); function CustomPropertyDeclaration(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(CustomPropertyDeclaration.prototype, "type", { get: function () { return NodeType.CustomPropertyDeclaration; }, enumerable: true, configurable: true }); CustomPropertyDeclaration.prototype.setProperty = function (node) { return this.setNode('property', node); }; CustomPropertyDeclaration.prototype.getProperty = function () { return this.property; }; CustomPropertyDeclaration.prototype.setValue = function (value) { return this.setNode('value', value); }; CustomPropertyDeclaration.prototype.getValue = function () { return this.value; }; CustomPropertyDeclaration.prototype.setPropertySet = function (value) { return this.setNode('propertySet', value); }; CustomPropertyDeclaration.prototype.getPropertySet = function () { return this.propertySet; }; return CustomPropertyDeclaration; }(AbstractDeclaration)); exports.CustomPropertyDeclaration = CustomPropertyDeclaration; var CustomPropertySet = /** @class */ (function (_super) { __extends(CustomPropertySet, _super); function CustomPropertySet(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(CustomPropertySet.prototype, "type", { get: function () { return NodeType.CustomPropertySet; }, enumerable: true, configurable: true }); return CustomPropertySet; }(BodyDeclaration)); exports.CustomPropertySet = CustomPropertySet; var Declaration = /** @class */ (function (_super) { __extends(Declaration, _super); function Declaration(offset, length) { var _this = _super.call(this, offset, length) || this; _this.property = null; return _this; } Object.defineProperty(Declaration.prototype, "type", { get: function () { return NodeType.Declaration; }, enumerable: true, configurable: true }); Declaration.prototype.setProperty = function (node) { return this.setNode('property', node); }; Declaration.prototype.getProperty = function () { return this.property; }; Declaration.prototype.getFullPropertyName = function () { var propertyName = this.property ? this.property.getName() : 'unknown'; if (this.parent instanceof Declarations && this.parent.getParent() instanceof NestedProperties) { var parentDecl = this.parent.getParent().getParent(); if (parentDecl instanceof Declaration) { return parentDecl.getFullPropertyName() + propertyName; } } return propertyName; }; Declaration.prototype.getNonPrefixedPropertyName = function () { var propertyName = this.getFullPropertyName(); if (propertyName && propertyName.charAt(0) === '-') { var vendorPrefixEnd = propertyName.indexOf('-', 1); if (vendorPrefixEnd !== -1) { return propertyName.substring(vendorPrefixEnd + 1); } } return propertyName; }; Declaration.prototype.setValue = function (value) { return this.setNode('value', value); }; Declaration.prototype.getValue = function () { return this.value; }; Declaration.prototype.setNestedProperties = function (value) { return this.setNode('nestedProperties', value); }; Declaration.prototype.getNestedProperties = function () { return this.nestedProperties; }; return Declaration; }(AbstractDeclaration)); exports.Declaration = Declaration; var Property = /** @class */ (function (_super) { __extends(Property, _super); function Property(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(Property.prototype, "type", { get: function () { return NodeType.Property; }, enumerable: true, configurable: true }); Property.prototype.setIdentifier = function (value) { return this.setNode('identifier', value); }; Property.prototype.getIdentifier = function () { return this.identifier; }; Property.prototype.getName = function () { return this.getText(); }; Property.prototype.isCustomProperty = function () { return !!this.identifier && this.identifier.isCustomProperty; }; return Property; }(Node)); exports.Property = Property; var Invocation = /** @class */ (function (_super) { __extends(Invocation, _super); function Invocation(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(Invocation.prototype, "type", { get: function () { return NodeType.Invocation; }, enumerable: true, configurable: true }); Invocation.prototype.getArguments = function () { if (!this.arguments) { this.arguments = new Nodelist(this); } return this.arguments; }; return Invocation; }(Node)); exports.Invocation = Invocation; var Function = /** @class */ (function (_super) { __extends(Function, _super); function Function(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(Function.prototype, "type", { get: function () { return NodeType.Function; }, enumerable: true, configurable: true }); Function.prototype.setIdentifier = function (node) { return this.setNode('identifier', node, 0); }; Function.prototype.getIdentifier = function () { return this.identifier; }; Function.prototype.getName = function () { return this.identifier ? this.identifier.getText() : ''; }; return Function; }(Invocation)); exports.Function = Function; var FunctionParameter = /** @class */ (function (_super) { __extends(FunctionParameter, _super); function FunctionParameter(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(FunctionParameter.prototype, "type", { get: function () { return NodeType.FunctionParameter; }, enumerable: true, configurable: true }); FunctionParameter.prototype.setIdentifier = function (node) { return this.setNode('identifier', node, 0); }; FunctionParameter.prototype.getIdentifier = function () { return this.identifier; }; FunctionParameter.prototype.getName = function () { return this.identifier ? this.identifier.getText() : ''; }; FunctionParameter.prototype.setDefaultValue = function (node) { return this.setNode('defaultValue', node, 0); }; FunctionParameter.prototype.getDefaultValue = function () { return this.defaultValue; }; return FunctionParameter; }(Node)); exports.FunctionParameter = FunctionParameter; var FunctionArgument = /** @class */ (function (_super) { __extends(FunctionArgument, _super); function FunctionArgument(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(FunctionArgument.prototype, "type", { get: function () { return NodeType.FunctionArgument; }, enumerable: true, configurable: true }); FunctionArgument.prototype.setIdentifier = function (node) { return this.setNode('identifier', node, 0); }; FunctionArgument.prototype.getIdentifier = function () { return this.identifier; }; FunctionArgument.prototype.getName = function () { return this.identifier ? this.identifier.getText() : ''; }; FunctionArgument.prototype.setValue = function (node) { return this.setNode('value', node, 0); }; FunctionArgument.prototype.getValue = function () { return this.value; }; return FunctionArgument; }(Node)); exports.FunctionArgument = FunctionArgument; var IfStatement = /** @class */ (function (_super) { __extends(IfStatement, _super); function IfStatement(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(IfStatement.prototype, "type", { get: function () { return NodeType.If; }, enumerable: true, configurable: true }); IfStatement.prototype.setExpression = function (node) { return this.setNode('expression', node, 0); }; IfStatement.prototype.setElseClause = function (elseClause) { return this.setNode('elseClause', elseClause); }; return IfStatement; }(BodyDeclaration)); exports.IfStatement = IfStatement; var ForStatement = /** @class */ (function (_super) { __extends(ForStatement, _super); function ForStatement(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(ForStatement.prototype, "type", { get: function () { return NodeType.For; }, enumerable: true, configurable: true }); ForStatement.prototype.setVariable = function (node) { return this.setNode('variable', node, 0); }; return ForStatement; }(BodyDeclaration)); exports.ForStatement = ForStatement; var EachStatement = /** @class */ (function (_super) { __extends(EachStatement, _super); function EachStatement(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(EachStatement.prototype, "type", { get: function () { return NodeType.Each; }, enumerable: true, configurable: true }); EachStatement.prototype.getVariables = function () { if (!this.variables) { this.variables = new Nodelist(this); } return this.variables; }; return EachStatement; }(BodyDeclaration)); exports.EachStatement = EachStatement; var WhileStatement = /** @class */ (function (_super) { __extends(WhileStatement, _super); function WhileStatement(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(WhileStatement.prototype, "type", { get: function () { return NodeType.While; }, enumerable: true, configurable: true }); return WhileStatement; }(BodyDeclaration)); exports.WhileStatement = WhileStatement; var ElseStatement = /** @class */ (function (_super) { __extends(ElseStatement, _super); function ElseStatement(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(ElseStatement.prototype, "type", { get: function () { return NodeType.Else; }, enumerable: true, configurable: true }); return ElseStatement; }(BodyDeclaration)); exports.ElseStatement = ElseStatement; var FunctionDeclaration = /** @class */ (function (_super) { __extends(FunctionDeclaration, _super); function FunctionDeclaration(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(FunctionDeclaration.prototype, "type", { get: function () { return NodeType.FunctionDeclaration; }, enumerable: true, configurable: true }); FunctionDeclaration.prototype.setIdentifier = function (node) { return this.setNode('identifier', node, 0); }; FunctionDeclaration.prototype.getIdentifier = function () { return this.identifier; }; FunctionDeclaration.prototype.getName = function () { return this.identifier ? this.identifier.getText() : ''; }; FunctionDeclaration.prototype.getParameters = function () { if (!this.parameters) { this.parameters = new Nodelist(this); } return this.parameters; }; return FunctionDeclaration; }(BodyDeclaration)); exports.FunctionDeclaration = FunctionDeclaration; var ViewPort = /** @class */ (function (_super) { __extends(ViewPort, _super); function ViewPort(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(ViewPort.prototype, "type", { get: function () { return NodeType.ViewPort; }, enumerable: true, configurable: true }); return ViewPort; }(BodyDeclaration)); exports.ViewPort = ViewPort; var FontFace = /** @class */ (function (_super) { __extends(FontFace, _super); function FontFace(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(FontFace.prototype, "type", { get: function () { return NodeType.FontFace; }, enumerable: true, configurable: true }); return FontFace; }(BodyDeclaration)); exports.FontFace = FontFace; var NestedProperties = /** @class */ (function (_super) { __extends(NestedProperties, _super); function NestedProperties(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(NestedProperties.prototype, "type", { get: function () { return NodeType.NestedProperties; }, enumerable: true, configurable: true }); return NestedProperties; }(BodyDeclaration)); exports.NestedProperties = NestedProperties; var Keyframe = /** @class */ (function (_super) { __extends(Keyframe, _super); function Keyframe(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(Keyframe.prototype, "type", { get: function () { return NodeType.Keyframe; }, enumerable: true, configurable: true }); Keyframe.prototype.setKeyword = function (keyword) { return this.setNode('keyword', keyword, 0); }; Keyframe.prototype.getKeyword = function () { return this.keyword; }; Keyframe.prototype.setIdentifier = function (node) { return this.setNode('identifier', node, 0); }; Keyframe.prototype.getIdentifier = function () { return this.identifier; }; Keyframe.prototype.getName = function () { return this.identifier ? this.identifier.getText() : ''; }; return Keyframe; }(BodyDeclaration)); exports.Keyframe = Keyframe; var KeyframeSelector = /** @class */ (function (_super) { __extends(KeyframeSelector, _super); function KeyframeSelector(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(KeyframeSelector.prototype, "type", { get: function () { return NodeType.KeyframeSelector; }, enumerable: true, configurable: true }); return KeyframeSelector; }(BodyDeclaration)); exports.KeyframeSelector = KeyframeSelector; var Import = /** @class */ (function (_super) { __extends(Import, _super); function Import(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(Import.prototype, "type", { get: function () { return NodeType.Import; }, enumerable: true, configurable: true }); Import.prototype.setMedialist = function (node) { if (node) { node.attachTo(this); return true; } return false; }; return Import; }(Node)); exports.Import = Import; var Use = /** @class */ (function (_super) { __extends(Use, _super); function Use() { return _super !== null && _super.apply(this, arguments) || this; } Object.defineProperty(Use.prototype, "type", { get: function () { return NodeType.Use; }, enumerable: true, configurable: true }); Use.prototype.getParameters = function () { if (!this.parameters) { this.parameters = new Nodelist(this); } return this.parameters; }; Use.prototype.setIdentifier = function (node) { return this.setNode('identifier', node, 0); }; Use.prototype.getIdentifier = function () { return this.identifier; }; return Use; }(Node)); exports.Use = Use; var ModuleConfiguration = /** @class */ (function (_super) { __extends(ModuleConfiguration, _super); function ModuleConfiguration() { return _super !== null && _super.apply(this, arguments) || this; } Object.defineProperty(ModuleConfiguration.prototype, "type", { get: function () { return NodeType.ModuleConfiguration; }, enumerable: true, configurable: true }); ModuleConfiguration.prototype.setIdentifier = function (node) { return this.setNode('identifier', node, 0); }; ModuleConfiguration.prototype.getIdentifier = function () { return this.identifier; }; ModuleConfiguration.prototype.getName = function () { return this.identifier ? this.identifier.getText() : ''; }; ModuleConfiguration.prototype.setValue = function (node) { return this.setNode('value', node, 0); }; ModuleConfiguration.prototype.getValue = function () { return this.value; }; return ModuleConfiguration; }(Node)); exports.ModuleConfiguration = ModuleConfiguration; var Forward = /** @class */ (function (_super) { __extends(Forward, _super); function Forward() { return _super !== null && _super.apply(this, arguments) || this; } Object.defineProperty(Forward.prototype, "type", { get: function () { return NodeType.Forward; }, enumerable: true, configurable: true }); Forward.prototype.setIdentifier = function (node) { return this.setNode('identifier', node, 0); }; Forward.prototype.getIdentifier = function () { return this.identifier; }; return Forward; }(Node)); exports.Forward = Forward; var ForwardVisibility = /** @class */ (function (_super) { __extends(ForwardVisibility, _super); function ForwardVisibility() { return _super !== null && _super.apply(this, arguments) || this; } Object.defineProperty(ForwardVisibility.prototype, "type", { get: function () { return NodeType.ForwardVisibility; }, enumerable: true, configurable: true }); ForwardVisibility.prototype.setIdentifier = function (node) { return this.setNode('identifier', node, 0); }; ForwardVisibility.prototype.getIdentifier = function () { return this.identifier; }; return ForwardVisibility; }(Node)); exports.ForwardVisibility = ForwardVisibility; var Namespace = /** @class */ (function (_super) { __extends(Namespace, _super); function Namespace(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(Namespace.prototype, "type", { get: function () { return NodeType.Namespace; }, enumerable: true, configurable: true }); return Namespace; }(Node)); exports.Namespace = Namespace; var Media = /** @class */ (function (_super) { __extends(Media, _super); function Media(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(Media.prototype, "type", { get: function () { return NodeType.Media; }, enumerable: true, configurable: true }); return Media; }(BodyDeclaration)); exports.Media = Media; var Supports = /** @class */ (function (_super) { __extends(Supports, _super); function Supports(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(Supports.prototype, "type", { get: function () { return NodeType.Supports; }, enumerable: true, configurable: true }); return Supports; }(BodyDeclaration)); exports.Supports = Supports; var Document = /** @class */ (function (_super) { __extends(Document, _super); function Document(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(Document.prototype, "type", { get: function () { return NodeType.Document; }, enumerable: true, configurable: true }); return Document; }(BodyDeclaration)); exports.Document = Document; var Medialist = /** @class */ (function (_super) { __extends(Medialist, _super); function Medialist(offset, length) { return _super.call(this, offset, length) || this; } Medialist.prototype.getMediums = function () { if (!this.mediums) { this.mediums = new Nodelist(this); } return this.mediums; }; return Medialist; }(Node)); exports.Medialist = Medialist; var MediaQuery = /** @class */ (function (_super) { __extends(MediaQuery, _super); function MediaQuery(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(MediaQuery.prototype, "type", { get: function () { return NodeType.MediaQuery; }, enumerable: true, configurable: true }); return MediaQuery; }(Node)); exports.MediaQuery = MediaQuery; var SupportsCondition = /** @class */ (function (_super) { __extends(SupportsCondition, _super); function SupportsCondition(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(SupportsCondition.prototype, "type", { get: function () { return NodeType.SupportsCondition; }, enumerable: true, configurable: true }); return SupportsCondition; }(Node)); exports.SupportsCondition = SupportsCondition; var Page = /** @class */ (function (_super) { __extends(Page, _super); function Page(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(Page.prototype, "type", { get: function () { return NodeType.Page; }, enumerable: true, configurable: true }); return Page; }(BodyDeclaration)); exports.Page = Page; var PageBoxMarginBox = /** @class */ (function (_super) { __extends(PageBoxMarginBox, _super); function PageBoxMarginBox(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(PageBoxMarginBox.prototype, "type", { get: function () { return NodeType.PageBoxMarginBox; }, enumerable: true, configurable: true }); return PageBoxMarginBox; }(BodyDeclaration)); exports.PageBoxMarginBox = PageBoxMarginBox; var Expression = /** @class */ (function (_super) { __extends(Expression, _super); function Expression(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(Expression.prototype, "type", { get: function () { return NodeType.Expression; }, enumerable: true, configurable: true }); return Expression; }(Node)); exports.Expression = Expression; var BinaryExpression = /** @class */ (function (_super) { __extends(BinaryExpression, _super); function BinaryExpression(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(BinaryExpression.prototype, "type", { get: function () { return NodeType.BinaryExpression; }, enumerable: true, configurable: true }); BinaryExpression.prototype.setLeft = function (left) { return this.setNode('left', left); }; BinaryExpression.prototype.getLeft = function () { return this.left; }; BinaryExpression.prototype.setRight = function (right) { return this.setNode('right', right); }; BinaryExpression.prototype.getRight = function () { return this.right; }; BinaryExpression.prototype.setOperator = function (value) { return this.setNode('operator', value); }; BinaryExpression.prototype.getOperator = function () { return this.operator; }; return BinaryExpression; }(Node)); exports.BinaryExpression = BinaryExpression; var Term = /** @class */ (function (_super) { __extends(Term, _super); function Term(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(Term.prototype, "type", { get: function () { return NodeType.Term; }, enumerable: true, configurable: true }); Term.prototype.setOperator = function (value) { return this.setNode('operator', value); }; Term.prototype.getOperator = function () { return this.operator; }; Term.prototype.setExpression = function (value) { return this.setNode('expression', value); }; Term.prototype.getExpression = function () { return this.expression; }; return Term; }(Node)); exports.Term = Term; var AttributeSelector = /** @class */ (function (_super) { __extends(AttributeSelector, _super); function AttributeSelector(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(AttributeSelector.prototype, "type", { get: function () { return NodeType.AttributeSelector; }, enumerable: true, configurable: true }); AttributeSelector.prototype.setNamespacePrefix = function (value) { return this.setNode('namespacePrefix', value); }; AttributeSelector.prototype.getNamespacePrefix = function () { return this.namespacePrefix; }; AttributeSelector.prototype.setIdentifier = function (value) { return this.setNode('identifier', value); }; AttributeSelector.prototype.getIdentifier = function () { return this.identifier; }; AttributeSelector.prototype.setOperator = function (operator) { return this.setNode('operator', operator); }; AttributeSelector.prototype.getOperator = function () { return this.operator; }; AttributeSelector.prototype.setValue = function (value) { return this.setNode('value', value); }; AttributeSelector.prototype.getValue = function () { return this.value; }; return AttributeSelector; }(Node)); exports.AttributeSelector = AttributeSelector; var Operator = /** @class */ (function (_super) { __extends(Operator, _super); function Operator(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(Operator.prototype, "type", { get: function () { return NodeType.Operator; }, enumerable: true, configurable: true }); return Operator; }(Node)); exports.Operator = Operator; var HexColorValue = /** @class */ (function (_super) { __extends(HexColorValue, _super); function HexColorValue(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(HexColorValue.prototype, "type", { get: function () { return NodeType.HexColorValue; }, enumerable: true, configurable: true }); return HexColorValue; }(Node)); exports.HexColorValue = HexColorValue; var _dot = '.'.charCodeAt(0), _0 = '0'.charCodeAt(0), _9 = '9'.charCodeAt(0); var NumericValue = /** @class */ (function (_super) { __extends(NumericValue, _super); function NumericValue(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(NumericValue.prototype, "type", { get: function () { return NodeType.NumericValue; }, enumerable: true, configurable: true }); NumericValue.prototype.getValue = function () { var raw = this.getText(); var unitIdx = 0; var code; for (var i = 0, len = raw.length; i < len; i++) { code = raw.charCodeAt(i); if (!(_0 <= code && code <= _9 || code === _dot)) { break; } unitIdx += 1; } return { value: raw.substring(0, unitIdx), unit: unitIdx < raw.length ? raw.substring(unitIdx) : undefined }; }; return NumericValue; }(Node)); exports.NumericValue = NumericValue; var VariableDeclaration = /** @class */ (function (_super) { __extends(VariableDeclaration, _super); function VariableDeclaration(offset, length) { var _this = _super.call(this, offset, length) || this; _this.variable = null; _this.value = null; _this.needsSemicolon = true; return _this; } Object.defineProperty(VariableDeclaration.prototype, "type", { get: function () { return NodeType.VariableDeclaration; }, enumerable: true, configurable: true }); VariableDeclaration.prototype.setVariable = function (node) { if (node) { node.attachTo(this); this.variable = node; return true; } return false; }; VariableDeclaration.prototype.getVariable = function () { return this.variable; }; VariableDeclaration.prototype.getName = function () { return this.variable ? this.variable.getName() : ''; }; VariableDeclaration.prototype.setValue = function (node) { if (node) { node.attachTo(this); this.value = node; return true; } return false; }; VariableDeclaration.prototype.getValue = function () { return this.value; }; return VariableDeclaration; }(AbstractDeclaration)); exports.VariableDeclaration = VariableDeclaration; var Interpolation = /** @class */ (function (_super) { __extends(Interpolation, _super); // private _interpolations: void; // workaround for https://github.com/Microsoft/TypeScript/issues/18276 function Interpolation(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(Interpolation.prototype, "type", { get: function () { return NodeType.Interpolation; }, enumerable: true, configurable: true }); return Interpolation; }(Node)); exports.Interpolation = Interpolation; var Variable = /** @class */ (function (_super) { __extends(Variable, _super); function Variable(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(Variable.prototype, "type", { get: function () { return NodeType.VariableName; }, enumerable: true, configurable: true }); Variable.prototype.getName = function () { return this.getText(); }; return Variable; }(Node)); exports.Variable = Variable; var ExtendsReference = /** @class */ (function (_super) { __extends(ExtendsReference, _super); function ExtendsReference(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(ExtendsReference.prototype, "type", { get: function () { return NodeType.ExtendsReference; }, enumerable: true, configurable: true }); ExtendsReference.prototype.getSelectors = function () { if (!this.selectors) { this.selectors = new Nodelist(this); } return this.selectors; }; return ExtendsReference; }(Node)); exports.ExtendsReference = ExtendsReference; var MixinReference = /** @class */ (function (_super) { __extends(MixinReference, _super); function MixinReference(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(MixinReference.prototype, "type", { get: function () { return NodeType.MixinReference; }, enumerable: true, configurable: true }); MixinReference.prototype.getNamespaces = function () { if (!this.namespaces) { this.namespaces = new Nodelist(this); } return this.namespaces; }; MixinReference.prototype.setIdentifier = function (node) { return this.setNode('identifier', node, 0); }; MixinReference.prototype.getIdentifier = function () { return this.identifier; }; MixinReference.prototype.getName = function () { return this.identifier ? this.identifier.getText() : ''; }; MixinReference.prototype.getArguments = function () { if (!this.arguments) { this.arguments = new Nodelist(this); } return this.arguments; }; MixinReference.prototype.setContent = function (node) { return this.setNode('content', node); }; MixinReference.prototype.getContent = function () { return this.content; }; return MixinReference; }(Node)); exports.MixinReference = MixinReference; var MixinDeclaration = /** @class */ (function (_super) { __extends(MixinDeclaration, _super); function MixinDeclaration(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(MixinDeclaration.prototype, "type", { get: function () { return NodeType.MixinDeclaration; }, enumerable: true, configurable: true }); MixinDeclaration.prototype.setIdentifier = function (node) { return this.setNode('identifier', node, 0); }; MixinDeclaration.prototype.getIdentifier = function () { return this.identifier; }; MixinDeclaration.prototype.getName = function () { return this.identifier ? this.identifier.getText() : ''; }; MixinDeclaration.prototype.getParameters = function () { if (!this.parameters) { this.parameters = new Nodelist(this); } return this.parameters; }; MixinDeclaration.prototype.setGuard = function (node) { if (node) { node.attachTo(this); this.guard = node; } return false; }; return MixinDeclaration; }(BodyDeclaration)); exports.MixinDeclaration = MixinDeclaration; var UnknownAtRule = /** @class */ (function (_super) { __extends(UnknownAtRule, _super); function UnknownAtRule(offset, length) { return _super.call(this, offset, length) || this; } Object.defineProperty(UnknownAtRule.prototype, "type", { get: function () { return NodeType.UnknownAtRule; }, enumerable: true, configurable: true }); UnknownAtRule.prototype.setAtRuleName = function (atRuleName) { this.atRuleName = atRuleName; }; UnknownAtRule.prototype.getAtRuleName = function () { return this.atRuleName; }; return UnknownAtRule; }(BodyDeclaration)); exports.UnknownAtRule = UnknownAtRule; var ListEntry = /** @class */ (function (_super) { __extends(ListEntry, _super); function ListEntry() { return _super !== null && _super.apply(this, arguments) || this; } Object.defineProperty(ListEntry.prototype, "type", { get: function () { return NodeType.ListEntry; }, enumerable: true, configurable: true }); ListEntry.prototype.setKey = function (node) { return this.setNode('key', node, 0); }; ListEntry.prototype.setValue = function (node) { return this.setNode('value', node, 1); }; return ListEntry; }(Node)); exports.ListEntry = ListEntry; var LessGuard = /** @class */ (function (_super) { __extends(LessGuard, _super); function LessGuard() { return _super !== null && _super.apply(this, arguments) || this; } LessGuard.prototype.getConditions = function () { if (!this.conditions) { this.conditions = new Nodelist(this); } return this.conditions; }; return LessGuard; }(Node)); exports.LessGuard = LessGuard; var GuardCondition = /** @class */ (function (_super) { __extends(GuardCondition, _super); function GuardCondition() { return _super !== null && _super.apply(this, arguments) || this; } GuardCondition.prototype.setVariable = function (node) { return this.setNode('variable', node); }; return GuardCondition; }(Node)); exports.GuardCondition = GuardCondition; var Module = /** @class */ (function (_super) { __extends(Module, _super); function Module() { return _super !== null && _super.apply(this, arguments) || this; } Object.defineProperty(Module.prototype, "type", { get: function () { return NodeType.Module; }, enumerable: true, configurable: true }); Module.prototype.setIdentifier = function (node) { return this.setNode('identifier', node, 0); }; Module.prototype.getIdentifier = function () { return this.identifier; }; return Module; }(Node)); exports.Module = Module; var Level; (function (Level) { Level[Level["Ignore"] = 1] = "Ignore"; Level[Level["Warning"] = 2] = "Warning"; Level[Level["Error"] = 4] = "Error"; })(Level = exports.Level || (exports.Level = {})); var Marker = /** @class */ (function () { function Marker(node, rule, level, message, offset, length) { if (offset === void 0) { offset = node.offset; } if (length === void 0) { length = node.length; } this.node = node; this.rule = rule; this.level = level; this.message = message || rule.message; this.offset = offset; this.length = length; } Marker.prototype.getRule = function () { return this.rule; }; Marker.prototype.getLevel = function () { return this.level; }; Marker.prototype.getOffset = function () { return this.offset; }; Marker.prototype.getLength = function () { return this.length; }; Marker.prototype.getNode = function () { return this.node; }; Marker.prototype.getMessage = function () { return this.message; }; return Marker; }()); exports.Marker = Marker; /* export class DefaultVisitor implements IVisitor { public visitNode(node:Node):boolean { switch (node.type) { case NodeType.Stylesheet: return this.visitStylesheet( node); case NodeType.FontFace: return this.visitFontFace( node); case NodeType.Ruleset: return this.visitRuleSet( node); case NodeType.Selector: return this.visitSelector( node); case NodeType.SimpleSelector: return this.visitSimpleSelector( node); case NodeType.Declaration: return this.visitDeclaration( node); case NodeType.Function: return this.visitFunction( node); case NodeType.FunctionDeclaration: return this.visitFunctionDeclaration( node); case NodeType.FunctionParameter: return this.visitFunctionParameter( node); case NodeType.FunctionArgument: return this.visitFunctionArgument( node); case NodeType.Term: return this.visitTerm( node); case NodeType.Declaration: return this.visitExpression( node); case NodeType.NumericValue: return this.visitNumericValue( node); case NodeType.Page: return this.visitPage( node); case NodeType.PageBoxMarginBox: return this.visitPageBoxMarginBox( node); case NodeType.Property: return this.visitProperty( node); case NodeType.NumericValue: return this.visitNodelist( node); case NodeType.Import: return this.visitImport( node); case NodeType.Namespace: return this.visitNamespace( node); case NodeType.Keyframe: return this.visitKeyframe( node); case NodeType.KeyframeSelector: return this.visitKeyframeSelector( node); case NodeType.MixinDeclaration: return this.visitMixinDeclaration( node); case NodeType.MixinReference: return this.visitMixinReference( node); case NodeType.Variable: return this.visitVariable( node); case NodeType.VariableDeclaration: return this.visitVariableDeclaration( node); } return this.visitUnknownNode(node); } public visitFontFace(node:FontFace):boolean { return true; } public visitKeyframe(node:Keyframe):boolean { return true; } public visitKeyframeSelector(node:KeyframeSelector):boolean { return true; } public visitStylesheet(node:Stylesheet):boolean { return true; } public visitProperty(Node:Property):boolean { return true; } public visitRuleSet(node:RuleSet):boolean { return true; } public visitSelector(node:Selector):boolean { return true; } public visitSimpleSelector(node:SimpleSelector):boolean { return true; } public visitDeclaration(node:Declaration):boolean { return true; } public visitFunction(node:Function):boolean { return true; } public visitFunctionDeclaration(node:FunctionDeclaration):boolean { return true; } public visitInvocation(node:Invocation):boolean { return true; } public visitTerm(node:Term):boolean { return true; } public visitImport(node:Import):boolean { return true; } public visitNamespace(node:Namespace):boolean { return true; } public visitExpression(node:Expression):boolean { return true; } public visitNumericValue(node:NumericValue):boolean { return true; } public visitPage(node:Page):boolean { return true; } public visitPageBoxMarginBox(node:PageBoxMarginBox):boolean { return true; } public visitNodelist(node:Nodelist):boolean { return true; } public visitVariableDeclaration(node:VariableDeclaration):boolean { return true; } public visitVariable(node:Variable):boolean { return true; } public visitMixinDeclaration(node:MixinDeclaration):boolean { return true; } public visitMixinReference(node:MixinReference):boolean { return true; } public visitUnknownNode(node:Node):boolean { return true; } } */ var ParseErrorCollector = /** @class */ (function () { function ParseErrorCollector() { this.entries = []; } ParseErrorCollector.entries = function (node) { var visitor = new ParseErrorCollector(); node.acceptVisitor(visitor); return visitor.entries; }; ParseErrorCollector.prototype.visitNode = function (node) { if (node.isErroneous()) { node.collectIssues(this.entries); } return true; }; return ParseErrorCollector; }()); exports.ParseErrorCollector = ParseErrorCollector; }); /*--------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ define('vscode-nls/vscode-nls',["require", "exports"], function (require, exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); function format(message, args) { var result; if (args.length === 0) { result = message; } else { result = message.replace(/\{(\d+)\}/g, function (match, rest) { var index = rest[0]; return typeof args[index] !== 'undefined' ? args[index] : match; }); } return result; } function localize(key, message) { var args = []; for (var _i = 2; _i < arguments.length; _i++) { args[_i - 2] = arguments[_i]; } return format(message, args); } function loadMessageBundle(file) { return localize; } exports.loadMessageBundle = loadMessageBundle; function config(opt) { return loadMessageBundle; } exports.config = config; }); define('vscode-nls', ['vscode-nls/vscode-nls'], function (main) { return main; }); (function (factory) { if (typeof module === "object" && typeof module.exports === "object") { var v = factory(require, exports); if (v !== undefined) module.exports = v; } else if (typeof define === "function" && define.amd) { define('vscode-css-languageservice/parser/cssErrors',["require", "exports", "vscode-nls"], factory); } })(function (require, exports) { /*--------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); var nls = require("vscode-nls"); var localize = nls.loadMessageBundle(); var CSSIssueType = /** @class */ (function () { function CSSIssueType(id, message) { this.id = id; this.message = message; } return CSSIssueType; }()); exports.CSSIssueType = CSSIssueType; exports.ParseError = { NumberExpected: new CSSIssueType('css-numberexpected', localize('expected.number', "number expected")), ConditionExpected: new CSSIssueType('css-conditionexpected', localize('expected.condt', "condition expected")), RuleOrSelectorExpected: new CSSIssueType('css-ruleorselectorexpected', localize('expected.ruleorselector', "at-rule or selector expected")), DotExpected: new CSSIssueType('css-dotexpected', localize('expected.dot', "dot expected")), ColonExpected: new CSSIssueType('css-colonexpected', localize('expected.colon', "colon expected")), SemiColonExpected: new CSSIssueType('css-semicolonexpected', localize('expected.semicolon', "semi-colon expected")), TermExpected: new CSSIssueType('css-termexpected', localize('expected.term', "term expected")), ExpressionExpected: new CSSIssueType('css-expressionexpected', localize('expected.expression', "expression expected")), OperatorExpected: new CSSIssueType('css-operatorexpected', localize('expected.operator', "operator expected")), IdentifierExpected: new CSSIssueType('css-identifierexpected', localize('expected.ident', "identifier expected")), PercentageExpected: new CSSIssueType('css-percentageexpected', localize('expected.percentage', "percentage expected")), URIOrStringExpected: new CSSIssueType('css-uriorstringexpected', localize('expected.uriorstring', "uri or string expected")), URIExpected: new CSSIssueType('css-uriexpected', localize('expected.uri', "URI expected")), VariableNameExpected: new CSSIssueType('css-varnameexpected', localize('expected.varname', "variable name expected")), VariableValueExpected: new CSSIssueType('css-varvalueexpected', localize('expected.varvalue', "variable value expected")), PropertyValueExpected: new CSSIssueType('css-propertyvalueexpected', localize('expected.propvalue', "property value expected")), LeftCurlyExpected: new CSSIssueType('css-lcurlyexpected', localize('expected.lcurly', "{ expected")), RightCurlyExpected: new CSSIssueType('css-rcurlyexpected', localize('expected.rcurly', "} expected")), LeftSquareBracketExpected: new CSSIssueType('css-rbracketexpected', localize('expected.lsquare', "[ expected")), RightSquareBracketExpected: new CSSIssueType('css-lbracketexpected', localize('expected.rsquare', "] expected")), LeftParenthesisExpected: new CSSIssueType('css-lparentexpected', localize('expected.lparen', "( expected")), RightParenthesisExpected: new CSSIssueType('css-rparentexpected', localize('expected.rparent', ") expected")), CommaExpected: new CSSIssueType('css-commaexpected', localize('expected.comma', "comma expected")), PageDirectiveOrDeclarationExpected: new CSSIssueType('css-pagedirordeclexpected', localize('expected.pagedirordecl', "page directive or declaraton expected")), UnknownAtRule: new CSSIssueType('css-unknownatrule', localize('unknown.atrule', "at-rule unknown")), UnknownKeyword: new CSSIssueType('css-unknownkeyword', localize('unknown.keyword', "unknown keyword")), SelectorExpected: new CSSIssueType('css-selectorexpected', localize('expected.selector', "selector expected")), StringLiteralExpected: new CSSIssueType('css-stringliteralexpected', localize('expected.stringliteral', "string literal expected")), WhitespaceExpected: new CSSIssueType('css-whitespaceexpected', localize('expected.whitespace', "whitespace expected")), MediaQueryExpected: new CSSIssueType('css-mediaqueryexpected', localize('expected.mediaquery', "media query expected")), IdentifierOrWildcardExpected: new CSSIssueType('css-idorwildcardexpected', localize('expected.idorwildcard', "identifier or wildcard expected")), WildcardExpected: new CSSIssueType('css-wildcardexpected', localize('expected.wildcard', "wildcard expected")), IdentifierOrVariableExpected: new CSSIssueType('css-idorvarexpected', localize('expected.idorvar', "identifier or variable expected")), }; }); /*--------------------------------------------------------------------------------------------- * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ // file generated from vscode-web-custom-data NPM package (function (factory) { if (typeof module === "object" && typeof module.exports === "object") { var v = factory(require, exports); if (v !== undefined) module.exports = v; } else if (typeof define === "function" && define.amd) { define('vscode-css-languageservice/data/webCustomData',["require", "exports"], factory); } })(function (require, exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.cssData = { "version": 1.1, "properties": [ { "name": "width", "values": [ { "name": "auto", "description": "The width depends on the values of other properties." }, { "name": "fit-content", "description": "Use the fit-content inline size or fit-content block size, as appropriate to the writing mode." }, { "name": "max-content", "description": "Use the max-content inline size or max-content block size, as appropriate to the writing mode." }, { "name": "min-content", "description": "Use the min-content inline size or min-content block size, as appropriate to the writing mode." } ], "syntax": "{1,2}", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/width" } ], "description": "Specifies the width of the content area, padding area or border area (depending on 'box-sizing') of certain boxes.", "restrictions": [ "length", "percentage" ] }, { "name": "height", "values": [ { "name": "auto", "description": "The height depends on the values of other properties." }, { "name": "fit-content", "description": "Use the fit-content inline size or fit-content block size, as appropriate to the writing mode." }, { "name": "max-content", "description": "Use the max-content inline size or max-content block size, as appropriate to the writing mode." }, { "name": "min-content", "description": "Use the min-content inline size or min-content block size, as appropriate to the writing mode." } ], "syntax": "{1,2}", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/height" } ], "description": "Specifies the height of the content area, padding area or border area (depending on 'box-sizing') of certain boxes.", "restrictions": [ "length", "percentage" ] }, { "name": "display", "values": [ { "name": "block", "description": "The element generates a block-level box" }, { "name": "contents", "description": "The element itself does not generate any boxes, but its children and pseudo-elements still generate boxes as normal." }, { "name": "flex", "description": "The element generates a principal flex container box and establishes a flex formatting context." }, { "name": "flexbox", "description": "The element lays out its contents using flow layout (block-and-inline layout). Standardized as 'flex'." }, { "name": "flow-root", "description": "The element generates a block container box, and lays out its contents using flow layout." }, { "name": "grid", "description": "The element generates a principal grid container box, and establishes a grid formatting context." }, { "name": "inline", "description": "The element generates an inline-level box." }, { "name": "inline-block", "description": "A block box, which itself is flowed as a single inline box, similar to a replaced element. The inside of an inline-block is formatted as a block box, and the box itself is formatted as an inline box." }, { "name": "inline-flex", "description": "Inline-level flex container." }, { "name": "inline-flexbox", "description": "Inline-level flex container. Standardized as 'inline-flex'" }, { "name": "inline-table", "description": "Inline-level table wrapper box containing table box." }, { "name": "list-item", "description": "One or more block boxes and one marker box." }, { "name": "-moz-box", "description": "The element lays out its contents using flow layout (block-and-inline layout). Standardized as 'flex'." }, { "name": "-moz-deck" }, { "name": "-moz-grid" }, { "name": "-moz-grid-group" }, { "name": "-moz-grid-line" }, { "name": "-moz-groupbox" }, { "name": "-moz-inline-box", "description": "Inline-level flex container. Standardized as 'inline-flex'" }, { "name": "-moz-inline-grid" }, { "name": "-moz-inline-stack" }, { "name": "-moz-marker" }, { "name": "-moz-popup" }, { "name": "-moz-stack" }, { "name": "-ms-flexbox", "description": "The element lays out its contents using flow layout (block-and-inline layout). Standardized as 'flex'." }, { "name": "-ms-grid", "description": "The element generates a principal grid container box, and establishes a grid formatting context." }, { "name": "-ms-inline-flexbox", "description": "Inline-level flex container. Standardized as 'inline-flex'" }, { "name": "-ms-inline-grid", "description": "Inline-level grid container." }, { "name": "none", "description": "The element and its descendants generates no boxes." }, { "name": "ruby", "description": "The element generates a principal ruby container box, and establishes a ruby formatting context." }, { "name": "ruby-base" }, { "name": "ruby-base-container" }, { "name": "ruby-text" }, { "name": "ruby-text-container" }, { "name": "run-in", "description": "The element generates a run-in box. Run-in elements act like inlines or blocks, depending on the surrounding elements." }, { "name": "table", "description": "The element generates a principal table wrapper box containing an additionally-generated table box, and establishes a table formatting context." }, { "name": "table-caption" }, { "name": "table-cell" }, { "name": "table-column" }, { "name": "table-column-group" }, { "name": "table-footer-group" }, { "name": "table-header-group" }, { "name": "table-row" }, { "name": "table-row-group" }, { "name": "-webkit-box", "description": "The element lays out its contents using flow layout (block-and-inline layout). Standardized as 'flex'." }, { "name": "-webkit-flex", "description": "The element lays out its contents using flow layout (block-and-inline layout)." }, { "name": "-webkit-inline-box", "description": "Inline-level flex container. Standardized as 'inline-flex'" }, { "name": "-webkit-inline-flex", "description": "Inline-level flex container." } ], "syntax": "[ || ] | | | | ", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/display" } ], "description": "In combination with 'float' and 'position', determines the type of box or boxes that are generated for an element.", "restrictions": [ "enum" ] }, { "name": "padding", "values": [], "syntax": "[ | ]{1,4}", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/padding" } ], "description": "Shorthand property to set values the thickness of the padding area. If left is omitted, it is the same as right. If bottom is omitted it is the same as top, if right is omitted it is the same as top. The value may not be negative.", "restrictions": [ "length", "percentage" ] }, { "name": "position", "values": [ { "name": "absolute", "description": "The box's position (and possibly size) is specified with the 'top', 'right', 'bottom', and 'left' properties. These properties specify offsets with respect to the box's 'containing block'." }, { "name": "fixed", "description": "The box's position is calculated according to the 'absolute' model, but in addition, the box is fixed with respect to some reference. As with the 'absolute' model, the box's margins do not collapse with any other margins." }, { "name": "-ms-page", "description": "The box's position is calculated according to the 'absolute' model." }, { "name": "relative", "description": "The box's position is calculated according to the normal flow (this is called the position in normal flow). Then the box is offset relative to its normal position." }, { "name": "static", "description": "The box is a normal box, laid out according to the normal flow. The 'top', 'right', 'bottom', and 'left' properties do not apply." }, { "name": "sticky", "description": "The box's position is calculated according to the normal flow. Then the box is offset relative to its flow root and containing block and in all cases, including table elements, does not affect the position of any following boxes." }, { "name": "-webkit-sticky", "description": "The box's position is calculated according to the normal flow. Then the box is offset relative to its flow root and containing block and in all cases, including table elements, does not affect the position of any following boxes." } ], "syntax": "static | relative | absolute | sticky | fixed", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/position" } ], "restrictions": [ "enum" ] }, { "name": "border", "syntax": " || || ", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/border" } ], "description": "Shorthand property for setting border width, style, and color.", "restrictions": [ "length", "line-width", "line-style", "color" ] }, { "name": "margin", "values": [ { "name": "auto" } ], "syntax": "[ | | auto ]{1,4}", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/margin" } ], "description": "Shorthand property to set values the thickness of the margin area. If left is omitted, it is the same as right. If bottom is omitted it is the same as top, if right is omitted it is the same as top. Negative values for margin properties are allowed, but there may be implementation-specific limits.", "restrictions": [ "length", "percentage" ] }, { "name": "top", "values": [ { "name": "auto", "description": "For non-replaced elements, the effect of this value depends on which of related properties have the value 'auto' as well" } ], "syntax": " | | auto", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/top" } ], "description": "Specifies how far an absolutely positioned box's top margin edge is offset below the top edge of the box's 'containing block'.", "restrictions": [ "length", "percentage" ] }, { "name": "left", "values": [ { "name": "auto", "description": "For non-replaced elements, the effect of this value depends on which of related properties have the value 'auto' as well" } ], "syntax": " | | auto", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/left" } ], "description": "Specifies how far an absolutely positioned box's left margin edge is offset to the right of the left edge of the box's 'containing block'.", "restrictions": [ "length", "percentage" ] }, { "name": "margin-top", "values": [ { "name": "auto" } ], "syntax": " | | auto", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/margin-top" } ], "description": "Shorthand property to set values the thickness of the margin area. If left is omitted, it is the same as right. If bottom is omitted it is the same as top, if right is omitted it is the same as top. Negative values for margin properties are allowed, but there may be implementation-specific limits..", "restrictions": [ "length", "percentage" ] }, { "name": "color", "syntax": "", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/color" } ], "description": "Color of an element's text", "restrictions": [ "color" ] }, { "name": "font-size", "values": [ { "name": "large" }, { "name": "larger" }, { "name": "medium" }, { "name": "small" }, { "name": "smaller" }, { "name": "x-large" }, { "name": "x-small" }, { "name": "xx-large" }, { "name": "xx-small" } ], "syntax": " | | ", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/font-size" } ], "description": "Indicates the desired height of glyphs from the font. For scalable fonts, the font-size is a scale factor applied to the EM unit of the font. (Note that certain glyphs may bleed outside their EM box.) For non-scalable fonts, the font-size is converted into absolute units and matched against the declared font-size of the font, using the same absolute coordinate space for both of the matched values.", "restrictions": [ "length", "percentage" ] }, { "name": "background-color", "syntax": "", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/background-color" } ], "description": "Sets the background color of an element.", "restrictions": [ "color" ] }, { "name": "text-align", "values": [ { "name": "center", "description": "The inline contents are centered within the line box." }, { "name": "end", "description": "The inline contents are aligned to the end edge of the line box." }, { "name": "justify", "description": "The text is justified according to the method specified by the 'text-justify' property." }, { "name": "left", "description": "The inline contents are aligned to the left edge of the line box. In vertical text, 'left' aligns to the edge of the line box that would be the start edge for left-to-right text." }, { "name": "right", "description": "The inline contents are aligned to the right edge of the line box. In vertical text, 'right' aligns to the edge of the line box that would be the end edge for left-to-right text." }, { "name": "start", "description": "The inline contents are aligned to the start edge of the line box." } ], "syntax": "start | end | left | right | center | justify | match-parent", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/text-align" } ], "description": "Describes how inline contents of a block are horizontally aligned if the contents do not completely fill the line box.", "restrictions": [ "string" ] }, { "name": "opacity", "syntax": "", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/opacity" } ], "description": "Opacity of an element's text, where 1 is opaque and 0 is entirely transparent.", "restrictions": [ "number(0-1)" ] }, { "name": "background", "values": [ { "name": "fixed", "description": "The background is fixed with regard to the viewport. In paged media where there is no viewport, a 'fixed' background is fixed with respect to the page box and therefore replicated on every page." }, { "name": "local", "description": "The background is fixed with regard to the element's contents: if the element has a scrolling mechanism, the background scrolls with the element's contents." }, { "name": "none", "description": "A value of 'none' counts as an image layer but draws nothing." }, { "name": "scroll", "description": "The background is fixed with regard to the element itself and does not scroll with its contents. (It is effectively attached to the element's border.)" } ], "syntax": "[ , ]* ", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/background" } ], "description": "Shorthand property for setting most background properties at the same place in the style sheet.", "restrictions": [ "enum", "image", "color", "position", "length", "repeat", "percentage", "box" ] }, { "name": "float", "values": [ { "name": "inline-end", "description": "A keyword indicating that the element must float on the end side of its containing block. That is the right side with ltr scripts, and the left side with rtl scripts." }, { "name": "inline-start", "description": "A keyword indicating that the element must float on the start side of its containing block. That is the left side with ltr scripts, and the right side with rtl scripts." }, { "name": "left", "description": "The element generates a block box that is floated to the left. Content flows on the right side of the box, starting at the top (subject to the 'clear' property)." }, { "name": "none", "description": "The box is not floated." }, { "name": "right", "description": "Similar to 'left', except the box is floated to the right, and content flows on the left side of the box, starting at the top." } ], "syntax": "left | right | none | inline-start | inline-end", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/float" } ], "description": "Specifies how a box should be floated. It may be set for any element, but only applies to elements that generate boxes that are not absolutely positioned.", "restrictions": [ "enum" ] }, { "name": "font-weight", "values": [ { "name": "100", "description": "Thin" }, { "name": "200", "description": "Extra Light (Ultra Light)" }, { "name": "300", "description": "Light" }, { "name": "400", "description": "Normal" }, { "name": "500", "description": "Medium" }, { "name": "600", "description": "Semi Bold (Demi Bold)" }, { "name": "700", "description": "Bold" }, { "name": "800", "description": "Extra Bold (Ultra Bold)" }, { "name": "900", "description": "Black (Heavy)" }, { "name": "bold", "description": "Same as 700" }, { "name": "bolder", "description": "Specifies the weight of the face bolder than the inherited value." }, { "name": "lighter", "description": "Specifies the weight of the face lighter than the inherited value." }, { "name": "normal", "description": "Same as 400" } ], "syntax": "{1,2}", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/font-weight" } ], "description": "Specifies weight of glyphs in the font, their degree of blackness or stroke thickness.", "restrictions": [ "enum" ] }, { "name": "overflow", "values": [ { "name": "auto", "description": "The behavior of the 'auto' value is UA-dependent, but should cause a scrolling mechanism to be provided for overflowing boxes." }, { "name": "hidden", "description": "Content is clipped and no scrolling mechanism should be provided to view the content outside the clipping region." }, { "name": "-moz-hidden-unscrollable", "description": "Same as the standardized 'clip', except doesn’t establish a block formatting context." }, { "name": "scroll", "description": "Content is clipped and if the user agent uses a scrolling mechanism that is visible on the screen (such as a scroll bar or a panner), that mechanism should be displayed for a box whether or not any of its content is clipped." }, { "name": "visible", "description": "Content is not clipped, i.e., it may be rendered outside the content box." } ], "syntax": "[ visible | hidden | clip | scroll | auto ]{1,2}", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/overflow" } ], "description": "Shorthand for setting 'overflow-x' and 'overflow-y'.", "restrictions": [ "enum" ] }, { "name": "line-height", "values": [ { "name": "normal", "description": "Tells user agents to set the computed value to a 'reasonable' value based on the font size of the element." } ], "syntax": "normal | | | ", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/line-height" } ], "description": "Determines the block-progression dimension of the text content area of an inline box.", "restrictions": [ "number", "length", "percentage" ] }, { "name": "font-family", "values": [ { "name": "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif" }, { "name": "Arial, Helvetica, sans-serif" }, { "name": "Cambria, Cochin, Georgia, Times, 'Times New Roman', serif" }, { "name": "'Courier New', Courier, monospace" }, { "name": "cursive" }, { "name": "fantasy" }, { "name": "'Franklin Gothic Medium', 'Arial Narrow', Arial, sans-serif" }, { "name": "Georgia, 'Times New Roman', Times, serif" }, { "name": "'Gill Sans', 'Gill Sans MT', Calibri, 'Trebuchet MS', sans-serif" }, { "name": "Impact, Haettenschweiler, 'Arial Narrow Bold', sans-serif" }, { "name": "'Lucida Sans', 'Lucida Sans Regular', 'Lucida Grande', 'Lucida Sans Unicode', Geneva, Verdana, sans-serif" }, { "name": "monospace" }, { "name": "sans-serif" }, { "name": "'Segoe UI', Tahoma, Geneva, Verdana, sans-serif" }, { "name": "serif" }, { "name": "'Times New Roman', Times, serif" }, { "name": "'Trebuchet MS', 'Lucida Sans Unicode', 'Lucida Grande', 'Lucida Sans', Arial, sans-serif" }, { "name": "Verdana, Geneva, Tahoma, sans-serif" } ], "syntax": "", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/font-family" } ], "description": "Specifies a prioritized list of font family names or generic family names. A user agent iterates through the list of family names until it matches an available font that contains a glyph for the character to be rendered.", "restrictions": [ "font" ] }, { "name": "text-decoration", "values": [ { "name": "dashed", "description": "Produces a dashed line style." }, { "name": "dotted", "description": "Produces a dotted line." }, { "name": "double", "description": "Produces a double line." }, { "name": "line-through", "description": "Each line of text has a line through the middle." }, { "name": "none", "description": "Produces no line." }, { "name": "overline", "description": "Each line of text has a line above it." }, { "name": "solid", "description": "Produces a solid line." }, { "name": "underline", "description": "Each line of text is underlined." }, { "name": "wavy", "description": "Produces a wavy line." } ], "syntax": "<'text-decoration-line'> || <'text-decoration-style'> || <'text-decoration-color'> || <'text-decoration-thickness'>", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/text-decoration" } ], "description": "Decorations applied to font used for an element's text.", "restrictions": [ "enum", "color" ] }, { "name": "box-sizing", "values": [ { "name": "border-box", "description": "The specified width and height (and respective min/max properties) on this element determine the border box of the element." }, { "name": "content-box", "description": "Behavior of width and height as specified by CSS2.1. The specified width and height (and respective min/max properties) apply to the width and height respectively of the content box of the element." } ], "syntax": "content-box | border-box", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/box-sizing" } ], "description": "Specifies the behavior of the 'width' and 'height' properties.", "restrictions": [ "enum" ] }, { "name": "z-index", "values": [ { "name": "auto", "description": "The stack level of the generated box in the current stacking context is 0. The box does not establish a new stacking context unless it is the root element." } ], "syntax": "auto | ", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/z-index" } ], "description": "For a positioned box, the 'z-index' property specifies the stack level of the box in the current stacking context and whether the box establishes a local stacking context.", "restrictions": [ "integer" ] }, { "name": "vertical-align", "values": [ { "name": "auto", "description": "Align the dominant baseline of the parent box with the equivalent, or heuristically reconstructed, baseline of the element inline box." }, { "name": "baseline", "description": "Align the 'alphabetic' baseline of the element with the 'alphabetic' baseline of the parent element." }, { "name": "bottom", "description": "Align the after edge of the extended inline box with the after-edge of the line box." }, { "name": "middle", "description": "Align the 'middle' baseline of the inline element with the middle baseline of the parent." }, { "name": "sub", "description": "Lower the baseline of the box to the proper position for subscripts of the parent's box. (This value has no effect on the font size of the element's text.)" }, { "name": "super", "description": "Raise the baseline of the box to the proper position for superscripts of the parent's box. (This value has no effect on the font size of the element's text.)" }, { "name": "text-bottom", "description": "Align the bottom of the box with the after-edge of the parent element's font." }, { "name": "text-top", "description": "Align the top of the box with the before-edge of the parent element's font." }, { "name": "top", "description": "Align the before edge of the extended inline box with the before-edge of the line box." }, { "name": "-webkit-baseline-middle" } ], "syntax": "baseline | sub | super | text-top | text-bottom | middle | top | bottom | | ", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/vertical-align" } ], "description": "Affects the vertical positioning of the inline boxes generated by an inline-level element inside a line box.", "restrictions": [ "percentage", "length" ] }, { "name": "border-radius", "syntax": "{1,4} [ / {1,4} ]?", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/border-radius" } ], "description": "Defines the radii of the outer border edge.", "restrictions": [ "length", "percentage" ] }, { "name": "margin-left", "values": [ { "name": "auto" } ], "syntax": " | | auto", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/margin-left" } ], "description": "Shorthand property to set values the thickness of the margin area. If left is omitted, it is the same as right. If bottom is omitted it is the same as top, if right is omitted it is the same as top. Negative values for margin properties are allowed, but there may be implementation-specific limits..", "restrictions": [ "length", "percentage" ] }, { "name": "cursor", "values": [ { "name": "alias", "description": "Indicates an alias of/shortcut to something is to be created. Often rendered as an arrow with a small curved arrow next to it." }, { "name": "all-scroll", "description": "Indicates that the something can be scrolled in any direction. Often rendered as arrows pointing up, down, left, and right with a dot in the middle." }, { "name": "auto", "description": "The UA determines the cursor to display based on the current context." }, { "name": "cell", "description": "Indicates that a cell or set of cells may be selected. Often rendered as a thick plus-sign with a dot in the middle." }, { "name": "col-resize", "description": "Indicates that the item/column can be resized horizontally. Often rendered as arrows pointing left and right with a vertical bar separating them." }, { "name": "context-menu", "description": "A context menu is available for the object under the cursor. Often rendered as an arrow with a small menu-like graphic next to it." }, { "name": "copy", "description": "Indicates something is to be copied. Often rendered as an arrow with a small plus sign next to it." }, { "name": "crosshair", "description": "A simple crosshair (e.g., short line segments resembling a '+' sign). Often used to indicate a two dimensional bitmap selection mode." }, { "name": "default", "description": "The platform-dependent default cursor. Often rendered as an arrow." }, { "name": "e-resize", "description": "Indicates that east edge is to be moved." }, { "name": "ew-resize", "description": "Indicates a bidirectional east-west resize cursor." }, { "name": "grab", "description": "Indicates that something can be grabbed." }, { "name": "grabbing", "description": "Indicates that something is being grabbed." }, { "name": "help", "description": "Help is available for the object under the cursor. Often rendered as a question mark or a balloon." }, { "name": "move", "description": "Indicates something is to be moved." }, { "name": "-moz-grab", "description": "Indicates that something can be grabbed." }, { "name": "-moz-grabbing", "description": "Indicates that something is being grabbed." }, { "name": "-moz-zoom-in", "description": "Indicates that something can be zoomed (magnified) in." }, { "name": "-moz-zoom-out", "description": "Indicates that something can be zoomed (magnified) out." }, { "name": "ne-resize", "description": "Indicates that movement starts from north-east corner." }, { "name": "nesw-resize", "description": "Indicates a bidirectional north-east/south-west cursor." }, { "name": "no-drop", "description": "Indicates that the dragged item cannot be dropped at the current cursor location. Often rendered as a hand or pointer with a small circle with a line through it." }, { "name": "none", "description": "No cursor is rendered for the element." }, { "name": "not-allowed", "description": "Indicates that the requested action will not be carried out. Often rendered as a circle with a line through it." }, { "name": "n-resize", "description": "Indicates that north edge is to be moved." }, { "name": "ns-resize", "description": "Indicates a bidirectional north-south cursor." }, { "name": "nw-resize", "description": "Indicates that movement starts from north-west corner." }, { "name": "nwse-resize", "description": "Indicates a bidirectional north-west/south-east cursor." }, { "name": "pointer", "description": "The cursor is a pointer that indicates a link." }, { "name": "progress", "description": "A progress indicator. The program is performing some processing, but is different from 'wait' in that the user may still interact with the program. Often rendered as a spinning beach ball, or an arrow with a watch or hourglass." }, { "name": "row-resize", "description": "Indicates that the item/row can be resized vertically. Often rendered as arrows pointing up and down with a horizontal bar separating them." }, { "name": "se-resize", "description": "Indicates that movement starts from south-east corner." }, { "name": "s-resize", "description": "Indicates that south edge is to be moved." }, { "name": "sw-resize", "description": "Indicates that movement starts from south-west corner." }, { "name": "text", "description": "Indicates text that may be selected. Often rendered as a vertical I-beam." }, { "name": "vertical-text", "description": "Indicates vertical-text that may be selected. Often rendered as a horizontal I-beam." }, { "name": "wait", "description": "Indicates that the program is busy and the user should wait. Often rendered as a watch or hourglass." }, { "name": "-webkit-grab", "description": "Indicates that something can be grabbed." }, { "name": "-webkit-grabbing", "description": "Indicates that something is being grabbed." }, { "name": "-webkit-zoom-in", "description": "Indicates that something can be zoomed (magnified) in." }, { "name": "-webkit-zoom-out", "description": "Indicates that something can be zoomed (magnified) out." }, { "name": "w-resize", "description": "Indicates that west edge is to be moved." }, { "name": "zoom-in", "description": "Indicates that something can be zoomed (magnified) in." }, { "name": "zoom-out", "description": "Indicates that something can be zoomed (magnified) out." } ], "syntax": "[ [ [ ]? , ]* [ auto | default | none | context-menu | help | pointer | progress | wait | cell | crosshair | text | vertical-text | alias | copy | move | no-drop | not-allowed | e-resize | n-resize | ne-resize | nw-resize | s-resize | se-resize | sw-resize | w-resize | ew-resize | ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | all-scroll | zoom-in | zoom-out | grab | grabbing ] ]", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/cursor" } ], "description": "Allows control over cursor appearance in an element", "restrictions": [ "url", "number", "enum" ] }, { "name": "margin-bottom", "values": [ { "name": "auto" } ], "syntax": " | | auto", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/margin-bottom" } ], "description": "Shorthand property to set values the thickness of the margin area. If left is omitted, it is the same as right. If bottom is omitted it is the same as top, if right is omitted it is the same as top. Negative values for margin properties are allowed, but there may be implementation-specific limits..", "restrictions": [ "length", "percentage" ] }, { "name": "right", "values": [ { "name": "auto", "description": "For non-replaced elements, the effect of this value depends on which of related properties have the value 'auto' as well" } ], "syntax": " | | auto", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/right" } ], "description": "Specifies how far an absolutely positioned box's right margin edge is offset to the left of the right edge of the box's 'containing block'.", "restrictions": [ "length", "percentage" ] }, { "name": "margin-right", "values": [ { "name": "auto" } ], "syntax": " | | auto", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/margin-right" } ], "description": "Shorthand property to set values the thickness of the margin area. If left is omitted, it is the same as right. If bottom is omitted it is the same as top, if right is omitted it is the same as top. Negative values for margin properties are allowed, but there may be implementation-specific limits..", "restrictions": [ "length", "percentage" ] }, { "name": "padding-left", "syntax": " | ", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/padding-left" } ], "description": "Shorthand property to set values the thickness of the padding area. If left is omitted, it is the same as right. If bottom is omitted it is the same as top, if right is omitted it is the same as top. The value may not be negative.", "restrictions": [ "length", "percentage" ] }, { "name": "padding-top", "syntax": " | ", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/padding-top" } ], "description": "Shorthand property to set values the thickness of the padding area. If left is omitted, it is the same as right. If bottom is omitted it is the same as top, if right is omitted it is the same as top. The value may not be negative.", "restrictions": [ "length", "percentage" ] }, { "name": "max-width", "values": [ { "name": "none", "description": "No limit on the width of the box." }, { "name": "fit-content", "description": "Use the fit-content inline size or fit-content block size, as appropriate to the writing mode." }, { "name": "max-content", "description": "Use the max-content inline size or max-content block size, as appropriate to the writing mode." }, { "name": "min-content", "description": "Use the min-content inline size or min-content block size, as appropriate to the writing mode." } ], "syntax": "", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/max-width" } ], "description": "Allows authors to constrain content width to a certain range.", "restrictions": [ "length", "percentage" ] }, { "name": "bottom", "values": [ { "name": "auto", "description": "For non-replaced elements, the effect of this value depends on which of related properties have the value 'auto' as well" } ], "syntax": " | | auto", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/bottom" } ], "description": "Specifies how far an absolutely positioned box's bottom margin edge is offset above the bottom edge of the box's 'containing block'.", "restrictions": [ "length", "percentage" ] }, { "name": "background-image", "values": [ { "name": "none", "description": "Counts as an image layer but draws nothing." } ], "syntax": "#", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/background-image" } ], "description": "Sets the background image(s) of an element.", "restrictions": [ "image", "enum" ] }, { "name": "content", "values": [ { "name": "attr()", "description": "The attr(n) function returns as a string the value of attribute n for the subject of the selector." }, { "name": "counter(name)", "description": "Counters are denoted by identifiers (see the 'counter-increment' and 'counter-reset' properties)." }, { "name": "icon", "description": "The (pseudo-)element is replaced in its entirety by the resource referenced by its 'icon' property, and treated as a replaced element." }, { "name": "none", "description": "On elements, this inhibits the children of the element from being rendered as children of this element, as if the element was empty. On pseudo-elements it causes the pseudo-element to have no content." }, { "name": "normal", "description": "See http://www.w3.org/TR/css3-content/#content for computation rules." }, { "name": "url()" } ], "syntax": "normal | none | [ | ] [/ ]?", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/content" } ], "description": "Determines which page-based occurrence of a given element is applied to a counter or string value.", "restrictions": [ "string", "url" ] }, { "name": "padding-right", "syntax": " | ", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/padding-right" } ], "description": "Shorthand property to set values the thickness of the padding area. If left is omitted, it is the same as right. If bottom is omitted it is the same as top, if right is omitted it is the same as top. The value may not be negative.", "restrictions": [ "length", "percentage" ] }, { "name": "white-space", "values": [ { "name": "normal", "description": "Sets 'white-space-collapsing' to 'collapse' and 'text-wrap' to 'normal'." }, { "name": "nowrap", "description": "Sets 'white-space-collapsing' to 'collapse' and 'text-wrap' to 'none'." }, { "name": "pre", "description": "Sets 'white-space-collapsing' to 'preserve' and 'text-wrap' to 'none'." }, { "name": "pre-line", "description": "Sets 'white-space-collapsing' to 'preserve-breaks' and 'text-wrap' to 'normal'." }, { "name": "pre-wrap", "description": "Sets 'white-space-collapsing' to 'preserve' and 'text-wrap' to 'normal'." } ], "syntax": "normal | pre | nowrap | pre-wrap | pre-line | break-spaces", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/white-space" } ], "description": "Shorthand property for the 'white-space-collapsing' and 'text-wrap' properties.", "restrictions": [ "enum" ] }, { "name": "padding-bottom", "syntax": " | ", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/padding-bottom" } ], "description": "Shorthand property to set values the thickness of the padding area. If left is omitted, it is the same as right. If bottom is omitted it is the same as top, if right is omitted it is the same as top. The value may not be negative.", "restrictions": [ "length", "percentage" ] }, { "name": "border-bottom", "syntax": " || || ", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/border-bottom" } ], "description": "Shorthand property for setting border width, style and color.", "restrictions": [ "length", "line-width", "line-style", "color" ] }, { "name": "box-shadow", "values": [ { "name": "inset", "description": "Changes the drop shadow from an outer shadow (one that shadows the box onto the canvas, as if it were lifted above the canvas) to an inner shadow (one that shadows the canvas onto the box, as if the box were cut out of the canvas and shifted behind it)." }, { "name": "none", "description": "No shadow." } ], "syntax": "none | #", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/box-shadow" } ], "description": "Attaches one or more drop-shadows to the box. The property is a comma-separated list of shadows, each specified by 2-4 length values, an optional color, and an optional 'inset' keyword. Omitted lengths are 0; omitted colors are a user agent chosen color.", "restrictions": [ "length", "color", "enum" ] }, { "name": "transform", "values": [ { "name": "matrix()", "description": "Specifies a 2D transformation in the form of a transformation matrix of six values. matrix(a,b,c,d,e,f) is equivalent to applying the transformation matrix [a b c d e f]" }, { "name": "matrix3d()", "description": "Specifies a 3D transformation as a 4x4 homogeneous matrix of 16 values in column-major order." }, { "name": "none" }, { "name": "perspective()", "description": "Specifies a perspective projection matrix." }, { "name": "rotate()", "description": "Specifies a 2D rotation by the angle specified in the parameter about the origin of the element, as defined by the transform-origin property." }, { "name": "rotate3d()", "description": "Specifies a clockwise 3D rotation by the angle specified in last parameter about the [x,y,z] direction vector described by the first 3 parameters." }, { "name": "rotateX('angle')", "description": "Specifies a clockwise rotation by the given angle about the X axis." }, { "name": "rotateY('angle')", "description": "Specifies a clockwise rotation by the given angle about the Y axis." }, { "name": "rotateZ('angle')", "description": "Specifies a clockwise rotation by the given angle about the Z axis." }, { "name": "scale()", "description": "Specifies a 2D scale operation by the [sx,sy] scaling vector described by the 2 parameters. If the second parameter is not provided, it is takes a value equal to the first." }, { "name": "scale3d()", "description": "Specifies a 3D scale operation by the [sx,sy,sz] scaling vector described by the 3 parameters." }, { "name": "scaleX()", "description": "Specifies a scale operation using the [sx,1] scaling vector, where sx is given as the parameter." }, { "name": "scaleY()", "description": "Specifies a scale operation using the [sy,1] scaling vector, where sy is given as the parameter." }, { "name": "scaleZ()", "description": "Specifies a scale operation using the [1,1,sz] scaling vector, where sz is given as the parameter." }, { "name": "skew()", "description": "Specifies a skew transformation along the X and Y axes. The first angle parameter specifies the skew on the X axis. The second angle parameter specifies the skew on the Y axis. If the second parameter is not given then a value of 0 is used for the Y angle (ie: no skew on the Y axis)." }, { "name": "skewX()", "description": "Specifies a skew transformation along the X axis by the given angle." }, { "name": "skewY()", "description": "Specifies a skew transformation along the Y axis by the given angle." }, { "name": "translate()", "description": "Specifies a 2D translation by the vector [tx, ty], where tx is the first translation-value parameter and ty is the optional second translation-value parameter." }, { "name": "translate3d()", "description": "Specifies a 3D translation by the vector [tx,ty,tz], with tx, ty and tz being the first, second and third translation-value parameters respectively." }, { "name": "translateX()", "description": "Specifies a translation by the given amount in the X direction." }, { "name": "translateY()", "description": "Specifies a translation by the given amount in the Y direction." }, { "name": "translateZ()", "description": "Specifies a translation by the given amount in the Z direction. Note that percentage values are not allowed in the translateZ translation-value, and if present are evaluated as 0." } ], "syntax": "none | ", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/transform" } ], "description": "A two-dimensional transformation is applied to an element through the 'transform' property. This property contains a list of transform functions similar to those allowed by SVG.", "restrictions": [ "enum" ] }, { "name": "min-height", "values": [ { "name": "auto" }, { "name": "fit-content", "description": "Use the fit-content inline size or fit-content block size, as appropriate to the writing mode." }, { "name": "max-content", "description": "Use the max-content inline size or max-content block size, as appropriate to the writing mode." }, { "name": "min-content", "description": "Use the min-content inline size or min-content block size, as appropriate to the writing mode." } ], "syntax": "", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/min-height" } ], "description": "Allows authors to constrain content height to a certain range.", "restrictions": [ "length", "percentage" ] }, { "name": "visibility", "values": [ { "name": "collapse", "description": "Table-specific. If used on elements other than rows, row groups, columns, or column groups, 'collapse' has the same meaning as 'hidden'." }, { "name": "hidden", "description": "The generated box is invisible (fully transparent, nothing is drawn), but still affects layout." }, { "name": "visible", "description": "The generated box is visible." } ], "syntax": "visible | hidden | collapse", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/visibility" } ], "description": "Specifies whether the boxes generated by an element are rendered. Invisible boxes still affect layout (set the ‘display’ property to ‘none’ to suppress box generation altogether).", "restrictions": [ "enum" ] }, { "name": "background-position", "syntax": "#", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/background-position" } ], "description": "Specifies the initial position of the background image(s) (after any resizing) within their corresponding background positioning area.", "restrictions": [ "position", "length", "percentage" ] }, { "name": "border-top", "syntax": " || || ", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/border-top" } ], "description": "Shorthand property for setting border width, style and color", "restrictions": [ "length", "line-width", "line-style", "color" ] }, { "name": "min-width", "values": [ { "name": "auto" }, { "name": "fit-content", "description": "Use the fit-content inline size or fit-content block size, as appropriate to the writing mode." }, { "name": "max-content", "description": "Use the max-content inline size or max-content block size, as appropriate to the writing mode." }, { "name": "min-content", "description": "Use the min-content inline size or min-content block size, as appropriate to the writing mode." } ], "syntax": "", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/min-width" } ], "description": "Allows authors to constrain content width to a certain range.", "restrictions": [ "length", "percentage" ] }, { "name": "outline", "values": [ { "name": "auto", "description": "Permits the user agent to render a custom outline style, typically the default platform style." }, { "name": "invert", "description": "Performs a color inversion on the pixels on the screen." } ], "syntax": "[ <'outline-color'> || <'outline-style'> || <'outline-width'> ]", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/outline" } ], "description": "Shorthand property for 'outline-style', 'outline-width', and 'outline-color'.", "restrictions": [ "length", "line-width", "line-style", "color", "enum" ] }, { "name": "transition", "values": [ { "name": "all", "description": "Every property that is able to undergo a transition will do so." }, { "name": "none", "description": "No property will transition." } ], "syntax": "#", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/transition" } ], "description": "Shorthand property combines four of the transition properties into a single property.", "restrictions": [ "time", "property", "timing-function", "enum" ] }, { "name": "clear", "values": [ { "name": "both", "description": "The clearance of the generated box is set to the amount necessary to place the top border edge below the bottom outer edge of any right-floating and left-floating boxes that resulted from elements earlier in the source document." }, { "name": "left", "description": "The clearance of the generated box is set to the amount necessary to place the top border edge below the bottom outer edge of any left-floating boxes that resulted from elements earlier in the source document." }, { "name": "none", "description": "No constraint on the box's position with respect to floats." }, { "name": "right", "description": "The clearance of the generated box is set to the amount necessary to place the top border edge below the bottom outer edge of any right-floating boxes that resulted from elements earlier in the source document." } ], "syntax": "none | left | right | both | inline-start | inline-end", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/clear" } ], "description": "Indicates which sides of an element's box(es) may not be adjacent to an earlier floating box. The 'clear' property does not consider floats inside the element itself or in other block formatting contexts.", "restrictions": [ "enum" ] }, { "name": "border-color", "values": [], "syntax": "{1,4}", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/border-color" } ], "description": "The color of the border around all four edges of an element.", "restrictions": [ "color" ] }, { "name": "background-repeat", "values": [], "syntax": "#", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/background-repeat" } ], "description": "Specifies how background images are tiled after they have been sized and positioned.", "restrictions": [ "repeat" ] }, { "name": "background-size", "values": [ { "name": "auto", "description": "Resolved by using the image’s intrinsic ratio and the size of the other dimension, or failing that, using the image’s intrinsic size, or failing that, treating it as 100%." }, { "name": "contain", "description": "Scale the image, while preserving its intrinsic aspect ratio (if any), to the largest size such that both its width and its height can fit inside the background positioning area." }, { "name": "cover", "description": "Scale the image, while preserving its intrinsic aspect ratio (if any), to the smallest size such that both its width and its height can completely cover the background positioning area." } ], "syntax": "#", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/background-size" } ], "description": "Specifies the size of the background images.", "restrictions": [ "length", "percentage" ] }, { "name": "text-transform", "values": [ { "name": "capitalize", "description": "Puts the first typographic letter unit of each word in titlecase." }, { "name": "lowercase", "description": "Puts all letters in lowercase." }, { "name": "none", "description": "No effects." }, { "name": "uppercase", "description": "Puts all letters in uppercase." } ], "syntax": "none | capitalize | uppercase | lowercase | full-width | full-size-kana", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/text-transform" } ], "description": "Controls capitalization effects of an element’s text.", "restrictions": [ "enum" ] }, { "name": "max-height", "values": [ { "name": "none", "description": "No limit on the height of the box." }, { "name": "fit-content", "description": "Use the fit-content inline size or fit-content block size, as appropriate to the writing mode." }, { "name": "max-content", "description": "Use the max-content inline size or max-content block size, as appropriate to the writing mode." }, { "name": "min-content", "description": "Use the min-content inline size or min-content block size, as appropriate to the writing mode." } ], "syntax": "", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/max-height" } ], "description": "Allows authors to constrain content height to a certain range.", "restrictions": [ "length", "percentage" ] }, { "name": "list-style", "values": [ { "name": "armenian" }, { "name": "circle", "description": "A hollow circle." }, { "name": "decimal" }, { "name": "decimal-leading-zero" }, { "name": "disc", "description": "A filled circle." }, { "name": "georgian" }, { "name": "inside", "description": "The marker box is outside the principal block box, as described in the section on the ::marker pseudo-element below." }, { "name": "lower-alpha" }, { "name": "lower-greek" }, { "name": "lower-latin" }, { "name": "lower-roman" }, { "name": "none" }, { "name": "outside", "description": "The ::marker pseudo-element is an inline element placed immediately before all ::before pseudo-elements in the principal block box, after which the element's content flows." }, { "name": "square", "description": "A filled square." }, { "name": "symbols()", "description": "Allows a counter style to be defined inline." }, { "name": "upper-alpha" }, { "name": "upper-latin" }, { "name": "upper-roman" }, { "name": "url()" } ], "syntax": "<'list-style-type'> || <'list-style-position'> || <'list-style-image'>", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/list-style" } ], "description": "Shorthand for setting 'list-style-type', 'list-style-position' and 'list-style-image'", "restrictions": [ "image", "enum", "url" ] }, { "name": "font-style", "values": [ { "name": "italic", "description": "Selects a font that is labeled as an 'italic' face, or an 'oblique' face if one is not" }, { "name": "normal", "description": "Selects a face that is classified as 'normal'." }, { "name": "oblique", "description": "Selects a font that is labeled as an 'oblique' face, or an 'italic' face if one is not." } ], "syntax": "normal | italic | oblique {0,2}", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/font-style" } ], "description": "Allows italic or oblique faces to be selected. Italic forms are generally cursive in nature while oblique faces are typically sloped versions of the regular face.", "restrictions": [ "enum" ] }, { "name": "font", "values": [ { "name": "100", "description": "Thin" }, { "name": "200", "description": "Extra Light (Ultra Light)" }, { "name": "300", "description": "Light" }, { "name": "400", "description": "Normal" }, { "name": "500", "description": "Medium" }, { "name": "600", "description": "Semi Bold (Demi Bold)" }, { "name": "700", "description": "Bold" }, { "name": "800", "description": "Extra Bold (Ultra Bold)" }, { "name": "900", "description": "Black (Heavy)" }, { "name": "bold", "description": "Same as 700" }, { "name": "bolder", "description": "Specifies the weight of the face bolder than the inherited value." }, { "name": "caption", "description": "The font used for captioned controls (e.g., buttons, drop-downs, etc.)." }, { "name": "icon", "description": "The font used to label icons." }, { "name": "italic", "description": "Selects a font that is labeled 'italic', or, if that is not available, one labeled 'oblique'." }, { "name": "large" }, { "name": "larger" }, { "name": "lighter", "description": "Specifies the weight of the face lighter than the inherited value." }, { "name": "medium" }, { "name": "menu", "description": "The font used in menus (e.g., dropdown menus and menu lists)." }, { "name": "message-box", "description": "The font used in dialog boxes." }, { "name": "normal", "description": "Specifies a face that is not labeled as a small-caps font." }, { "name": "oblique", "description": "Selects a font that is labeled 'oblique'." }, { "name": "small" }, { "name": "small-caps", "description": "Specifies a font that is labeled as a small-caps font. If a genuine small-caps font is not available, user agents should simulate a small-caps font." }, { "name": "small-caption", "description": "The font used for labeling small controls." }, { "name": "smaller" }, { "name": "status-bar", "description": "The font used in window status bars." }, { "name": "x-large" }, { "name": "x-small" }, { "name": "xx-large" }, { "name": "xx-small" } ], "syntax": "[ [ <'font-style'> || || <'font-weight'> || <'font-stretch'> ]? <'font-size'> [ / <'line-height'> ]? <'font-family'> ] | caption | icon | menu | message-box | small-caption | status-bar", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/font" } ], "description": "Shorthand property for setting 'font-style', 'font-variant', 'font-weight', 'font-size', 'line-height', and 'font-family', at the same place in the style sheet. The syntax of this property is based on a traditional typographical shorthand notation to set multiple properties related to fonts.", "restrictions": [ "font" ] }, { "name": "text-overflow", "values": [ { "name": "clip", "description": "Clip inline content that overflows. Characters may be only partially rendered." }, { "name": "ellipsis", "description": "Render an ellipsis character (U+2026) to represent clipped inline content." } ], "syntax": "[ clip | ellipsis | ]{1,2}", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/text-overflow" } ], "description": "Text can overflow for example when it is prevented from wrapping.", "restrictions": [ "enum", "string" ] }, { "name": "border-left", "syntax": " || || ", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/border-left" } ], "description": "Shorthand property for setting border width, style and color", "restrictions": [ "length", "line-width", "line-style", "color" ] }, { "name": "border-right", "syntax": " || || ", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/border-right" } ], "description": "Shorthand property for setting border width, style and color", "restrictions": [ "length", "line-width", "line-style", "color" ] }, { "name": "border-width", "values": [], "syntax": "{1,4}", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/border-width" } ], "description": "Shorthand that sets the four 'border-*-width' properties. If it has four values, they set top, right, bottom and left in that order. If left is missing, it is the same as right; if bottom is missing, it is the same as top; if right is missing, it is the same as top.", "restrictions": [ "length", "line-width" ] }, { "name": "justify-content", "values": [ { "name": "center", "description": "Flex items are packed toward the center of the line." }, { "name": "start", "description": "The items are packed flush to each other toward the start edge of the alignment container in the main axis." }, { "name": "end", "description": "The items are packed flush to each other toward the end edge of the alignment container in the main axis." }, { "name": "left", "description": "The items are packed flush to each other toward the left edge of the alignment container in the main axis." }, { "name": "right", "description": "The items are packed flush to each other toward the right edge of the alignment container in the main axis." }, { "name": "safe", "description": "If the size of the item overflows the alignment container, the item is instead aligned as if the alignment mode were start." }, { "name": "unsafe", "description": "Regardless of the relative sizes of the item and alignment container, the given alignment value is honored." }, { "name": "stretch", "description": "If the combined size of the alignment subjects is less than the size of the alignment container, any auto-sized alignment subjects have their size increased equally (not proportionally), while still respecting the constraints imposed by max-height/max-width (or equivalent functionality), so that the combined size exactly fills the alignment container." }, { "name": "space-evenly", "description": "The items are evenly distributed within the alignment container along the main axis." }, { "name": "flex-end", "description": "Flex items are packed toward the end of the line." }, { "name": "flex-start", "description": "Flex items are packed toward the start of the line." }, { "name": "space-around", "description": "Flex items are evenly distributed in the line, with half-size spaces on either end." }, { "name": "space-between", "description": "Flex items are evenly distributed in the line." }, { "name": "baseline", "description": "Specifies participation in first-baseline alignment." }, { "name": "first baseline", "description": "Specifies participation in first-baseline alignment." }, { "name": "last baseline", "description": "Specifies participation in last-baseline alignment." } ], "syntax": "normal | | ? [ | left | right ]", "description": "Aligns flex items along the main axis of the current line of the flex container.", "restrictions": [ "enum" ] }, { "name": "align-items", "values": [ { "name": "baseline", "description": "If the flex item’s inline axis is the same as the cross axis, this value is identical to 'flex-start'. Otherwise, it participates in baseline alignment." }, { "name": "center", "description": "The flex item’s margin box is centered in the cross axis within the line." }, { "name": "flex-end", "description": "The cross-end margin edge of the flex item is placed flush with the cross-end edge of the line." }, { "name": "flex-start", "description": "The cross-start margin edge of the flex item is placed flush with the cross-start edge of the line." }, { "name": "stretch", "description": "If the cross size property of the flex item computes to auto, and neither of the cross-axis margins are auto, the flex item is stretched." } ], "syntax": "normal | stretch | | [ ? ]", "description": "Aligns flex items along the cross axis of the current line of the flex container.", "restrictions": [ "enum" ] }, { "name": "overflow-y", "values": [ { "name": "auto", "description": "The behavior of the 'auto' value is UA-dependent, but should cause a scrolling mechanism to be provided for overflowing boxes." }, { "name": "hidden", "description": "Content is clipped and no scrolling mechanism should be provided to view the content outside the clipping region." }, { "name": "scroll", "description": "Content is clipped and if the user agent uses a scrolling mechanism that is visible on the screen (such as a scroll bar or a panner), that mechanism should be displayed for a box whether or not any of its content is clipped." }, { "name": "visible", "description": "Content is not clipped, i.e., it may be rendered outside the content box." } ], "syntax": "visible | hidden | clip | scroll | auto", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/overflow-y" } ], "description": "Specifies the handling of overflow in the vertical direction.", "restrictions": [ "enum" ] }, { "name": "pointer-events", "values": [ { "name": "all", "description": "The given element can be the target element for pointer events whenever the pointer is over either the interior or the perimeter of the element." }, { "name": "fill", "description": "The given element can be the target element for pointer events whenever the pointer is over the interior of the element." }, { "name": "none", "description": "The given element does not receive pointer events." }, { "name": "painted", "description": "The given element can be the target element for pointer events when the pointer is over a \"painted\" area. " }, { "name": "stroke", "description": "The given element can be the target element for pointer events whenever the pointer is over the perimeter of the element." }, { "name": "visible", "description": "The given element can be the target element for pointer events when the ‘visibility’ property is set to visible and the pointer is over either the interior or the perimete of the element." }, { "name": "visibleFill", "description": "The given element can be the target element for pointer events when the ‘visibility’ property is set to visible and when the pointer is over the interior of the element." }, { "name": "visiblePainted", "description": "The given element can be the target element for pointer events when the ‘visibility’ property is set to visible and when the pointer is over a ‘painted’ area." }, { "name": "visibleStroke", "description": "The given element can be the target element for pointer events when the ‘visibility’ property is set to visible and when the pointer is over the perimeter of the element." } ], "syntax": "auto | none | visiblePainted | visibleFill | visibleStroke | visible | painted | fill | stroke | all | inherit", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/pointer-events" } ], "description": "Specifies under what circumstances a given element can be the target element for a pointer event.", "restrictions": [ "enum" ] }, { "name": "letter-spacing", "values": [ { "name": "normal", "description": "The spacing is the normal spacing for the current font. It is typically zero-length." } ], "syntax": "normal | ", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/letter-spacing" } ], "description": "Specifies the minimum, maximum, and optimal spacing between grapheme clusters.", "restrictions": [ "length" ] }, { "name": "border-style", "values": [], "syntax": "{1,4}", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/border-style" } ], "description": "The style of the border around edges of an element.", "restrictions": [ "line-style" ] }, { "name": "animation", "values": [ { "name": "alternate", "description": "The animation cycle iterations that are odd counts are played in the normal direction, and the animation cycle iterations that are even counts are played in a reverse direction." }, { "name": "alternate-reverse", "description": "The animation cycle iterations that are odd counts are played in the reverse direction, and the animation cycle iterations that are even counts are played in a normal direction." }, { "name": "backwards", "description": "The beginning property value (as defined in the first @keyframes at-rule) is applied before the animation is displayed, during the period defined by 'animation-delay'." }, { "name": "both", "description": "Both forwards and backwards fill modes are applied." }, { "name": "forwards", "description": "The final property value (as defined in the last @keyframes at-rule) is maintained after the animation completes." }, { "name": "infinite", "description": "Causes the animation to repeat forever." }, { "name": "none", "description": "No animation is performed" }, { "name": "normal", "description": "Normal playback." }, { "name": "reverse", "description": "All iterations of the animation are played in the reverse direction from the way they were specified." } ], "syntax": "#", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/animation" } ], "description": "Shorthand property combines six of the animation properties into a single property.", "restrictions": [ "time", "timing-function", "enum", "identifier", "number" ] }, { "name": "overflow-x", "values": [ { "name": "auto", "description": "The behavior of the 'auto' value is UA-dependent, but should cause a scrolling mechanism to be provided for overflowing boxes." }, { "name": "hidden", "description": "Content is clipped and no scrolling mechanism should be provided to view the content outside the clipping region." }, { "name": "scroll", "description": "Content is clipped and if the user agent uses a scrolling mechanism that is visible on the screen (such as a scroll bar or a panner), that mechanism should be displayed for a box whether or not any of its content is clipped." }, { "name": "visible", "description": "Content is not clipped, i.e., it may be rendered outside the content box." } ], "syntax": "visible | hidden | clip | scroll | auto", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/overflow-x" } ], "description": "Specifies the handling of overflow in the horizontal direction.", "restrictions": [ "enum" ] }, { "name": "word-wrap", "values": [ { "name": "break-word", "description": "An otherwise unbreakable sequence of characters may be broken at an arbitrary point if there are no otherwise-acceptable break points in the line." }, { "name": "normal", "description": "Lines may break only at allowed break points." } ], "syntax": "normal | break-word", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/overflow-wrap" } ], "description": "Specifies whether the UA may break within a word to prevent overflow when an otherwise-unbreakable string is too long to fit.", "restrictions": [ "enum" ] }, { "name": "border-collapse", "values": [ { "name": "collapse", "description": "Selects the collapsing borders model." }, { "name": "separate", "description": "Selects the separated borders border model." } ], "syntax": "collapse | separate", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/border-collapse" } ], "description": "Selects a table's border model.", "restrictions": [ "enum" ] }, { "name": "flex-direction", "values": [ { "name": "column", "description": "The flex container’s main axis has the same orientation as the block axis of the current writing mode." }, { "name": "column-reverse", "description": "Same as 'column', except the main-start and main-end directions are swapped." }, { "name": "row", "description": "The flex container’s main axis has the same orientation as the inline axis of the current writing mode." }, { "name": "row-reverse", "description": "Same as 'row', except the main-start and main-end directions are swapped." } ], "syntax": "row | row-reverse | column | column-reverse", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/flex-direction" } ], "description": "Specifies how flex items are placed in the flex container, by setting the direction of the flex container’s main axis.", "restrictions": [ "enum" ] }, { "name": "zoom", "browsers": [ "E12", "S3.1", "C1", "IE5.5", "O15" ], "values": [ { "name": "normal" } ], "syntax": "auto | | ", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/zoom" } ], "description": "Non-standard. Specifies the magnification scale of the object. See 'transform: scale()' for a standards-based alternative.", "restrictions": [ "enum", "integer", "number", "percentage" ] }, { "name": "flex", "values": [ { "name": "auto", "description": "Retrieves the value of the main size property as the used 'flex-basis'." }, { "name": "content", "description": "Indicates automatic sizing, based on the flex item’s content." }, { "name": "none", "description": "Expands to '0 0 auto'." } ], "syntax": "none | [ <'flex-grow'> <'flex-shrink'>? || <'flex-basis'> ]", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/flex" } ], "description": "Specifies the components of a flexible length: the flex grow factor and flex shrink factor, and the flex basis.", "restrictions": [ "length", "number", "percentage" ] }, { "name": "text-shadow", "values": [ { "name": "none", "description": "No shadow." } ], "syntax": "none | #", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/text-shadow" } ], "description": "Enables shadow effects to be applied to the text of the element.", "restrictions": [ "length", "color" ] }, { "name": "list-style-type", "values": [ { "name": "armenian", "description": "Traditional uppercase Armenian numbering." }, { "name": "circle", "description": "A hollow circle." }, { "name": "decimal", "description": "Western decimal numbers." }, { "name": "decimal-leading-zero", "description": "Decimal numbers padded by initial zeros." }, { "name": "disc", "description": "A filled circle." }, { "name": "georgian", "description": "Traditional Georgian numbering." }, { "name": "lower-alpha", "description": "Lowercase ASCII letters." }, { "name": "lower-greek", "description": "Lowercase classical Greek." }, { "name": "lower-latin", "description": "Lowercase ASCII letters." }, { "name": "lower-roman", "description": "Lowercase ASCII Roman numerals." }, { "name": "none", "description": "No marker" }, { "name": "square", "description": "A filled square." }, { "name": "symbols()", "description": "Allows a counter style to be defined inline." }, { "name": "upper-alpha", "description": "Uppercase ASCII letters." }, { "name": "upper-latin", "description": "Uppercase ASCII letters." }, { "name": "upper-roman", "description": "Uppercase ASCII Roman numerals." } ], "syntax": " | | none", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/list-style-type" } ], "description": "Used to construct the default contents of a list item’s marker", "restrictions": [ "enum", "string" ] }, { "name": "border-bottom-left-radius", "syntax": "{1,2}", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/border-bottom-left-radius" } ], "description": "Defines the radii of the bottom left outer border edge.", "restrictions": [ "length", "percentage" ] }, { "name": "user-select", "values": [ { "name": "all", "description": "The content of the element must be selected atomically" }, { "name": "auto" }, { "name": "contain", "description": "UAs must not allow a selection which is started in this element to be extended outside of this element." }, { "name": "none", "description": "The UA must not allow selections to be started in this element." }, { "name": "text", "description": "The element imposes no constraint on the selection." } ], "status": "nonstandard", "syntax": "auto | text | none | contain | all", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/user-select" } ], "description": "Controls the appearance of selection.", "restrictions": [ "enum" ] }, { "name": "fill", "values": [ { "name": "url()", "description": "A URL reference to a paint server element, which is an element that defines a paint server: ‘hatch’, ‘linearGradient’, ‘mesh’, ‘pattern’, ‘radialGradient’ and ‘solidcolor’." }, { "name": "none", "description": "No paint is applied in this layer." } ], "description": "Paints the interior of the given graphical element.", "restrictions": [ "color", "enum", "url" ] }, { "name": "transform-origin", "syntax": "[ | left | center | right | top | bottom ] | [ [ | left | center | right ] && [ | top | center | bottom ] ] ?", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/transform-origin" } ], "description": "Establishes the origin of transformation for an element.", "restrictions": [ "position", "length", "percentage" ] }, { "name": "border-top-left-radius", "syntax": "{1,2}", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/border-top-left-radius" } ], "description": "Defines the radii of the top left outer border edge.", "restrictions": [ "length", "percentage" ] }, { "name": "text-indent", "values": [], "syntax": " && hanging? && each-line?", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/text-indent" } ], "description": "Specifies the indentation applied to lines of inline content in a block. The indentation only affects the first line of inline content in the block unless the 'hanging' keyword is specified, in which case it affects all lines except the first.", "restrictions": [ "percentage", "length" ] }, { "name": "border-bottom-right-radius", "syntax": "{1,2}", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/border-bottom-right-radius" } ], "description": "Defines the radii of the bottom right outer border edge.", "restrictions": [ "length", "percentage" ] }, { "name": "flex-wrap", "values": [ { "name": "nowrap", "description": "The flex container is single-line." }, { "name": "wrap", "description": "The flexbox is multi-line." }, { "name": "wrap-reverse", "description": "Same as 'wrap', except the cross-start and cross-end directions are swapped." } ], "syntax": "nowrap | wrap | wrap-reverse", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/flex-wrap" } ], "description": "Controls whether the flex container is single-line or multi-line, and the direction of the cross-axis, which determines the direction new lines are stacked in.", "restrictions": [ "enum" ] }, { "name": "border-spacing", "syntax": " ?", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/border-spacing" } ], "description": "The lengths specify the distance that separates adjoining cell borders. If one length is specified, it gives both the horizontal and vertical spacing. If two are specified, the first gives the horizontal spacing and the second the vertical spacing. Lengths may not be negative.", "restrictions": [ "length" ] }, { "name": "border-top-right-radius", "syntax": "{1,2}", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/border-top-right-radius" } ], "description": "Defines the radii of the top right outer border edge.", "restrictions": [ "length", "percentage" ] }, { "name": "clip", "values": [ { "name": "auto", "description": "The element does not clip." }, { "name": "rect()", "description": "Specifies offsets from the edges of the border box." } ], "syntax": " | auto", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/clip" } ], "description": "Deprecated. Use the 'clip-path' property when support allows. Defines the visible portion of an element’s box.", "restrictions": [ "enum" ] }, { "name": "border-top-color", "syntax": "", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/border-top-color" } ], "description": "Sets the color of the top border.", "restrictions": [ "color" ] }, { "name": "word-break", "values": [ { "name": "break-all", "description": "Lines may break between any two grapheme clusters for non-CJK scripts." }, { "name": "keep-all", "description": "Block characters can no longer create implied break points." }, { "name": "normal", "description": "Breaks non-CJK scripts according to their own rules." } ], "syntax": "normal | break-all | keep-all | break-word", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/word-break" } ], "description": "Specifies line break opportunities for non-CJK scripts.", "restrictions": [ "enum" ] }, { "name": "border-bottom-color", "syntax": "<'border-top-color'>", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/border-bottom-color" } ], "description": "Sets the color of the bottom border.", "restrictions": [ "color" ] }, { "name": "flex-grow", "syntax": "", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/flex-grow" } ], "description": "Sets the flex grow factor. Negative numbers are invalid.", "restrictions": [ "number" ] }, { "name": "direction", "values": [ { "name": "ltr", "description": "Left-to-right direction." }, { "name": "rtl", "description": "Right-to-left direction." } ], "syntax": "ltr | rtl", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/direction" } ], "description": "Specifies the inline base direction or directionality of any bidi paragraph, embedding, isolate, or override established by the box. Note: for HTML content use the 'dir' attribute and 'bdo' element rather than this property.", "restrictions": [ "enum" ] }, { "name": "align-self", "values": [ { "name": "auto", "description": "Computes to the value of 'align-items' on the element’s parent, or 'stretch' if the element has no parent. On absolutely positioned elements, it computes to itself." }, { "name": "baseline", "description": "If the flex item’s inline axis is the same as the cross axis, this value is identical to 'flex-start'. Otherwise, it participates in baseline alignment." }, { "name": "center", "description": "The flex item’s margin box is centered in the cross axis within the line." }, { "name": "flex-end", "description": "The cross-end margin edge of the flex item is placed flush with the cross-end edge of the line." }, { "name": "flex-start", "description": "The cross-start margin edge of the flex item is placed flush with the cross-start edge of the line." }, { "name": "stretch", "description": "If the cross size property of the flex item computes to auto, and neither of the cross-axis margins are auto, the flex item is stretched." } ], "syntax": "auto | normal | stretch | | ? ", "description": "Allows the default alignment along the cross axis to be overridden for individual flex items.", "restrictions": [ "enum" ] }, { "name": "flex-shrink", "syntax": "", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/flex-shrink" } ], "description": "Sets the flex shrink factor. Negative numbers are invalid.", "restrictions": [ "number" ] }, { "name": "text-rendering", "browsers": [ "FF1", "S5", "C4", "O15" ], "values": [ { "name": "auto" }, { "name": "geometricPrecision", "description": "Indicates that the user agent shall emphasize geometric precision over legibility and rendering speed." }, { "name": "optimizeLegibility", "description": "Indicates that the user agent shall emphasize legibility over rendering speed and geometric precision." }, { "name": "optimizeSpeed", "description": "Indicates that the user agent shall emphasize rendering speed over legibility and geometric precision." } ], "syntax": "auto | optimizeSpeed | optimizeLegibility | geometricPrecision", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/text-rendering" } ], "description": "The creator of SVG content might want to provide a hint to the implementation about what tradeoffs to make as it renders text. The ‘text-rendering’ property provides these hints.", "restrictions": [ "enum" ] }, { "name": "touch-action", "values": [ { "name": "auto", "description": "The user agent may determine any permitted touch behaviors for touches that begin on the element." }, { "name": "cross-slide-x" }, { "name": "cross-slide-y" }, { "name": "double-tap-zoom" }, { "name": "manipulation", "description": "The user agent may consider touches that begin on the element only for the purposes of scrolling and continuous zooming." }, { "name": "none", "description": "Touches that begin on the element must not trigger default touch behaviors." }, { "name": "pan-x", "description": "The user agent may consider touches that begin on the element only for the purposes of horizontally scrolling the element’s nearest ancestor with horizontally scrollable content." }, { "name": "pan-y", "description": "The user agent may consider touches that begin on the element only for the purposes of vertically scrolling the element’s nearest ancestor with vertically scrollable content." }, { "name": "pinch-zoom" } ], "syntax": "auto | none | [ [ pan-x | pan-left | pan-right ] || [ pan-y | pan-up | pan-down ] || pinch-zoom ] | manipulation", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/touch-action" } ], "description": "Determines whether touch input may trigger default behavior supplied by user agent.", "restrictions": [ "enum" ] }, { "name": "background-clip", "syntax": "#", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/background-clip" } ], "description": "Determines the background painting area.", "restrictions": [ "box" ] }, { "name": "filter", "browsers": [ "E12", "FF35", "S9.1", "C53", "O40" ], "values": [ { "name": "none", "description": "No filter effects are applied." }, { "name": "blur()", "description": "Applies a Gaussian blur to the input image." }, { "name": "brightness()", "description": "Applies a linear multiplier to input image, making it appear more or less bright." }, { "name": "contrast()", "description": "Adjusts the contrast of the input." }, { "name": "drop-shadow()", "description": "Applies a drop shadow effect to the input image." }, { "name": "grayscale()", "description": "Converts the input image to grayscale." }, { "name": "hue-rotate()", "description": "Applies a hue rotation on the input image. " }, { "name": "invert()", "description": "Inverts the samples in the input image." }, { "name": "opacity()", "description": "Applies transparency to the samples in the input image." }, { "name": "saturate()", "description": "Saturates the input image." }, { "name": "sepia()", "description": "Converts the input image to sepia." }, { "name": "url()", "browsers": [ "E12", "FF35", "S9.1", "C53", "O40" ], "description": "A filter reference to a element." } ], "syntax": "none | ", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/filter" } ], "description": "Processes an element’s rendering before it is displayed in the document, by applying one or more filter effects.", "restrictions": [ "enum", "url" ] }, { "name": "src", "values": [ { "name": "url()", "description": "Reference font by URL" }, { "name": "format()", "description": "Optional hint describing the format of the font resource." }, { "name": "local()", "description": "Format-specific string that identifies a locally available copy of a given font." } ], "syntax": "[ [ format( # ) ]? | local( ) ]#", "description": "@font-face descriptor. Specifies the resource containing font data. It is required, whether the font is downloadable or locally installed.", "restrictions": [ "enum", "url", "identifier" ] }, { "name": "animation-timing-function", "syntax": "#", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/animation-timing-function" } ], "description": "Describes how the animation will progress over one cycle of its duration.", "restrictions": [ "timing-function" ] }, { "name": "border-right-color", "syntax": "", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/border-right-color" } ], "description": "Sets the color of the right border.", "restrictions": [ "color" ] }, { "name": "font-variant", "values": [ { "name": "normal", "description": "Specifies a face that is not labeled as a small-caps font." }, { "name": "small-caps", "description": "Specifies a font that is labeled as a small-caps font. If a genuine small-caps font is not available, user agents should simulate a small-caps font." } ], "syntax": "normal | none | [ || || || || stylistic() || historical-forms || styleset(#) || character-variant(#) || swash() || ornaments() || annotation() || [ small-caps | all-small-caps | petite-caps | all-petite-caps | unicase | titling-caps ] || || || || ordinal || slashed-zero || || || ruby ]", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/font-variant" } ], "description": "Specifies variant representations of the font", "restrictions": [ "enum" ] }, { "name": "border-left-color", "syntax": "", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/border-left-color" } ], "description": "Sets the color of the left border.", "restrictions": [ "color" ] }, { "name": "animation-name", "values": [ { "name": "none", "description": "No animation is performed" } ], "syntax": "[ none | ]#", "references": [ { "name": "MDN Reference", "url": "https://developer.mozilla.org/docs/Web/CSS/animation-name" } ], "description": "Defines a list of animations that apply. Each name is used to select the keyframe at-rule that provides the property values for the animation.", "restrictions": [ "identifier", "enum" ] }, { "name": "animation-duration", "syntax": "