@codingame/monaco-vscode-api 1.85.4 → 2.0.0-rework-ci.1

package/vscode/src/vs/base/common/types.js

@@ -0,0 +1,106 @@
+function isString(str) {
+    return (typeof str === 'string');
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every(elem => isString(elem));
+}
+function isObject(obj) {
+    return typeof obj === 'object'
+        && obj !== null
+        && !Array.isArray(obj)
+        && !(obj instanceof RegExp)
+        && !(obj instanceof Date);
+}
+function isTypedArray(obj) {
+    const TypedArray = Object.getPrototypeOf(Uint8Array);
+    return typeof obj === 'object'
+        && obj instanceof TypedArray;
+}
+function isNumber(obj) {
+    return (typeof obj === 'number' && !isNaN(obj));
+}
+function isIterable(obj) {
+    return !!obj && typeof obj[Symbol.iterator] === 'function';
+}
+function isBoolean(obj) {
+    return (obj === true || obj === false);
+}
+function isUndefined(obj) {
+    return (typeof obj === 'undefined');
+}
+function isDefined(arg) {
+    return !isUndefinedOrNull(arg);
+}
+function isUndefinedOrNull(obj) {
+    return (isUndefined(obj) || obj === null);
+}
+function assertType(condition, type) {
+    if (!condition) {
+        throw new Error(type ? `Unexpected type, expected '${type}'` : 'Unexpected type');
+    }
+}
+function assertIsDefined(arg) {
+    if (isUndefinedOrNull(arg)) {
+        throw new Error('Assertion Failed: argument is undefined or null');
+    }
+    return arg;
+}
+function assertAllDefined(...args) {
+    const result = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (isUndefinedOrNull(arg)) {
+            throw new Error(`Assertion Failed: argument at index ${i} is undefined or null`);
+        }
+        result.push(arg);
+    }
+    return result;
+}
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function isEmptyObject(obj) {
+    if (!isObject(obj)) {
+        return false;
+    }
+    for (const key in obj) {
+        if (hasOwnProperty.call(obj, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isFunction(obj) {
+    return (typeof obj === 'function');
+}
+function areFunctions(...objects) {
+    return objects.length > 0 && objects.every(isFunction);
+}
+function validateConstraints(args, constraints) {
+    const len = Math.min(args.length, constraints.length);
+    for (let i = 0; i < len; i++) {
+        validateConstraint(args[i], constraints[i]);
+    }
+}
+function validateConstraint(arg, constraint) {
+    if (isString(constraint)) {
+        if (typeof arg !== constraint) {
+            throw new Error(`argument does not match constraint: typeof ${constraint}`);
+        }
+    }
+    else if (isFunction(constraint)) {
+        try {
+            if (arg instanceof constraint) {
+                return;
+            }
+        }
+        catch {
+        }
+        if (!isUndefinedOrNull(arg) && arg.constructor === constraint) {
+            return;
+        }
+        if (constraint.length === 1 && constraint.call(undefined, arg) === true) {
+            return;
+        }
+        throw new Error(`argument does not match one of these constraints: arg instanceof constraint, arg.constructor === constraint, nor constraint(arg) === true`);
+    }
+}
+export { areFunctions, assertAllDefined, assertIsDefined, assertType, isBoolean, isDefined, isEmptyObject, isFunction, isIterable, isNumber, isObject, isString, isStringArray, isTypedArray, isUndefined, isUndefinedOrNull, validateConstraint, validateConstraints };

package/vscode/src/vs/base/common/uint.js

@@ -0,0 +1,19 @@
+function toUint8(v) {
+    if (v < 0) {
+        return 0;
+    }
+    if (v > 255 ) {
+        return 255 ;
+    }
+    return v | 0;
+}
+function toUint32(v) {
+    if (v < 0) {
+        return 0;
+    }
+    if (v > 4294967295 ) {
+        return 4294967295 ;
+    }
+    return v | 0;
+}
+export { toUint32, toUint8 };

package/vscode/src/vs/base/common/uri.js

@@ -0,0 +1,454 @@
+import { win32, posix } from './path.js';
+import { isWindows } from './platform.js';
+const _schemePattern = /^\w[\w\d+.-]*$/;
+const _singleSlashStart = /^\//;
+const _doubleSlashStart = /^\/\//;
+function _validateUri(ret, _strict) {
+    if (!ret.scheme && _strict) {
+        throw new Error(`[UriError]: Scheme is missing: {scheme: "", authority: "${ret.authority}", path: "${ret.path}", query: "${ret.query}", fragment: "${ret.fragment}"}`);
+    }
+    if (ret.scheme && !_schemePattern.test(ret.scheme)) {
+        throw new Error('[UriError]: Scheme contains illegal characters.');
+    }
+    if (ret.path) {
+        if (ret.authority) {
+            if (!_singleSlashStart.test(ret.path)) {
+                throw new Error('[UriError]: If a URI contains an authority component, then the path component must either be empty or begin with a slash ("/") character');
+            }
+        }
+        else {
+            if (_doubleSlashStart.test(ret.path)) {
+                throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters ("//")');
+            }
+        }
+    }
+}
+function _schemeFix(scheme, _strict) {
+    if (!scheme && !_strict) {
+        return 'file';
+    }
+    return scheme;
+}
+function _referenceResolution(scheme, path) {
+    switch (scheme) {
+        case 'https':
+        case 'http':
+        case 'file':
+            if (!path) {
+                path = _slash;
+            }
+            else if (path[0] !== _slash) {
+                path = _slash + path;
+            }
+            break;
+    }
+    return path;
+}
+const _empty = '';
+const _slash = '/';
+const _regexp = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
+class URI {
+    static isUri(thing) {
+        if (thing instanceof URI) {
+            return true;
+        }
+        if (!thing) {
+            return false;
+        }
+        return typeof thing.authority === 'string'
+            && typeof thing.fragment === 'string'
+            && typeof thing.path === 'string'
+            && typeof thing.query === 'string'
+            && typeof thing.scheme === 'string'
+            && typeof thing.fsPath === 'string'
+            && typeof thing.with === 'function'
+            && typeof thing.toString === 'function';
+    }
+    constructor(schemeOrData, authority, path, query, fragment, _strict = false) {
+        if (typeof schemeOrData === 'object') {
+            this.scheme = schemeOrData.scheme || _empty;
+            this.authority = schemeOrData.authority || _empty;
+            this.path = schemeOrData.path || _empty;
+            this.query = schemeOrData.query || _empty;
+            this.fragment = schemeOrData.fragment || _empty;
+        }
+        else {
+            this.scheme = _schemeFix(schemeOrData, _strict);
+            this.authority = authority || _empty;
+            this.path = _referenceResolution(this.scheme, path || _empty);
+            this.query = query || _empty;
+            this.fragment = fragment || _empty;
+            _validateUri(this, _strict);
+        }
+    }
+    get fsPath() {
+        return uriToFsPath(this, false);
+    }
+    with(change) {
+        if (!change) {
+            return this;
+        }
+        let { scheme, authority, path, query, fragment } = change;
+        if (scheme === undefined) {
+            scheme = this.scheme;
+        }
+        else if (scheme === null) {
+            scheme = _empty;
+        }
+        if (authority === undefined) {
+            authority = this.authority;
+        }
+        else if (authority === null) {
+            authority = _empty;
+        }
+        if (path === undefined) {
+            path = this.path;
+        }
+        else if (path === null) {
+            path = _empty;
+        }
+        if (query === undefined) {
+            query = this.query;
+        }
+        else if (query === null) {
+            query = _empty;
+        }
+        if (fragment === undefined) {
+            fragment = this.fragment;
+        }
+        else if (fragment === null) {
+            fragment = _empty;
+        }
+        if (scheme === this.scheme
+            && authority === this.authority
+            && path === this.path
+            && query === this.query
+            && fragment === this.fragment) {
+            return this;
+        }
+        return ( new Uri(scheme, authority, path, query, fragment));
+    }
+    static parse(value, _strict = false) {
+        const match = _regexp.exec(value);
+        if (!match) {
+            return ( new Uri(_empty, _empty, _empty, _empty, _empty));
+        }
+        return ( new Uri(
+            match[2] || _empty,
+            percentDecode(match[4] || _empty),
+            percentDecode(match[5] || _empty),
+            percentDecode(match[7] || _empty),
+            percentDecode(match[9] || _empty),
+            _strict
+        ));
+    }
+    static file(path) {
+        let authority = _empty;
+        if (isWindows) {
+            path = path.replace(/\\/g, _slash);
+        }
+        if (path[0] === _slash && path[1] === _slash) {
+            const idx = path.indexOf(_slash, 2);
+            if (idx === -1) {
+                authority = path.substring(2);
+                path = _slash;
+            }
+            else {
+                authority = path.substring(2, idx);
+                path = path.substring(idx) || _slash;
+            }
+        }
+        return ( new Uri('file', authority, path, _empty, _empty));
+    }
+    static from(components, strict) {
+        const result = ( new Uri(
+            components.scheme,
+            components.authority,
+            components.path,
+            components.query,
+            components.fragment,
+            strict
+        ));
+        return result;
+    }
+    static joinPath(uri, ...pathFragment) {
+        if (!uri.path) {
+            throw new Error(`[UriError]: cannot call joinPath on URI without path`);
+        }
+        let newPath;
+        if (isWindows && uri.scheme === 'file') {
+            newPath = URI.file(win32.join(uriToFsPath(uri, true), ...pathFragment)).path;
+        }
+        else {
+            newPath = posix.join(uri.path, ...pathFragment);
+        }
+        return uri.with({ path: newPath });
+    }
+    toString(skipEncoding = false) {
+        return _asFormatted(this, skipEncoding);
+    }
+    toJSON() {
+        return this;
+    }
+    static revive(data) {
+        if (!data) {
+            return data;
+        }
+        else if (data instanceof URI) {
+            return data;
+        }
+        else {
+            const result = ( new Uri(data));
+            result._formatted = data.external ?? null;
+            result._fsPath = data._sep === _pathSepMarker ? data.fsPath ?? null : null;
+            return result;
+        }
+    }
+}
+const _pathSepMarker = isWindows ? 1 : undefined;
+class Uri extends URI {
+    constructor() {
+        super(...arguments);
+        this._formatted = null;
+        this._fsPath = null;
+    }
+    get fsPath() {
+        if (!this._fsPath) {
+            this._fsPath = uriToFsPath(this, false);
+        }
+        return this._fsPath;
+    }
+    toString(skipEncoding = false) {
+        if (!skipEncoding) {
+            if (!this._formatted) {
+                this._formatted = _asFormatted(this, false);
+            }
+            return this._formatted;
+        }
+        else {
+            return _asFormatted(this, true);
+        }
+    }
+    toJSON() {
+        const res = {
+            $mid: 1
+        };
+        if (this._fsPath) {
+            res.fsPath = this._fsPath;
+            res._sep = _pathSepMarker;
+        }
+        if (this._formatted) {
+            res.external = this._formatted;
+        }
+        if (this.path) {
+            res.path = this.path;
+        }
+        if (this.scheme) {
+            res.scheme = this.scheme;
+        }
+        if (this.authority) {
+            res.authority = this.authority;
+        }
+        if (this.query) {
+            res.query = this.query;
+        }
+        if (this.fragment) {
+            res.fragment = this.fragment;
+        }
+        return res;
+    }
+}
+const encodeTable = {
+    [58 ]: '%3A',
+    [47 ]: '%2F',
+    [63 ]: '%3F',
+    [35 ]: '%23',
+    [91 ]: '%5B',
+    [93 ]: '%5D',
+    [64 ]: '%40',
+    [33 ]: '%21',
+    [36 ]: '%24',
+    [38 ]: '%26',
+    [39 ]: '%27',
+    [40 ]: '%28',
+    [41 ]: '%29',
+    [42 ]: '%2A',
+    [43 ]: '%2B',
+    [44 ]: '%2C',
+    [59 ]: '%3B',
+    [61 ]: '%3D',
+    [32 ]: '%20',
+};
+function encodeURIComponentFast(uriComponent, isPath, isAuthority) {
+    let res = undefined;
+    let nativeEncodePos = -1;
+    for (let pos = 0; pos < uriComponent.length; pos++) {
+        const code = uriComponent.charCodeAt(pos);
+        if (((code >= 97  && code <= 122) )
+            || ((code >= 65  && code <= 90) )
+            || ((code >= 48  && code <= 57) )
+            || code === 45
+            || code === 46
+            || code === 95
+            || code === 126
+            || ((isPath && code === 47) )
+            || ((isAuthority && code === 91) )
+            || ((isAuthority && code === 93) )
+            || ((isAuthority && code === 58) )) {
+            if (nativeEncodePos !== -1) {
+                res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));
+                nativeEncodePos = -1;
+            }
+            if (res !== undefined) {
+                res += uriComponent.charAt(pos);
+            }
+        }
+        else {
+            if (res === undefined) {
+                res = uriComponent.substr(0, pos);
+            }
+            const escaped = encodeTable[code];
+            if (escaped !== undefined) {
+                if (nativeEncodePos !== -1) {
+                    res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));
+                    nativeEncodePos = -1;
+                }
+                res += escaped;
+            }
+            else if (nativeEncodePos === -1) {
+                nativeEncodePos = pos;
+            }
+        }
+    }
+    if (nativeEncodePos !== -1) {
+        res += encodeURIComponent(uriComponent.substring(nativeEncodePos));
+    }
+    return res !== undefined ? res : uriComponent;
+}
+function encodeURIComponentMinimal(path) {
+    let res = undefined;
+    for (let pos = 0; pos < path.length; pos++) {
+        const code = path.charCodeAt(pos);
+        if (code === 35  || code === 63 ) {
+            if (res === undefined) {
+                res = path.substr(0, pos);
+            }
+            res += encodeTable[code];
+        }
+        else {
+            if (res !== undefined) {
+                res += path[pos];
+            }
+        }
+    }
+    return res !== undefined ? res : path;
+}
+function uriToFsPath(uri, keepDriveLetterCasing) {
+    let value;
+    if (uri.authority && uri.path.length > 1 && uri.scheme === 'file') {
+        value = `//${uri.authority}${uri.path}`;
+    }
+    else if (uri.path.charCodeAt(0) === 47
+        && ((uri.path.charCodeAt(1) >= 65  && uri.path.charCodeAt(1) <= 90  || uri.path.charCodeAt(1) >= 97  && uri.path.charCodeAt(1) <= 122) )
+        && uri.path.charCodeAt(2) === 58 ) {
+        if (!keepDriveLetterCasing) {
+            value = uri.path[1].toLowerCase() + uri.path.substr(2);
+        }
+        else {
+            value = uri.path.substr(1);
+        }
+    }
+    else {
+        value = uri.path;
+    }
+    if (isWindows) {
+        value = value.replace(/\//g, '\\');
+    }
+    return value;
+}
+function _asFormatted(uri, skipEncoding) {
+    const encoder = !skipEncoding
+        ? encodeURIComponentFast
+        : encodeURIComponentMinimal;
+    let res = '';
+    let { scheme, authority, path, query, fragment } = uri;
+    if (scheme) {
+        res += scheme;
+        res += ':';
+    }
+    if (authority || scheme === 'file') {
+        res += _slash;
+        res += _slash;
+    }
+    if (authority) {
+        let idx = authority.indexOf('@');
+        if (idx !== -1) {
+            const userinfo = authority.substr(0, idx);
+            authority = authority.substr(idx + 1);
+            idx = userinfo.lastIndexOf(':');
+            if (idx === -1) {
+                res += encoder(userinfo, false, false);
+            }
+            else {
+                res += encoder(userinfo.substr(0, idx), false, false);
+                res += ':';
+                res += encoder(userinfo.substr(idx + 1), false, true);
+            }
+            res += '@';
+        }
+        authority = authority.toLowerCase();
+        idx = authority.lastIndexOf(':');
+        if (idx === -1) {
+            res += encoder(authority, false, true);
+        }
+        else {
+            res += encoder(authority.substr(0, idx), false, true);
+            res += authority.substr(idx);
+        }
+    }
+    if (path) {
+        if (path.length >= 3 && path.charCodeAt(0) === 47  && path.charCodeAt(2) === 58 ) {
+            const code = path.charCodeAt(1);
+            if (code >= 65  && code <= 90 ) {
+                path = `/${String.fromCharCode(code + 32)}:${path.substr(3)}`;
+            }
+        }
+        else if (path.length >= 2 && path.charCodeAt(1) === 58 ) {
+            const code = path.charCodeAt(0);
+            if (code >= 65  && code <= 90 ) {
+                path = `${String.fromCharCode(code + 32)}:${path.substr(2)}`;
+            }
+        }
+        res += encoder(path, true, false);
+    }
+    if (query) {
+        res += '?';
+        res += encoder(query, false, false);
+    }
+    if (fragment) {
+        res += '#';
+        res += !skipEncoding ? encodeURIComponentFast(fragment, false, false) : fragment;
+    }
+    return res;
+}
+function decodeURIComponentGraceful(str) {
+    try {
+        return decodeURIComponent(str);
+    }
+    catch {
+        if (str.length > 3) {
+            return str.substr(0, 3) + decodeURIComponentGraceful(str.substr(3));
+        }
+        else {
+            return str;
+        }
+    }
+}
+const _rEncodedAsHex = /(%[0-9A-Za-z][0-9A-Za-z])+/g;
+function percentDecode(str) {
+    if (!str.match(_rEncodedAsHex)) {
+        return str;
+    }
+    return str.replace(_rEncodedAsHex, (match) => decodeURIComponentGraceful(match));
+}
+export { URI, uriToFsPath };

package/vscode/src/vs/base/common/uriIpc.js

@@ -1,5 +1,5 @@
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { VSBuffer } from './buffer.js';
+import { URI } from './uri.js';
 const DefaultURITransformer = new class {
     transformIncoming(uri) {
         return uri;

package/vscode/src/vs/base/common/uuid.js

@@ -0,0 +1,55 @@
+const _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUUID(value) {
+    return _UUIDPattern.test(value);
+}
+const generateUuid = ( (function() {
+    if (typeof crypto === 'object' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID.bind(crypto);
+    }
+    let getRandomValues;
+    if (typeof crypto === 'object' && typeof crypto.getRandomValues === 'function') {
+        getRandomValues = crypto.getRandomValues.bind(crypto);
+    }
+    else {
+        getRandomValues = function (bucket) {
+            for (let i = 0; i < bucket.length; i++) {
+                bucket[i] = Math.floor(Math.random() * 256);
+            }
+            return bucket;
+        };
+    }
+    const _data = ( new Uint8Array(16));
+    const _hex = [];
+    for (let i = 0; i < 256; i++) {
+        _hex.push(( i.toString(16)).padStart(2, '0'));
+    }
+    return function generateUuid() {
+        getRandomValues(_data);
+        _data[6] = (_data[6] & 0x0f) | 0x40;
+        _data[8] = (_data[8] & 0x3f) | 0x80;
+        let i = 0;
+        let result = '';
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += '-';
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += '-';
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += '-';
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += '-';
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        result += _hex[_data[i++]];
+        return result;
+    };
+})());
+export { generateUuid, isUUID };

package/vscode/src/vs/base/common/verifier.js

@@ -1,4 +1,4 @@
-import { isObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { isObject } from './types.js';
 class Verifier {
     constructor(defaultValue) {
         this.defaultValue = defaultValue;