monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/kotlin.js

@@ -0,0 +1,251 @@
+const conf = {
+  // the default separators except `@$`
+  wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+  comments: {
+    lineComment: "//",
+    blockComment: ["/*", "*/"]
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" }
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" },
+    { open: "<", close: ">" }
+  ],
+  folding: {
+    markers: {
+      start: new RegExp("^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))"),
+      end: new RegExp("^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))")
+    }
+  }
+};
+const language = {
+  defaultToken: "",
+  tokenPostfix: ".kt",
+  keywords: [
+    "as",
+    "as?",
+    "break",
+    "class",
+    "continue",
+    "do",
+    "else",
+    "false",
+    "for",
+    "fun",
+    "if",
+    "in",
+    "!in",
+    "interface",
+    "is",
+    "!is",
+    "null",
+    "object",
+    "package",
+    "return",
+    "super",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typealias",
+    "val",
+    "var",
+    "when",
+    "while",
+    "by",
+    "catch",
+    "constructor",
+    "delegate",
+    "dynamic",
+    "field",
+    "file",
+    "finally",
+    "get",
+    "import",
+    "init",
+    "param",
+    "property",
+    "receiver",
+    "set",
+    "setparam",
+    "where",
+    "actual",
+    "abstract",
+    "annotation",
+    "companion",
+    "const",
+    "crossinline",
+    "data",
+    "enum",
+    "expect",
+    "external",
+    "final",
+    "infix",
+    "inline",
+    "inner",
+    "internal",
+    "lateinit",
+    "noinline",
+    "open",
+    "operator",
+    "out",
+    "override",
+    "private",
+    "protected",
+    "public",
+    "reified",
+    "sealed",
+    "suspend",
+    "tailrec",
+    "vararg",
+    "field",
+    "it"
+  ],
+  operators: [
+    "+",
+    "-",
+    "*",
+    "/",
+    "%",
+    "=",
+    "+=",
+    "-=",
+    "*=",
+    "/=",
+    "%=",
+    "++",
+    "--",
+    "&&",
+    "||",
+    "!",
+    "==",
+    "!=",
+    "===",
+    "!==",
+    ">",
+    "<",
+    "<=",
+    ">=",
+    "[",
+    "]",
+    "!!",
+    "?.",
+    "?:",
+    "::",
+    "..",
+    ":",
+    "?",
+    "->",
+    "@",
+    ";",
+    "$",
+    "_"
+  ],
+  // we include these common regular expressions
+  symbols: /[=><!~?:&|+\-*\/\^%]+/,
+  escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  digits: /\d+(_+\d+)*/,
+  octaldigits: /[0-7]+(_+[0-7]+)*/,
+  binarydigits: /[0-1]+(_+[0-1]+)*/,
+  hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+  // The main tokenizer for our languages
+  tokenizer: {
+    root: [
+      // class name highlighting
+      [/[A-Z][\w\$]*/, "type.identifier"],
+      // identifiers and keywords
+      [
+        /[a-zA-Z_$][\w$]*/,
+        {
+          cases: {
+            "@keywords": { token: "keyword.$0" },
+            "@default": "identifier"
+          }
+        }
+      ],
+      // whitespace
+      { include: "@whitespace" },
+      // delimiters and operators
+      [/[{}()\[\]]/, "@brackets"],
+      [/[<>](?!@symbols)/, "@brackets"],
+      [
+        /@symbols/,
+        {
+          cases: {
+            "@operators": "delimiter",
+            "@default": ""
+          }
+        }
+      ],
+      // @ annotations.
+      [/@\s*[a-zA-Z_\$][\w\$]*/, "annotation"],
+      // numbers
+      [/(@digits)[eE]([\-+]?(@digits))?[fF]?/, "number.float"],
+      [/(@digits)?\.(@digits)([eE][\-+]?(@digits))?[fF]?/, "number.float"],
+      [/0[xX](@hexdigits)[uU]?L?/, "number.hex"],
+      [/0[bB](@binarydigits)[uU]?L?/, "number.binary"],
+      [/(@digits)[fF]/, "number.float"],
+      [/(@digits)[uU]?L?/, "number"],
+      // delimiter: after number because of .\d floats
+      [/[;,.]/, "delimiter"],
+      // strings
+      [/"([^"\\]|\\.)*$/, "string.invalid"],
+      // non-teminated string
+      [/"""/, "string", "@multistring"],
+      [/"/, "string", "@string"],
+      // characters
+      [/'[^\\']'/, "string"],
+      [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+      [/'/, "string.invalid"]
+    ],
+    whitespace: [
+      [/[ \t\r\n]+/, ""],
+      [/\/\*\*(?!\/)/, "comment.doc", "@javadoc"],
+      [/\/\*/, "comment", "@comment"],
+      [/\/\/.*$/, "comment"]
+    ],
+    comment: [
+      [/[^\/*]+/, "comment"],
+      [/\/\*/, "comment", "@comment"],
+      [/\*\//, "comment", "@pop"],
+      [/[\/*]/, "comment"]
+    ],
+    //Identical copy of comment above, except for the addition of .doc
+    javadoc: [
+      [/[^\/*]+/, "comment.doc"],
+      [/\/\*/, "comment.doc", "@push"],
+      [/\/\*/, "comment.doc.invalid"],
+      [/\*\//, "comment.doc", "@pop"],
+      [/[\/*]/, "comment.doc"]
+    ],
+    string: [
+      [/[^\\"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/"/, "string", "@pop"]
+    ],
+    multistring: [
+      [/[^\\"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/"""/, "string", "@pop"],
+      [/./, "string"]
+    ]
+  }
+};
+
+export { conf, language };

package/dist/workers/label.js

@@ -0,0 +1,5 @@
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+
+const ILabelService = createDecorator('labelService');
+
+export { ILabelService };

package/dist/workers/labels.js

@@ -0,0 +1,15 @@
+import { hasDriveLetter } from './extpath.js';
+import { isWindows } from './platform.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function normalizeDriveLetter(path, isWindowsOS = isWindows) {
+    if (hasDriveLetter(path, isWindowsOS)) {
+        return path.charAt(0).toUpperCase() + path.slice(1);
+    }
+    return path;
+}
+
+export { normalizeDriveLetter };

package/dist/workers/language.js

@@ -0,0 +1,9 @@
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const ILanguageService = createDecorator('languageService');
+
+export { ILanguageService };

package/dist/workers/languageBracketsConfiguration.js

@@ -0,0 +1,133 @@
+import { CachedFunction } from '../../../../base/common/cache.js';
+import { createBracketOrRegExp } from './richEditBrackets.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Captures all bracket related configurations for a single language.
+ * Immutable.
+*/
+class LanguageBracketsConfiguration {
+    constructor(languageId, config) {
+        this.languageId = languageId;
+        const bracketPairs = config.brackets ? filterValidBrackets(config.brackets) : [];
+        const openingBracketInfos = new CachedFunction((bracket) => {
+            const closing = new Set();
+            return {
+                info: new OpeningBracketKind(this, bracket, closing),
+                closing,
+            };
+        });
+        const closingBracketInfos = new CachedFunction((bracket) => {
+            const opening = new Set();
+            const openingColorized = new Set();
+            return {
+                info: new ClosingBracketKind(this, bracket, opening, openingColorized),
+                opening,
+                openingColorized,
+            };
+        });
+        for (const [open, close] of bracketPairs) {
+            const opening = openingBracketInfos.get(open);
+            const closing = closingBracketInfos.get(close);
+            opening.closing.add(closing.info);
+            closing.opening.add(opening.info);
+        }
+        // Treat colorized brackets as brackets, and mark them as colorized.
+        const colorizedBracketPairs = config.colorizedBracketPairs
+            ? filterValidBrackets(config.colorizedBracketPairs)
+            // If not configured: Take all brackets except `<` ... `>`
+            // Many languages set < ... > as bracket pair, even though they also use it as comparison operator.
+            // This leads to problems when colorizing this bracket, so we exclude it if not explicitly configured otherwise.
+            // https://github.com/microsoft/vscode/issues/132476
+            : bracketPairs.filter((p) => !(p[0] === '<' && p[1] === '>'));
+        for (const [open, close] of colorizedBracketPairs) {
+            const opening = openingBracketInfos.get(open);
+            const closing = closingBracketInfos.get(close);
+            opening.closing.add(closing.info);
+            closing.openingColorized.add(opening.info);
+            closing.opening.add(opening.info);
+        }
+        this._openingBrackets = new Map([...openingBracketInfos.cachedValues].map(([k, v]) => [k, v.info]));
+        this._closingBrackets = new Map([...closingBracketInfos.cachedValues].map(([k, v]) => [k, v.info]));
+    }
+    /**
+     * No two brackets have the same bracket text.
+    */
+    get openingBrackets() {
+        return [...this._openingBrackets.values()];
+    }
+    /**
+     * No two brackets have the same bracket text.
+    */
+    get closingBrackets() {
+        return [...this._closingBrackets.values()];
+    }
+    getOpeningBracketInfo(bracketText) {
+        return this._openingBrackets.get(bracketText);
+    }
+    getClosingBracketInfo(bracketText) {
+        return this._closingBrackets.get(bracketText);
+    }
+    getBracketInfo(bracketText) {
+        return this.getOpeningBracketInfo(bracketText) || this.getClosingBracketInfo(bracketText);
+    }
+    getBracketRegExp(options) {
+        const brackets = Array.from([...this._openingBrackets.keys(), ...this._closingBrackets.keys()]);
+        return createBracketOrRegExp(brackets, options);
+    }
+}
+function filterValidBrackets(bracketPairs) {
+    return bracketPairs.filter(([open, close]) => open !== '' && close !== '');
+}
+class BracketKindBase {
+    constructor(config, bracketText) {
+        this.config = config;
+        this.bracketText = bracketText;
+    }
+    get languageId() {
+        return this.config.languageId;
+    }
+}
+class OpeningBracketKind extends BracketKindBase {
+    constructor(config, bracketText, openedBrackets) {
+        super(config, bracketText);
+        this.openedBrackets = openedBrackets;
+        this.isOpeningBracket = true;
+    }
+}
+class ClosingBracketKind extends BracketKindBase {
+    constructor(config, bracketText, 
+    /**
+     * Non empty array of all opening brackets this bracket closes.
+    */
+    openingBrackets, openingColorizedBrackets) {
+        super(config, bracketText);
+        this.openingBrackets = openingBrackets;
+        this.openingColorizedBrackets = openingColorizedBrackets;
+        this.isOpeningBracket = false;
+    }
+    /**
+     * Checks if this bracket closes the given other bracket.
+     * If the bracket infos come from different configurations, this method will return false.
+    */
+    closes(other) {
+        if (other['config'] !== this.config) {
+            return false;
+        }
+        return this.openingBrackets.has(other);
+    }
+    closesColorized(other) {
+        if (other['config'] !== this.config) {
+            return false;
+        }
+        return this.openingColorizedBrackets.has(other);
+    }
+    getOpeningBrackets() {
+        return [...this.openingBrackets];
+    }
+}
+
+export { BracketKindBase, ClosingBracketKind, LanguageBracketsConfiguration, OpeningBracketKind };

package/dist/workers/languageConfiguration.js

@@ -0,0 +1,138 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Describes what to do with the indentation when pressing Enter.
+ */
+var IndentAction;
+(function (IndentAction) {
+    /**
+     * Insert new line and copy the previous line's indentation.
+     */
+    IndentAction[IndentAction["None"] = 0] = "None";
+    /**
+     * Insert new line and indent once (relative to the previous line's indentation).
+     */
+    IndentAction[IndentAction["Indent"] = 1] = "Indent";
+    /**
+     * Insert two new lines:
+     *  - the first one indented which will hold the cursor
+     *  - the second one at the same indentation level
+     */
+    IndentAction[IndentAction["IndentOutdent"] = 2] = "IndentOutdent";
+    /**
+     * Insert new line and outdent once (relative to the previous line's indentation).
+     */
+    IndentAction[IndentAction["Outdent"] = 3] = "Outdent";
+})(IndentAction || (IndentAction = {}));
+/**
+ * @internal
+ */
+class StandardAutoClosingPairConditional {
+    constructor(source) {
+        this._neutralCharacter = null;
+        this._neutralCharacterSearched = false;
+        this.open = source.open;
+        this.close = source.close;
+        // initially allowed in all tokens
+        this._inString = true;
+        this._inComment = true;
+        this._inRegEx = true;
+        if (Array.isArray(source.notIn)) {
+            for (let i = 0, len = source.notIn.length; i < len; i++) {
+                const notIn = source.notIn[i];
+                switch (notIn) {
+                    case 'string':
+                        this._inString = false;
+                        break;
+                    case 'comment':
+                        this._inComment = false;
+                        break;
+                    case 'regex':
+                        this._inRegEx = false;
+                        break;
+                }
+            }
+        }
+    }
+    isOK(standardToken) {
+        switch (standardToken) {
+            case 0 /* StandardTokenType.Other */:
+                return true;
+            case 1 /* StandardTokenType.Comment */:
+                return this._inComment;
+            case 2 /* StandardTokenType.String */:
+                return this._inString;
+            case 3 /* StandardTokenType.RegEx */:
+                return this._inRegEx;
+        }
+    }
+    shouldAutoClose(context, column) {
+        // Always complete on empty line
+        if (context.getTokenCount() === 0) {
+            return true;
+        }
+        const tokenIndex = context.findTokenIndexAtOffset(column - 2);
+        const standardTokenType = context.getStandardTokenType(tokenIndex);
+        return this.isOK(standardTokenType);
+    }
+    _findNeutralCharacterInRange(fromCharCode, toCharCode) {
+        for (let charCode = fromCharCode; charCode <= toCharCode; charCode++) {
+            const character = String.fromCharCode(charCode);
+            if (!this.open.includes(character) && !this.close.includes(character)) {
+                return character;
+            }
+        }
+        return null;
+    }
+    /**
+     * Find a character in the range [0-9a-zA-Z] that does not appear in the open or close
+     */
+    findNeutralCharacter() {
+        if (!this._neutralCharacterSearched) {
+            this._neutralCharacterSearched = true;
+            if (!this._neutralCharacter) {
+                this._neutralCharacter = this._findNeutralCharacterInRange(48 /* CharCode.Digit0 */, 57 /* CharCode.Digit9 */);
+            }
+            if (!this._neutralCharacter) {
+                this._neutralCharacter = this._findNeutralCharacterInRange(97 /* CharCode.a */, 122 /* CharCode.z */);
+            }
+            if (!this._neutralCharacter) {
+                this._neutralCharacter = this._findNeutralCharacterInRange(65 /* CharCode.A */, 90 /* CharCode.Z */);
+            }
+        }
+        return this._neutralCharacter;
+    }
+}
+/**
+ * @internal
+ */
+class AutoClosingPairs {
+    constructor(autoClosingPairs) {
+        this.autoClosingPairsOpenByStart = new Map();
+        this.autoClosingPairsOpenByEnd = new Map();
+        this.autoClosingPairsCloseByStart = new Map();
+        this.autoClosingPairsCloseByEnd = new Map();
+        this.autoClosingPairsCloseSingleChar = new Map();
+        for (const pair of autoClosingPairs) {
+            appendEntry(this.autoClosingPairsOpenByStart, pair.open.charAt(0), pair);
+            appendEntry(this.autoClosingPairsOpenByEnd, pair.open.charAt(pair.open.length - 1), pair);
+            appendEntry(this.autoClosingPairsCloseByStart, pair.close.charAt(0), pair);
+            appendEntry(this.autoClosingPairsCloseByEnd, pair.close.charAt(pair.close.length - 1), pair);
+            if (pair.close.length === 1 && pair.open.length === 1) {
+                appendEntry(this.autoClosingPairsCloseSingleChar, pair.close, pair);
+            }
+        }
+    }
+}
+function appendEntry(target, key, value) {
+    if (target.has(key)) {
+        target.get(key).push(value);
+    }
+    else {
+        target.set(key, [value]);
+    }
+}
+
+export { AutoClosingPairs, IndentAction, StandardAutoClosingPairConditional };