monaco-editor11 1.1.2 → 1.1.4

package/dist/esm/monaco-editor/esm/external/vscode-json-languageservice/lib/esm/services/jsonValidation.js

@@ -0,0 +1,154 @@
+import { ErrorCode } from '../jsonLanguageTypes.js';
+import { t } from '../../../../@vscode/l10n/dist/browser.js';
+import { isBoolean } from '../utils/objects.js';
+import { DiagnosticSeverity, Diagnostic, Range } from '../../../../vscode-languageserver-types/lib/esm/main.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class JSONValidation {
+    constructor(jsonSchemaService, promiseConstructor) {
+        this.jsonSchemaService = jsonSchemaService;
+        this.promise = promiseConstructor;
+        this.validationEnabled = true;
+    }
+    configure(raw) {
+        if (raw) {
+            this.validationEnabled = raw.validate !== false;
+            this.commentSeverity = raw.allowComments ? undefined : DiagnosticSeverity.Error;
+        }
+    }
+    doValidation(textDocument, jsonDocument, documentSettings, schema) {
+        if (!this.validationEnabled) {
+            return this.promise.resolve([]);
+        }
+        const diagnostics = [];
+        const added = {};
+        const addProblem = (problem) => {
+            // remove duplicated messages
+            const signature = problem.range.start.line + ' ' + problem.range.start.character + ' ' + problem.message;
+            if (!added[signature]) {
+                added[signature] = true;
+                diagnostics.push(problem);
+            }
+        };
+        const getDiagnostics = (schema) => {
+            let trailingCommaSeverity = documentSettings?.trailingCommas ? toDiagnosticSeverity(documentSettings.trailingCommas) : DiagnosticSeverity.Error;
+            let commentSeverity = documentSettings?.comments ? toDiagnosticSeverity(documentSettings.comments) : this.commentSeverity;
+            let schemaValidation = documentSettings?.schemaValidation ? toDiagnosticSeverity(documentSettings.schemaValidation) : DiagnosticSeverity.Warning;
+            let schemaRequest = documentSettings?.schemaRequest ? toDiagnosticSeverity(documentSettings.schemaRequest) : DiagnosticSeverity.Warning;
+            if (schema) {
+                const addSchemaProblem = (errorMessage, errorCode) => {
+                    if (jsonDocument.root && schemaRequest) {
+                        const astRoot = jsonDocument.root;
+                        const property = astRoot.type === 'object' ? astRoot.properties[0] : undefined;
+                        if (property && property.keyNode.value === '$schema') {
+                            const node = property.valueNode || property;
+                            const range = Range.create(textDocument.positionAt(node.offset), textDocument.positionAt(node.offset + node.length));
+                            addProblem(Diagnostic.create(range, errorMessage, schemaRequest, errorCode));
+                        }
+                        else {
+                            const range = Range.create(textDocument.positionAt(astRoot.offset), textDocument.positionAt(astRoot.offset + 1));
+                            addProblem(Diagnostic.create(range, errorMessage, schemaRequest, errorCode));
+                        }
+                    }
+                };
+                if (schema.errors.length) {
+                    addSchemaProblem(schema.errors[0], ErrorCode.SchemaResolveError);
+                }
+                else if (schemaValidation) {
+                    for (const warning of schema.warnings) {
+                        addSchemaProblem(warning, ErrorCode.SchemaUnsupportedFeature);
+                    }
+                    const semanticErrors = jsonDocument.validate(textDocument, schema.schema, schemaValidation, documentSettings?.schemaDraft);
+                    if (semanticErrors) {
+                        semanticErrors.forEach(addProblem);
+                    }
+                }
+                if (schemaAllowsComments(schema.schema)) {
+                    commentSeverity = undefined;
+                }
+                if (schemaAllowsTrailingCommas(schema.schema)) {
+                    trailingCommaSeverity = undefined;
+                }
+            }
+            for (const p of jsonDocument.syntaxErrors) {
+                if (p.code === ErrorCode.TrailingComma) {
+                    if (typeof trailingCommaSeverity !== 'number') {
+                        continue;
+                    }
+                    p.severity = trailingCommaSeverity;
+                }
+                addProblem(p);
+            }
+            if (typeof commentSeverity === 'number') {
+                const message = t('Comments are not permitted in JSON.');
+                jsonDocument.comments.forEach(c => {
+                    addProblem(Diagnostic.create(c, message, commentSeverity, ErrorCode.CommentNotPermitted));
+                });
+            }
+            return diagnostics;
+        };
+        if (schema) {
+            const uri = schema.id || ('schemaservice://untitled/' + idCounter++);
+            const handle = this.jsonSchemaService.registerExternalSchema({ uri, schema });
+            return handle.getResolvedSchema().then(resolvedSchema => {
+                return getDiagnostics(resolvedSchema);
+            });
+        }
+        return this.jsonSchemaService.getSchemaForResource(textDocument.uri, jsonDocument).then(schema => {
+            return getDiagnostics(schema);
+        });
+    }
+    getLanguageStatus(textDocument, jsonDocument) {
+        return { schemas: this.jsonSchemaService.getSchemaURIsForResource(textDocument.uri, jsonDocument) };
+    }
+}
+let idCounter = 0;
+function schemaAllowsComments(schemaRef) {
+    if (schemaRef && typeof schemaRef === 'object') {
+        if (isBoolean(schemaRef.allowComments)) {
+            return schemaRef.allowComments;
+        }
+        if (schemaRef.allOf) {
+            for (const schema of schemaRef.allOf) {
+                const allow = schemaAllowsComments(schema);
+                if (isBoolean(allow)) {
+                    return allow;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function schemaAllowsTrailingCommas(schemaRef) {
+    if (schemaRef && typeof schemaRef === 'object') {
+        if (isBoolean(schemaRef.allowTrailingCommas)) {
+            return schemaRef.allowTrailingCommas;
+        }
+        const deprSchemaRef = schemaRef;
+        if (isBoolean(deprSchemaRef['allowsTrailingCommas'])) { // deprecated
+            return deprSchemaRef['allowsTrailingCommas'];
+        }
+        if (schemaRef.allOf) {
+            for (const schema of schemaRef.allOf) {
+                const allow = schemaAllowsTrailingCommas(schema);
+                if (isBoolean(allow)) {
+                    return allow;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function toDiagnosticSeverity(severityLevel) {
+    switch (severityLevel) {
+        case 'error': return DiagnosticSeverity.Error;
+        case 'warning': return DiagnosticSeverity.Warning;
+        case 'ignore': return undefined;
+    }
+    return undefined;
+}
+
+export { JSONValidation };

package/dist/esm/monaco-editor/esm/external/vscode-json-languageservice/lib/esm/utils/colors.js

@@ -0,0 +1,62 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const Digit0 = 48;
+const Digit9 = 57;
+const A = 65;
+const a = 97;
+const f = 102;
+function hexDigit(charCode) {
+    if (charCode < Digit0) {
+        return 0;
+    }
+    if (charCode <= Digit9) {
+        return charCode - Digit0;
+    }
+    if (charCode < a) {
+        charCode += (a - A);
+    }
+    if (charCode >= a && charCode <= f) {
+        return charCode - a + 10;
+    }
+    return 0;
+}
+function colorFromHex(text) {
+    if (text[0] !== '#') {
+        return undefined;
+    }
+    switch (text.length) {
+        case 4:
+            return {
+                red: (hexDigit(text.charCodeAt(1)) * 0x11) / 255.0,
+                green: (hexDigit(text.charCodeAt(2)) * 0x11) / 255.0,
+                blue: (hexDigit(text.charCodeAt(3)) * 0x11) / 255.0,
+                alpha: 1
+            };
+        case 5:
+            return {
+                red: (hexDigit(text.charCodeAt(1)) * 0x11) / 255.0,
+                green: (hexDigit(text.charCodeAt(2)) * 0x11) / 255.0,
+                blue: (hexDigit(text.charCodeAt(3)) * 0x11) / 255.0,
+                alpha: (hexDigit(text.charCodeAt(4)) * 0x11) / 255.0,
+            };
+        case 7:
+            return {
+                red: (hexDigit(text.charCodeAt(1)) * 0x10 + hexDigit(text.charCodeAt(2))) / 255.0,
+                green: (hexDigit(text.charCodeAt(3)) * 0x10 + hexDigit(text.charCodeAt(4))) / 255.0,
+                blue: (hexDigit(text.charCodeAt(5)) * 0x10 + hexDigit(text.charCodeAt(6))) / 255.0,
+                alpha: 1
+            };
+        case 9:
+            return {
+                red: (hexDigit(text.charCodeAt(1)) * 0x10 + hexDigit(text.charCodeAt(2))) / 255.0,
+                green: (hexDigit(text.charCodeAt(3)) * 0x10 + hexDigit(text.charCodeAt(4))) / 255.0,
+                blue: (hexDigit(text.charCodeAt(5)) * 0x10 + hexDigit(text.charCodeAt(6))) / 255.0,
+                alpha: (hexDigit(text.charCodeAt(7)) * 0x10 + hexDigit(text.charCodeAt(8))) / 255.0
+            };
+    }
+    return undefined;
+}
+
+export { colorFromHex, hexDigit };

package/dist/esm/monaco-editor/esm/external/vscode-json-languageservice/lib/esm/utils/format.js

@@ -0,0 +1,24 @@
+import { format as format$1 } from '../../../../jsonc-parser/lib/esm/main.js';
+import '../jsonLanguageTypes.js';
+import { TextEdit, Range } from '../../../../vscode-languageserver-types/lib/esm/main.js';
+
+function format(documentToFormat, formattingOptions, formattingRange) {
+    let range = undefined;
+    if (formattingRange) {
+        const offset = documentToFormat.offsetAt(formattingRange.start);
+        const length = documentToFormat.offsetAt(formattingRange.end) - offset;
+        range = { offset, length };
+    }
+    const options = {
+        tabSize: formattingOptions ? formattingOptions.tabSize : 4,
+        insertSpaces: formattingOptions?.insertSpaces === true,
+        insertFinalNewline: formattingOptions?.insertFinalNewline === true,
+        eol: '\n',
+        keepLines: formattingOptions?.keepLines === true
+    };
+    return format$1(documentToFormat.getText(), range, options).map(edit => {
+        return TextEdit.replace(Range.create(documentToFormat.positionAt(edit.offset), documentToFormat.positionAt(edit.offset + edit.length)), edit.content);
+    });
+}
+
+export { format };

package/dist/esm/monaco-editor/esm/external/vscode-json-languageservice/lib/esm/utils/glob.js

@@ -0,0 +1,125 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Copyright (c) 2013, Nick Fitzgerald
+ *  Licensed under the MIT License. See LICENCE.md in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function createRegex(glob, opts) {
+    if (typeof glob !== 'string') {
+        throw new TypeError('Expected a string');
+    }
+    const str = String(glob);
+    // The regexp we are building, as a string.
+    let reStr = "";
+    // Whether we are matching so called "extended" globs (like bash) and should
+    // support single character matching, matching ranges of characters, group
+    // matching, etc.
+    const extended = opts ? true : false;
+    // When globstar is _false_ (default), '/foo/*' is translated a regexp like
+    // '^\/foo\/.*$' which will match any string beginning with '/foo/'
+    // When globstar is _true_, '/foo/*' is translated to regexp like
+    // '^\/foo\/[^/]*$' which will match any string beginning with '/foo/' BUT
+    // which does not have a '/' to the right of it.
+    // E.g. with '/foo/*' these will match: '/foo/bar', '/foo/bar.txt' but
+    // these will not '/foo/bar/baz', '/foo/bar/baz.txt'
+    // Lastely, when globstar is _true_, '/foo/**' is equivelant to '/foo/*' when
+    // globstar is _false_
+    const globstar = opts ? true : false;
+    // If we are doing extended matching, this boolean is true when we are inside
+    // a group (eg {*.html,*.js}), and false otherwise.
+    let inGroup = false;
+    // RegExp flags (eg "i" ) to pass in to RegExp constructor.
+    const flags = opts && typeof (opts.flags) === "string" ? opts.flags : "";
+    let c;
+    for (let i = 0, len = str.length; i < len; i++) {
+        c = str[i];
+        switch (c) {
+            case "/":
+            case "$":
+            case "^":
+            case "+":
+            case ".":
+            case "(":
+            case ")":
+            case "=":
+            case "!":
+            case "|":
+                reStr += "\\" + c;
+                break;
+            case "?":
+                if (extended) {
+                    reStr += ".";
+                    break;
+                }
+            case "[":
+            case "]":
+                if (extended) {
+                    reStr += c;
+                    break;
+                }
+            case "{":
+                if (extended) {
+                    inGroup = true;
+                    reStr += "(";
+                    break;
+                }
+            case "}":
+                if (extended) {
+                    inGroup = false;
+                    reStr += ")";
+                    break;
+                }
+            case ",":
+                if (inGroup) {
+                    reStr += "|";
+                    break;
+                }
+                reStr += "\\" + c;
+                break;
+            case "*":
+                // Move over all consecutive "*"'s.
+                // Also store the previous and next characters
+                const prevChar = str[i - 1];
+                let starCount = 1;
+                while (str[i + 1] === "*") {
+                    starCount++;
+                    i++;
+                }
+                const nextChar = str[i + 1];
+                if (!globstar) {
+                    // globstar is disabled, so treat any number of "*" as one
+                    reStr += ".*";
+                }
+                else {
+                    // globstar is enabled, so determine if this is a globstar segment
+                    const isGlobstar = starCount > 1 // multiple "*"'s
+                        && (prevChar === "/" || prevChar === undefined || prevChar === '{' || prevChar === ',') // from the start of the segment
+                        && (nextChar === "/" || nextChar === undefined || nextChar === ',' || nextChar === '}'); // to the end of the segment
+                    if (isGlobstar) {
+                        if (nextChar === "/") {
+                            i++; // move over the "/"
+                        }
+                        else if (prevChar === '/' && reStr.endsWith('\\/')) {
+                            reStr = reStr.substr(0, reStr.length - 2);
+                        }
+                        // it's a globstar, so match zero or more path segments
+                        reStr += "((?:[^/]*(?:\/|$))*)";
+                    }
+                    else {
+                        // it's not a globstar, so only match one path segment
+                        reStr += "([^/]*)";
+                    }
+                }
+                break;
+            default:
+                reStr += c;
+        }
+    }
+    // When regexp 'g' flag is specified don't
+    // constrain the regular expression with ^ & $
+    if (!flags || !~flags.indexOf('g')) {
+        reStr = "^" + reStr + "$";
+    }
+    return new RegExp(reStr, flags);
+}
+
+export { createRegex };

package/dist/esm/monaco-editor/esm/external/vscode-json-languageservice/lib/esm/utils/json.js

@@ -0,0 +1,44 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+function stringifyObject(obj, indent, stringifyLiteral) {
+    if (obj !== null && typeof obj === 'object') {
+        const newIndent = indent + '\t';
+        if (Array.isArray(obj)) {
+            if (obj.length === 0) {
+                return '[]';
+            }
+            let result = '[\n';
+            for (let i = 0; i < obj.length; i++) {
+                result += newIndent + stringifyObject(obj[i], newIndent, stringifyLiteral);
+                if (i < obj.length - 1) {
+                    result += ',';
+                }
+                result += '\n';
+            }
+            result += indent + ']';
+            return result;
+        }
+        else {
+            const keys = Object.keys(obj);
+            if (keys.length === 0) {
+                return '{}';
+            }
+            let result = '{\n';
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i];
+                result += newIndent + JSON.stringify(key) + ': ' + stringifyObject(obj[key], newIndent, stringifyLiteral);
+                if (i < keys.length - 1) {
+                    result += ',';
+                }
+                result += '\n';
+            }
+            result += indent + '}';
+            return result;
+        }
+    }
+    return stringifyLiteral(obj);
+}
+
+export { stringifyObject };

package/dist/esm/monaco-editor/esm/external/vscode-json-languageservice/lib/esm/utils/objects.js

@@ -0,0 +1,70 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+function equals(one, other) {
+    if (one === other) {
+        return true;
+    }
+    if (one === null || one === undefined || other === null || other === undefined) {
+        return false;
+    }
+    if (typeof one !== typeof other) {
+        return false;
+    }
+    if (typeof one !== 'object') {
+        return false;
+    }
+    if ((Array.isArray(one)) !== (Array.isArray(other))) {
+        return false;
+    }
+    let i, key;
+    if (Array.isArray(one)) {
+        if (one.length !== other.length) {
+            return false;
+        }
+        for (i = 0; i < one.length; i++) {
+            if (!equals(one[i], other[i])) {
+                return false;
+            }
+        }
+    }
+    else {
+        const oneKeys = [];
+        for (key in one) {
+            oneKeys.push(key);
+        }
+        oneKeys.sort();
+        const otherKeys = [];
+        for (key in other) {
+            otherKeys.push(key);
+        }
+        otherKeys.sort();
+        if (!equals(oneKeys, otherKeys)) {
+            return false;
+        }
+        for (i = 0; i < oneKeys.length; i++) {
+            if (!equals(one[oneKeys[i]], other[oneKeys[i]])) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function isNumber(val) {
+    return typeof val === 'number';
+}
+function isDefined(val) {
+    return typeof val !== 'undefined';
+}
+function isBoolean(val) {
+    return typeof val === 'boolean';
+}
+function isString(val) {
+    return typeof val === 'string';
+}
+function isObject(val) {
+    return typeof val === 'object' && val !== null && !Array.isArray(val);
+}
+
+export { equals, isBoolean, isDefined, isNumber, isObject, isString };

package/dist/esm/monaco-editor/esm/external/vscode-json-languageservice/lib/esm/utils/propertyTree.js

@@ -0,0 +1,78 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+var Container;
+(function (Container) {
+    Container[Container["Object"] = 0] = "Object";
+    Container[Container["Array"] = 1] = "Array";
+})(Container || (Container = {}));
+class PropertyTree {
+    constructor(propertyName, beginningLineNumber) {
+        this.propertyName = propertyName ?? '';
+        this.beginningLineNumber = beginningLineNumber;
+        this.childrenProperties = [];
+        this.lastProperty = false;
+        this.noKeyName = false;
+    }
+    addChildProperty(childProperty) {
+        childProperty.parent = this;
+        if (this.childrenProperties.length > 0) {
+            let insertionIndex = 0;
+            if (childProperty.noKeyName) {
+                insertionIndex = this.childrenProperties.length;
+            }
+            else {
+                insertionIndex = binarySearchOnPropertyArray(this.childrenProperties, childProperty, compareProperties);
+            }
+            if (insertionIndex < 0) {
+                insertionIndex = (insertionIndex * -1) - 1;
+            }
+            this.childrenProperties.splice(insertionIndex, 0, childProperty);
+        }
+        else {
+            this.childrenProperties.push(childProperty);
+        }
+        return childProperty;
+    }
+}
+function compareProperties(propertyTree1, propertyTree2) {
+    const propertyName1 = propertyTree1.propertyName.toLowerCase();
+    const propertyName2 = propertyTree2.propertyName.toLowerCase();
+    if (propertyName1 < propertyName2) {
+        return -1;
+    }
+    else if (propertyName1 > propertyName2) {
+        return 1;
+    }
+    return 0;
+}
+function binarySearchOnPropertyArray(propertyTreeArray, propertyTree, compare_fn) {
+    const propertyName = propertyTree.propertyName.toLowerCase();
+    const firstPropertyInArrayName = propertyTreeArray[0].propertyName.toLowerCase();
+    const lastPropertyInArrayName = propertyTreeArray[propertyTreeArray.length - 1].propertyName.toLowerCase();
+    if (propertyName < firstPropertyInArrayName) {
+        return 0;
+    }
+    if (propertyName > lastPropertyInArrayName) {
+        return propertyTreeArray.length;
+    }
+    let m = 0;
+    let n = propertyTreeArray.length - 1;
+    while (m <= n) {
+        let k = (n + m) >> 1;
+        let cmp = compare_fn(propertyTree, propertyTreeArray[k]);
+        if (cmp > 0) {
+            m = k + 1;
+        }
+        else if (cmp < 0) {
+            n = k - 1;
+        }
+        else {
+            return k;
+        }
+    }
+    return -m - 1;
+}
+
+export { Container, PropertyTree };