vscode-css-languageservice 5.4.1 → 6.0.1

package/lib/umd/services/cssFormatter.js

@@ -1,150 +1,150 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-(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(["require", "exports", "../cssLanguageTypes", "../beautify/beautify-css", "../utils/strings"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.format = void 0;
-    var cssLanguageTypes_1 = require("../cssLanguageTypes");
-    var beautify_css_1 = require("../beautify/beautify-css");
-    var strings_1 = require("../utils/strings");
-    function format(document, range, options) {
-        var value = document.getText();
-        var includesEnd = true;
-        var initialIndentLevel = 0;
-        var inRule = false;
-        var tabSize = options.tabSize || 4;
-        if (range) {
-            var startOffset = document.offsetAt(range.start);
-            // include all leading whitespace iff at the beginning of the line
-            var extendedStart = startOffset;
-            while (extendedStart > 0 && isWhitespace(value, extendedStart - 1)) {
-                extendedStart--;
-            }
-            if (extendedStart === 0 || isEOL(value, extendedStart - 1)) {
-                startOffset = extendedStart;
-            }
-            else {
-                // else keep at least one whitespace
-                if (extendedStart < startOffset) {
-                    startOffset = extendedStart + 1;
-                }
-            }
-            // include all following whitespace until the end of the line
-            var endOffset = document.offsetAt(range.end);
-            var extendedEnd = endOffset;
-            while (extendedEnd < value.length && isWhitespace(value, extendedEnd)) {
-                extendedEnd++;
-            }
-            if (extendedEnd === value.length || isEOL(value, extendedEnd)) {
-                endOffset = extendedEnd;
-            }
-            range = cssLanguageTypes_1.Range.create(document.positionAt(startOffset), document.positionAt(endOffset));
-            // Test if inside a rule
-            inRule = isInRule(value, startOffset);
-            includesEnd = endOffset === value.length;
-            value = value.substring(startOffset, endOffset);
-            if (startOffset !== 0) {
-                var startOfLineOffset = document.offsetAt(cssLanguageTypes_1.Position.create(range.start.line, 0));
-                initialIndentLevel = computeIndentLevel(document.getText(), startOfLineOffset, options);
-            }
-            if (inRule) {
-                value = "{\n".concat(trimLeft(value));
-            }
-        }
-        else {
-            range = cssLanguageTypes_1.Range.create(cssLanguageTypes_1.Position.create(0, 0), document.positionAt(value.length));
-        }
-        var cssOptions = {
-            indent_size: tabSize,
-            indent_char: options.insertSpaces ? ' ' : '\t',
-            end_with_newline: includesEnd && getFormatOption(options, 'insertFinalNewline', false),
-            selector_separator_newline: getFormatOption(options, 'newlineBetweenSelectors', true),
-            newline_between_rules: getFormatOption(options, 'newlineBetweenRules', true),
-            space_around_selector_separator: getFormatOption(options, 'spaceAroundSelectorSeparator', false),
-            brace_style: getFormatOption(options, 'braceStyle', 'collapse'),
-            indent_empty_lines: getFormatOption(options, 'indentEmptyLines', false),
-            max_preserve_newlines: getFormatOption(options, 'maxPreserveNewLines', undefined),
-            preserve_newlines: getFormatOption(options, 'preserveNewLines', true),
-            wrap_line_length: getFormatOption(options, 'wrapLineLength', undefined),
-            eol: '\n'
-        };
-        var result = (0, beautify_css_1.css_beautify)(value, cssOptions);
-        if (inRule) {
-            result = trimLeft(result.substring(2));
-        }
-        if (initialIndentLevel > 0) {
-            var indent = options.insertSpaces ? (0, strings_1.repeat)(' ', tabSize * initialIndentLevel) : (0, strings_1.repeat)('\t', initialIndentLevel);
-            result = result.split('\n').join('\n' + indent);
-            if (range.start.character === 0) {
-                result = indent + result; // keep the indent
-            }
-        }
-        return [{
-                range: range,
-                newText: result
-            }];
-    }
-    exports.format = format;
-    function trimLeft(str) {
-        return str.replace(/^\s+/, '');
-    }
-    var _CUL = '{'.charCodeAt(0);
-    var _CUR = '}'.charCodeAt(0);
-    function isInRule(str, offset) {
-        while (offset >= 0) {
-            var ch = str.charCodeAt(offset);
-            if (ch === _CUL) {
-                return true;
-            }
-            else if (ch === _CUR) {
-                return false;
-            }
-            offset--;
-        }
-        return false;
-    }
-    function getFormatOption(options, key, dflt) {
-        if (options && options.hasOwnProperty(key)) {
-            var value = options[key];
-            if (value !== null) {
-                return value;
-            }
-        }
-        return dflt;
-    }
-    function computeIndentLevel(content, offset, options) {
-        var i = offset;
-        var nChars = 0;
-        var tabSize = options.tabSize || 4;
-        while (i < content.length) {
-            var ch = content.charAt(i);
-            if (ch === ' ') {
-                nChars++;
-            }
-            else if (ch === '\t') {
-                nChars += tabSize;
-            }
-            else {
-                break;
-            }
-            i++;
-        }
-        return Math.floor(nChars / tabSize);
-    }
-    function isEOL(text, offset) {
-        return '\r\n'.indexOf(text.charAt(offset)) !== -1;
-    }
-    function isWhitespace(text, offset) {
-        return ' \t'.indexOf(text.charAt(offset)) !== -1;
-    }
-});
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(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(["require", "exports", "../cssLanguageTypes", "../beautify/beautify-css", "../utils/strings"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.format = void 0;
+    const cssLanguageTypes_1 = require("../cssLanguageTypes");
+    const beautify_css_1 = require("../beautify/beautify-css");
+    const strings_1 = require("../utils/strings");
+    function format(document, range, options) {
+        let value = document.getText();
+        let includesEnd = true;
+        let initialIndentLevel = 0;
+        let inRule = false;
+        const tabSize = options.tabSize || 4;
+        if (range) {
+            let startOffset = document.offsetAt(range.start);
+            // include all leading whitespace iff at the beginning of the line
+            let extendedStart = startOffset;
+            while (extendedStart > 0 && isWhitespace(value, extendedStart - 1)) {
+                extendedStart--;
+            }
+            if (extendedStart === 0 || isEOL(value, extendedStart - 1)) {
+                startOffset = extendedStart;
+            }
+            else {
+                // else keep at least one whitespace
+                if (extendedStart < startOffset) {
+                    startOffset = extendedStart + 1;
+                }
+            }
+            // include all following whitespace until the end of the line
+            let endOffset = document.offsetAt(range.end);
+            let extendedEnd = endOffset;
+            while (extendedEnd < value.length && isWhitespace(value, extendedEnd)) {
+                extendedEnd++;
+            }
+            if (extendedEnd === value.length || isEOL(value, extendedEnd)) {
+                endOffset = extendedEnd;
+            }
+            range = cssLanguageTypes_1.Range.create(document.positionAt(startOffset), document.positionAt(endOffset));
+            // Test if inside a rule
+            inRule = isInRule(value, startOffset);
+            includesEnd = endOffset === value.length;
+            value = value.substring(startOffset, endOffset);
+            if (startOffset !== 0) {
+                const startOfLineOffset = document.offsetAt(cssLanguageTypes_1.Position.create(range.start.line, 0));
+                initialIndentLevel = computeIndentLevel(document.getText(), startOfLineOffset, options);
+            }
+            if (inRule) {
+                value = `{\n${trimLeft(value)}`;
+            }
+        }
+        else {
+            range = cssLanguageTypes_1.Range.create(cssLanguageTypes_1.Position.create(0, 0), document.positionAt(value.length));
+        }
+        const cssOptions = {
+            indent_size: tabSize,
+            indent_char: options.insertSpaces ? ' ' : '\t',
+            end_with_newline: includesEnd && getFormatOption(options, 'insertFinalNewline', false),
+            selector_separator_newline: getFormatOption(options, 'newlineBetweenSelectors', true),
+            newline_between_rules: getFormatOption(options, 'newlineBetweenRules', true),
+            space_around_selector_separator: getFormatOption(options, 'spaceAroundSelectorSeparator', false),
+            brace_style: getFormatOption(options, 'braceStyle', 'collapse'),
+            indent_empty_lines: getFormatOption(options, 'indentEmptyLines', false),
+            max_preserve_newlines: getFormatOption(options, 'maxPreserveNewLines', undefined),
+            preserve_newlines: getFormatOption(options, 'preserveNewLines', true),
+            wrap_line_length: getFormatOption(options, 'wrapLineLength', undefined),
+            eol: '\n'
+        };
+        let result = (0, beautify_css_1.css_beautify)(value, cssOptions);
+        if (inRule) {
+            result = trimLeft(result.substring(2));
+        }
+        if (initialIndentLevel > 0) {
+            const indent = options.insertSpaces ? (0, strings_1.repeat)(' ', tabSize * initialIndentLevel) : (0, strings_1.repeat)('\t', initialIndentLevel);
+            result = result.split('\n').join('\n' + indent);
+            if (range.start.character === 0) {
+                result = indent + result; // keep the indent
+            }
+        }
+        return [{
+                range: range,
+                newText: result
+            }];
+    }
+    exports.format = format;
+    function trimLeft(str) {
+        return str.replace(/^\s+/, '');
+    }
+    const _CUL = '{'.charCodeAt(0);
+    const _CUR = '}'.charCodeAt(0);
+    function isInRule(str, offset) {
+        while (offset >= 0) {
+            const ch = str.charCodeAt(offset);
+            if (ch === _CUL) {
+                return true;
+            }
+            else if (ch === _CUR) {
+                return false;
+            }
+            offset--;
+        }
+        return false;
+    }
+    function getFormatOption(options, key, dflt) {
+        if (options && options.hasOwnProperty(key)) {
+            const value = options[key];
+            if (value !== null) {
+                return value;
+            }
+        }
+        return dflt;
+    }
+    function computeIndentLevel(content, offset, options) {
+        let i = offset;
+        let nChars = 0;
+        const tabSize = options.tabSize || 4;
+        while (i < content.length) {
+            const ch = content.charAt(i);
+            if (ch === ' ') {
+                nChars++;
+            }
+            else if (ch === '\t') {
+                nChars += tabSize;
+            }
+            else {
+                break;
+            }
+            i++;
+        }
+        return Math.floor(nChars / tabSize);
+    }
+    function isEOL(text, offset) {
+        return '\r\n'.indexOf(text.charAt(offset)) !== -1;
+    }
+    function isWhitespace(text, offset) {
+        return ' \t'.indexOf(text.charAt(offset)) !== -1;
+    }
+});

package/lib/umd/services/cssHover.js

@@ -1,163 +1,161 @@
-(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(["require", "exports", "../parser/cssNodes", "../languageFacts/facts", "./selectorPrinting", "../utils/strings", "../cssLanguageTypes", "../utils/objects"], 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 });
-    exports.CSSHover = void 0;
-    var nodes = require("../parser/cssNodes");
-    var languageFacts = require("../languageFacts/facts");
-    var selectorPrinting_1 = require("./selectorPrinting");
-    var strings_1 = require("../utils/strings");
-    var cssLanguageTypes_1 = require("../cssLanguageTypes");
-    var objects_1 = require("../utils/objects");
-    var CSSHover = /** @class */ (function () {
-        function CSSHover(clientCapabilities, cssDataManager) {
-            this.clientCapabilities = clientCapabilities;
-            this.cssDataManager = cssDataManager;
-            this.selectorPrinting = new selectorPrinting_1.SelectorPrinting(cssDataManager);
-        }
-        CSSHover.prototype.configure = function (settings) {
-            this.defaultSettings = settings;
-        };
-        CSSHover.prototype.doHover = function (document, position, stylesheet, settings) {
-            if (settings === void 0) { settings = this.defaultSettings; }
-            function getRange(node) {
-                return cssLanguageTypes_1.Range.create(document.positionAt(node.offset), document.positionAt(node.end));
-            }
-            var offset = document.offsetAt(position);
-            var nodepath = nodes.getNodePath(stylesheet, offset);
-            /**
-             * nodepath is top-down
-             * Build up the hover by appending inner node's information
-             */
-            var hover = null;
-            for (var i = 0; i < nodepath.length; i++) {
-                var node = nodepath[i];
-                if (node instanceof nodes.Selector) {
-                    hover = {
-                        contents: this.selectorPrinting.selectorToMarkedString(node),
-                        range: getRange(node)
-                    };
-                    break;
-                }
-                if (node instanceof nodes.SimpleSelector) {
-                    /**
-                     * Some sass specific at rules such as `@at-root` are parsed as `SimpleSelector`
-                     */
-                    if (!(0, strings_1.startsWith)(node.getText(), '@')) {
-                        hover = {
-                            contents: this.selectorPrinting.simpleSelectorToMarkedString(node),
-                            range: getRange(node)
-                        };
-                    }
-                    break;
-                }
-                if (node instanceof nodes.Declaration) {
-                    var propertyName = node.getFullPropertyName();
-                    var entry = this.cssDataManager.getProperty(propertyName);
-                    if (entry) {
-                        var contents = languageFacts.getEntryDescription(entry, this.doesSupportMarkdown(), settings);
-                        if (contents) {
-                            hover = {
-                                contents: contents,
-                                range: getRange(node)
-                            };
-                        }
-                        else {
-                            hover = null;
-                        }
-                    }
-                    continue;
-                }
-                if (node instanceof nodes.UnknownAtRule) {
-                    var atRuleName = node.getText();
-                    var entry = this.cssDataManager.getAtDirective(atRuleName);
-                    if (entry) {
-                        var contents = languageFacts.getEntryDescription(entry, this.doesSupportMarkdown(), settings);
-                        if (contents) {
-                            hover = {
-                                contents: contents,
-                                range: getRange(node)
-                            };
-                        }
-                        else {
-                            hover = null;
-                        }
-                    }
-                    continue;
-                }
-                if (node instanceof nodes.Node && node.type === nodes.NodeType.PseudoSelector) {
-                    var selectorName = node.getText();
-                    var entry = selectorName.slice(0, 2) === '::'
-                        ? this.cssDataManager.getPseudoElement(selectorName)
-                        : this.cssDataManager.getPseudoClass(selectorName);
-                    if (entry) {
-                        var contents = languageFacts.getEntryDescription(entry, this.doesSupportMarkdown(), settings);
-                        if (contents) {
-                            hover = {
-                                contents: contents,
-                                range: getRange(node)
-                            };
-                        }
-                        else {
-                            hover = null;
-                        }
-                    }
-                    continue;
-                }
-            }
-            if (hover) {
-                hover.contents = this.convertContents(hover.contents);
-            }
-            return hover;
-        };
-        CSSHover.prototype.convertContents = function (contents) {
-            if (!this.doesSupportMarkdown()) {
-                if (typeof contents === 'string') {
-                    return contents;
-                }
-                // MarkupContent
-                else if ('kind' in contents) {
-                    return {
-                        kind: 'plaintext',
-                        value: contents.value
-                    };
-                }
-                // MarkedString[]
-                else if (Array.isArray(contents)) {
-                    return contents.map(function (c) {
-                        return typeof c === 'string' ? c : c.value;
-                    });
-                }
-                // MarkedString
-                else {
-                    return contents.value;
-                }
-            }
-            return contents;
-        };
-        CSSHover.prototype.doesSupportMarkdown = function () {
-            if (!(0, objects_1.isDefined)(this.supportsMarkdown)) {
-                if (!(0, objects_1.isDefined)(this.clientCapabilities)) {
-                    this.supportsMarkdown = true;
-                    return this.supportsMarkdown;
-                }
-                var hover = this.clientCapabilities.textDocument && this.clientCapabilities.textDocument.hover;
-                this.supportsMarkdown = hover && hover.contentFormat && Array.isArray(hover.contentFormat) && hover.contentFormat.indexOf(cssLanguageTypes_1.MarkupKind.Markdown) !== -1;
-            }
-            return this.supportsMarkdown;
-        };
-        return CSSHover;
-    }());
-    exports.CSSHover = CSSHover;
-});
+(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(["require", "exports", "../parser/cssNodes", "../languageFacts/facts", "./selectorPrinting", "../utils/strings", "../cssLanguageTypes", "../utils/objects"], 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 });
+    exports.CSSHover = void 0;
+    const nodes = require("../parser/cssNodes");
+    const languageFacts = require("../languageFacts/facts");
+    const selectorPrinting_1 = require("./selectorPrinting");
+    const strings_1 = require("../utils/strings");
+    const cssLanguageTypes_1 = require("../cssLanguageTypes");
+    const objects_1 = require("../utils/objects");
+    class CSSHover {
+        constructor(clientCapabilities, cssDataManager) {
+            this.clientCapabilities = clientCapabilities;
+            this.cssDataManager = cssDataManager;
+            this.selectorPrinting = new selectorPrinting_1.SelectorPrinting(cssDataManager);
+        }
+        configure(settings) {
+            this.defaultSettings = settings;
+        }
+        doHover(document, position, stylesheet, settings = this.defaultSettings) {
+            function getRange(node) {
+                return cssLanguageTypes_1.Range.create(document.positionAt(node.offset), document.positionAt(node.end));
+            }
+            const offset = document.offsetAt(position);
+            const nodepath = nodes.getNodePath(stylesheet, offset);
+            /**
+             * nodepath is top-down
+             * Build up the hover by appending inner node's information
+             */
+            let hover = null;
+            for (let i = 0; i < nodepath.length; i++) {
+                const node = nodepath[i];
+                if (node instanceof nodes.Selector) {
+                    hover = {
+                        contents: this.selectorPrinting.selectorToMarkedString(node),
+                        range: getRange(node)
+                    };
+                    break;
+                }
+                if (node instanceof nodes.SimpleSelector) {
+                    /**
+                     * Some sass specific at rules such as `@at-root` are parsed as `SimpleSelector`
+                     */
+                    if (!(0, strings_1.startsWith)(node.getText(), '@')) {
+                        hover = {
+                            contents: this.selectorPrinting.simpleSelectorToMarkedString(node),
+                            range: getRange(node)
+                        };
+                    }
+                    break;
+                }
+                if (node instanceof nodes.Declaration) {
+                    const propertyName = node.getFullPropertyName();
+                    const entry = this.cssDataManager.getProperty(propertyName);
+                    if (entry) {
+                        const contents = languageFacts.getEntryDescription(entry, this.doesSupportMarkdown(), settings);
+                        if (contents) {
+                            hover = {
+                                contents,
+                                range: getRange(node)
+                            };
+                        }
+                        else {
+                            hover = null;
+                        }
+                    }
+                    continue;
+                }
+                if (node instanceof nodes.UnknownAtRule) {
+                    const atRuleName = node.getText();
+                    const entry = this.cssDataManager.getAtDirective(atRuleName);
+                    if (entry) {
+                        const contents = languageFacts.getEntryDescription(entry, this.doesSupportMarkdown(), settings);
+                        if (contents) {
+                            hover = {
+                                contents,
+                                range: getRange(node)
+                            };
+                        }
+                        else {
+                            hover = null;
+                        }
+                    }
+                    continue;
+                }
+                if (node instanceof nodes.Node && node.type === nodes.NodeType.PseudoSelector) {
+                    const selectorName = node.getText();
+                    const entry = selectorName.slice(0, 2) === '::'
+                        ? this.cssDataManager.getPseudoElement(selectorName)
+                        : this.cssDataManager.getPseudoClass(selectorName);
+                    if (entry) {
+                        const contents = languageFacts.getEntryDescription(entry, this.doesSupportMarkdown(), settings);
+                        if (contents) {
+                            hover = {
+                                contents,
+                                range: getRange(node)
+                            };
+                        }
+                        else {
+                            hover = null;
+                        }
+                    }
+                    continue;
+                }
+            }
+            if (hover) {
+                hover.contents = this.convertContents(hover.contents);
+            }
+            return hover;
+        }
+        convertContents(contents) {
+            if (!this.doesSupportMarkdown()) {
+                if (typeof contents === 'string') {
+                    return contents;
+                }
+                // MarkupContent
+                else if ('kind' in contents) {
+                    return {
+                        kind: 'plaintext',
+                        value: contents.value
+                    };
+                }
+                // MarkedString[]
+                else if (Array.isArray(contents)) {
+                    return contents.map(c => {
+                        return typeof c === 'string' ? c : c.value;
+                    });
+                }
+                // MarkedString
+                else {
+                    return contents.value;
+                }
+            }
+            return contents;
+        }
+        doesSupportMarkdown() {
+            if (!(0, objects_1.isDefined)(this.supportsMarkdown)) {
+                if (!(0, objects_1.isDefined)(this.clientCapabilities)) {
+                    this.supportsMarkdown = true;
+                    return this.supportsMarkdown;
+                }
+                const hover = this.clientCapabilities.textDocument && this.clientCapabilities.textDocument.hover;
+                this.supportsMarkdown = hover && hover.contentFormat && Array.isArray(hover.contentFormat) && hover.contentFormat.indexOf(cssLanguageTypes_1.MarkupKind.Markdown) !== -1;
+            }
+            return this.supportsMarkdown;
+        }
+    }
+    exports.CSSHover = CSSHover;
+});