vscode-css-languageservice 5.4.1 → 6.0.1

package/lib/esm/services/cssFolding.js

@@ -1,193 +1,190 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-'use strict';
-import { TokenType, Scanner } from '../parser/cssScanner';
-import { SCSSScanner, InterpolationFunction } from '../parser/scssScanner';
-import { LESSScanner } from '../parser/lessScanner';
-export function getFoldingRanges(document, context) {
-    var ranges = computeFoldingRanges(document);
-    return limitFoldingRanges(ranges, context);
-}
-function computeFoldingRanges(document) {
-    function getStartLine(t) {
-        return document.positionAt(t.offset).line;
-    }
-    function getEndLine(t) {
-        return document.positionAt(t.offset + t.len).line;
-    }
-    function getScanner() {
-        switch (document.languageId) {
-            case 'scss':
-                return new SCSSScanner();
-            case 'less':
-                return new LESSScanner();
-            default:
-                return new Scanner();
-        }
-    }
-    function tokenToRange(t, kind) {
-        var startLine = getStartLine(t);
-        var endLine = getEndLine(t);
-        if (startLine !== endLine) {
-            return {
-                startLine: startLine,
-                endLine: endLine,
-                kind: kind
-            };
-        }
-        else {
-            return null;
-        }
-    }
-    var ranges = [];
-    var delimiterStack = [];
-    var scanner = getScanner();
-    scanner.ignoreComment = false;
-    scanner.setSource(document.getText());
-    var token = scanner.scan();
-    var prevToken = null;
-    var _loop_1 = function () {
-        switch (token.type) {
-            case TokenType.CurlyL:
-            case InterpolationFunction:
-                {
-                    delimiterStack.push({ line: getStartLine(token), type: 'brace', isStart: true });
-                    break;
-                }
-            case TokenType.CurlyR: {
-                if (delimiterStack.length !== 0) {
-                    var prevDelimiter = popPrevStartDelimiterOfType(delimiterStack, 'brace');
-                    if (!prevDelimiter) {
-                        break;
-                    }
-                    var endLine = getEndLine(token);
-                    if (prevDelimiter.type === 'brace') {
-                        /**
-                         * Other than the case when curly brace is not on a new line by itself, for example
-                         * .foo {
-                         *   color: red; }
-                         * Use endLine minus one to show ending curly brace
-                         */
-                        if (prevToken && getEndLine(prevToken) !== endLine) {
-                            endLine--;
-                        }
-                        if (prevDelimiter.line !== endLine) {
-                            ranges.push({
-                                startLine: prevDelimiter.line,
-                                endLine: endLine,
-                                kind: undefined
-                            });
-                        }
-                    }
-                }
-                break;
-            }
-            /**
-             * In CSS, there is no single line comment prefixed with //
-             * All comments are marked as `Comment`
-             */
-            case TokenType.Comment: {
-                var commentRegionMarkerToDelimiter_1 = function (marker) {
-                    if (marker === '#region') {
-                        return { line: getStartLine(token), type: 'comment', isStart: true };
-                    }
-                    else {
-                        return { line: getEndLine(token), type: 'comment', isStart: false };
-                    }
-                };
-                var getCurrDelimiter = function (token) {
-                    var matches = token.text.match(/^\s*\/\*\s*(#region|#endregion)\b\s*(.*?)\s*\*\//);
-                    if (matches) {
-                        return commentRegionMarkerToDelimiter_1(matches[1]);
-                    }
-                    else if (document.languageId === 'scss' || document.languageId === 'less') {
-                        var matches_1 = token.text.match(/^\s*\/\/\s*(#region|#endregion)\b\s*(.*?)\s*/);
-                        if (matches_1) {
-                            return commentRegionMarkerToDelimiter_1(matches_1[1]);
-                        }
-                    }
-                    return null;
-                };
-                var currDelimiter = getCurrDelimiter(token);
-                // /* */ comment region folding
-                // All #region and #endregion cases
-                if (currDelimiter) {
-                    if (currDelimiter.isStart) {
-                        delimiterStack.push(currDelimiter);
-                    }
-                    else {
-                        var prevDelimiter = popPrevStartDelimiterOfType(delimiterStack, 'comment');
-                        if (!prevDelimiter) {
-                            break;
-                        }
-                        if (prevDelimiter.type === 'comment') {
-                            if (prevDelimiter.line !== currDelimiter.line) {
-                                ranges.push({
-                                    startLine: prevDelimiter.line,
-                                    endLine: currDelimiter.line,
-                                    kind: 'region'
-                                });
-                            }
-                        }
-                    }
-                }
-                // Multiline comment case
-                else {
-                    var range = tokenToRange(token, 'comment');
-                    if (range) {
-                        ranges.push(range);
-                    }
-                }
-                break;
-            }
-        }
-        prevToken = token;
-        token = scanner.scan();
-    };
-    while (token.type !== TokenType.EOF) {
-        _loop_1();
-    }
-    return ranges;
-}
-function popPrevStartDelimiterOfType(stack, type) {
-    if (stack.length === 0) {
-        return null;
-    }
-    for (var i = stack.length - 1; i >= 0; i--) {
-        if (stack[i].type === type && stack[i].isStart) {
-            return stack.splice(i, 1)[0];
-        }
-    }
-    return null;
-}
-/**
- * - Sort regions
- * - Remove invalid regions (intersections)
- * - If limit exceeds, only return `rangeLimit` amount of ranges
- */
-function limitFoldingRanges(ranges, context) {
-    var maxRanges = context && context.rangeLimit || Number.MAX_VALUE;
-    var sortedRanges = ranges.sort(function (r1, r2) {
-        var diff = r1.startLine - r2.startLine;
-        if (diff === 0) {
-            diff = r1.endLine - r2.endLine;
-        }
-        return diff;
-    });
-    var validRanges = [];
-    var prevEndLine = -1;
-    sortedRanges.forEach(function (r) {
-        if (!(r.startLine < prevEndLine && prevEndLine < r.endLine)) {
-            validRanges.push(r);
-            prevEndLine = r.endLine;
-        }
-    });
-    if (validRanges.length < maxRanges) {
-        return validRanges;
-    }
-    else {
-        return validRanges.slice(0, maxRanges);
-    }
-}
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+import { TokenType, Scanner } from '../parser/cssScanner';
+import { SCSSScanner, InterpolationFunction } from '../parser/scssScanner';
+import { LESSScanner } from '../parser/lessScanner';
+export function getFoldingRanges(document, context) {
+    const ranges = computeFoldingRanges(document);
+    return limitFoldingRanges(ranges, context);
+}
+function computeFoldingRanges(document) {
+    function getStartLine(t) {
+        return document.positionAt(t.offset).line;
+    }
+    function getEndLine(t) {
+        return document.positionAt(t.offset + t.len).line;
+    }
+    function getScanner() {
+        switch (document.languageId) {
+            case 'scss':
+                return new SCSSScanner();
+            case 'less':
+                return new LESSScanner();
+            default:
+                return new Scanner();
+        }
+    }
+    function tokenToRange(t, kind) {
+        const startLine = getStartLine(t);
+        const endLine = getEndLine(t);
+        if (startLine !== endLine) {
+            return {
+                startLine,
+                endLine,
+                kind
+            };
+        }
+        else {
+            return null;
+        }
+    }
+    const ranges = [];
+    const delimiterStack = [];
+    const scanner = getScanner();
+    scanner.ignoreComment = false;
+    scanner.setSource(document.getText());
+    let token = scanner.scan();
+    let prevToken = null;
+    while (token.type !== TokenType.EOF) {
+        switch (token.type) {
+            case TokenType.CurlyL:
+            case InterpolationFunction:
+                {
+                    delimiterStack.push({ line: getStartLine(token), type: 'brace', isStart: true });
+                    break;
+                }
+            case TokenType.CurlyR: {
+                if (delimiterStack.length !== 0) {
+                    const prevDelimiter = popPrevStartDelimiterOfType(delimiterStack, 'brace');
+                    if (!prevDelimiter) {
+                        break;
+                    }
+                    let endLine = getEndLine(token);
+                    if (prevDelimiter.type === 'brace') {
+                        /**
+                         * Other than the case when curly brace is not on a new line by itself, for example
+                         * .foo {
+                         *   color: red; }
+                         * Use endLine minus one to show ending curly brace
+                         */
+                        if (prevToken && getEndLine(prevToken) !== endLine) {
+                            endLine--;
+                        }
+                        if (prevDelimiter.line !== endLine) {
+                            ranges.push({
+                                startLine: prevDelimiter.line,
+                                endLine,
+                                kind: undefined
+                            });
+                        }
+                    }
+                }
+                break;
+            }
+            /**
+             * In CSS, there is no single line comment prefixed with //
+             * All comments are marked as `Comment`
+             */
+            case TokenType.Comment: {
+                const commentRegionMarkerToDelimiter = (marker) => {
+                    if (marker === '#region') {
+                        return { line: getStartLine(token), type: 'comment', isStart: true };
+                    }
+                    else {
+                        return { line: getEndLine(token), type: 'comment', isStart: false };
+                    }
+                };
+                const getCurrDelimiter = (token) => {
+                    const matches = token.text.match(/^\s*\/\*\s*(#region|#endregion)\b\s*(.*?)\s*\*\//);
+                    if (matches) {
+                        return commentRegionMarkerToDelimiter(matches[1]);
+                    }
+                    else if (document.languageId === 'scss' || document.languageId === 'less') {
+                        const matches = token.text.match(/^\s*\/\/\s*(#region|#endregion)\b\s*(.*?)\s*/);
+                        if (matches) {
+                            return commentRegionMarkerToDelimiter(matches[1]);
+                        }
+                    }
+                    return null;
+                };
+                const currDelimiter = getCurrDelimiter(token);
+                // /* */ comment region folding
+                // All #region and #endregion cases
+                if (currDelimiter) {
+                    if (currDelimiter.isStart) {
+                        delimiterStack.push(currDelimiter);
+                    }
+                    else {
+                        const prevDelimiter = popPrevStartDelimiterOfType(delimiterStack, 'comment');
+                        if (!prevDelimiter) {
+                            break;
+                        }
+                        if (prevDelimiter.type === 'comment') {
+                            if (prevDelimiter.line !== currDelimiter.line) {
+                                ranges.push({
+                                    startLine: prevDelimiter.line,
+                                    endLine: currDelimiter.line,
+                                    kind: 'region'
+                                });
+                            }
+                        }
+                    }
+                }
+                // Multiline comment case
+                else {
+                    const range = tokenToRange(token, 'comment');
+                    if (range) {
+                        ranges.push(range);
+                    }
+                }
+                break;
+            }
+        }
+        prevToken = token;
+        token = scanner.scan();
+    }
+    return ranges;
+}
+function popPrevStartDelimiterOfType(stack, type) {
+    if (stack.length === 0) {
+        return null;
+    }
+    for (let i = stack.length - 1; i >= 0; i--) {
+        if (stack[i].type === type && stack[i].isStart) {
+            return stack.splice(i, 1)[0];
+        }
+    }
+    return null;
+}
+/**
+ * - Sort regions
+ * - Remove invalid regions (intersections)
+ * - If limit exceeds, only return `rangeLimit` amount of ranges
+ */
+function limitFoldingRanges(ranges, context) {
+    const maxRanges = context && context.rangeLimit || Number.MAX_VALUE;
+    const sortedRanges = ranges.sort((r1, r2) => {
+        let diff = r1.startLine - r2.startLine;
+        if (diff === 0) {
+            diff = r1.endLine - r2.endLine;
+        }
+        return diff;
+    });
+    const validRanges = [];
+    let prevEndLine = -1;
+    sortedRanges.forEach(r => {
+        if (!(r.startLine < prevEndLine && prevEndLine < r.endLine)) {
+            validRanges.push(r);
+            prevEndLine = r.endLine;
+        }
+    });
+    if (validRanges.length < maxRanges) {
+        return validRanges;
+    }
+    else {
+        return validRanges.slice(0, maxRanges);
+    }
+}

package/lib/esm/services/cssFormatter.js

@@ -1,136 +1,136 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import { Range, Position } from '../cssLanguageTypes';
-import { css_beautify } from '../beautify/beautify-css';
-import { repeat } from '../utils/strings';
-export 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 = 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(Position.create(range.start.line, 0));
-            initialIndentLevel = computeIndentLevel(document.getText(), startOfLineOffset, options);
-        }
-        if (inRule) {
-            value = "{\n".concat(trimLeft(value));
-        }
-    }
-    else {
-        range = Range.create(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 = css_beautify(value, cssOptions);
-    if (inRule) {
-        result = trimLeft(result.substring(2));
-    }
-    if (initialIndentLevel > 0) {
-        var indent = options.insertSpaces ? repeat(' ', tabSize * initialIndentLevel) : 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
-        }];
-}
-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.
+ *--------------------------------------------------------------------------------------------*/
+import { Range, Position } from '../cssLanguageTypes';
+import { css_beautify } from '../beautify/beautify-css';
+import { repeat } from '../utils/strings';
+export 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 = 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(Position.create(range.start.line, 0));
+            initialIndentLevel = computeIndentLevel(document.getText(), startOfLineOffset, options);
+        }
+        if (inRule) {
+            value = `{\n${trimLeft(value)}`;
+        }
+    }
+    else {
+        range = Range.create(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 = css_beautify(value, cssOptions);
+    if (inRule) {
+        result = trimLeft(result.substring(2));
+    }
+    if (initialIndentLevel > 0) {
+        const indent = options.insertSpaces ? repeat(' ', tabSize * initialIndentLevel) : 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
+        }];
+}
+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;
+}