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

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

@@ -0,0 +1,104 @@
+import { extname } from './path.js';
+const Mimes = ( Object.freeze({
+    text: 'text/plain',
+    binary: 'application/octet-stream',
+    unknown: 'application/unknown',
+    markdown: 'text/markdown',
+    latex: 'text/latex',
+    uriList: 'text/uri-list',
+}));
+const mapExtToTextMimes = {
+    '.css': 'text/css',
+    '.csv': 'text/csv',
+    '.htm': 'text/html',
+    '.html': 'text/html',
+    '.ics': 'text/calendar',
+    '.js': 'text/javascript',
+    '.mjs': 'text/javascript',
+    '.txt': 'text/plain',
+    '.xml': 'text/xml'
+};
+const mapExtToMediaMimes = {
+    '.aac': 'audio/x-aac',
+    '.avi': 'video/x-msvideo',
+    '.bmp': 'image/bmp',
+    '.flv': 'video/x-flv',
+    '.gif': 'image/gif',
+    '.ico': 'image/x-icon',
+    '.jpe': 'image/jpg',
+    '.jpeg': 'image/jpg',
+    '.jpg': 'image/jpg',
+    '.m1v': 'video/mpeg',
+    '.m2a': 'audio/mpeg',
+    '.m2v': 'video/mpeg',
+    '.m3a': 'audio/mpeg',
+    '.mid': 'audio/midi',
+    '.midi': 'audio/midi',
+    '.mk3d': 'video/x-matroska',
+    '.mks': 'video/x-matroska',
+    '.mkv': 'video/x-matroska',
+    '.mov': 'video/quicktime',
+    '.movie': 'video/x-sgi-movie',
+    '.mp2': 'audio/mpeg',
+    '.mp2a': 'audio/mpeg',
+    '.mp3': 'audio/mpeg',
+    '.mp4': 'video/mp4',
+    '.mp4a': 'audio/mp4',
+    '.mp4v': 'video/mp4',
+    '.mpe': 'video/mpeg',
+    '.mpeg': 'video/mpeg',
+    '.mpg': 'video/mpeg',
+    '.mpg4': 'video/mp4',
+    '.mpga': 'audio/mpeg',
+    '.oga': 'audio/ogg',
+    '.ogg': 'audio/ogg',
+    '.opus': 'audio/opus',
+    '.ogv': 'video/ogg',
+    '.png': 'image/png',
+    '.psd': 'image/vnd.adobe.photoshop',
+    '.qt': 'video/quicktime',
+    '.spx': 'audio/ogg',
+    '.svg': 'image/svg+xml',
+    '.tga': 'image/x-tga',
+    '.tif': 'image/tiff',
+    '.tiff': 'image/tiff',
+    '.wav': 'audio/x-wav',
+    '.webm': 'video/webm',
+    '.webp': 'image/webp',
+    '.wma': 'audio/x-ms-wma',
+    '.wmv': 'video/x-ms-wmv',
+    '.woff': 'application/font-woff',
+};
+function getMediaOrTextMime(path) {
+    const ext = extname(path);
+    const textMime = mapExtToTextMimes[ext.toLowerCase()];
+    if (textMime !== undefined) {
+        return textMime;
+    }
+    else {
+        return getMediaMime(path);
+    }
+}
+function getMediaMime(path) {
+    const ext = extname(path);
+    return mapExtToMediaMimes[ext.toLowerCase()];
+}
+function getExtensionForMimeType(mimeType) {
+    for (const extension in mapExtToMediaMimes) {
+        if (mapExtToMediaMimes[extension] === mimeType) {
+            return extension;
+        }
+    }
+    return undefined;
+}
+const _simplePattern = /^(.+)\/(.+?)(;.+)?$/;
+function normalizeMimeType(mimeType, strict) {
+    const match = _simplePattern.exec(mimeType);
+    if (!match) {
+        return strict
+            ? undefined
+            : mimeType;
+    }
+    return `${match[1].toLowerCase()}/${match[2].toLowerCase()}${match[3] ?? ''}`;
+}
+export { Mimes, getExtensionForMimeType, getMediaMime, getMediaOrTextMime, normalizeMimeType };

package/vscode/src/vs/base/common/naturalLanguage/korean.js

@@ -0,0 +1,203 @@
+function getKoreanAltChars(code) {
+    const result = disassembleKorean(code);
+    if (result && result.length > 0) {
+        return ( new Uint32Array(result));
+    }
+    return undefined;
+}
+let codeBufferLength = 0;
+const codeBuffer = ( new Uint32Array(10));
+function disassembleKorean(code) {
+    codeBufferLength = 0;
+    getCodesFromArray(code, modernConsonants, 4352 );
+    if (codeBufferLength > 0) {
+        return codeBuffer.subarray(0, codeBufferLength);
+    }
+    getCodesFromArray(code, modernVowels, 4449 );
+    if (codeBufferLength > 0) {
+        return codeBuffer.subarray(0, codeBufferLength);
+    }
+    getCodesFromArray(code, modernFinalConsonants, 4520 );
+    if (codeBufferLength > 0) {
+        return codeBuffer.subarray(0, codeBufferLength);
+    }
+    getCodesFromArray(code, compatibilityJamo, 12593 );
+    if (codeBufferLength) {
+        return codeBuffer.subarray(0, codeBufferLength);
+    }
+    if (code >= 0xAC00 && code <= 0xD7A3) {
+        const hangulIndex = code - 0xAC00;
+        const vowelAndFinalConsonantProduct = hangulIndex % 588;
+        const initialConsonantIndex = Math.floor(hangulIndex / 588);
+        const vowelIndex = Math.floor(vowelAndFinalConsonantProduct / 28);
+        const finalConsonantIndex = vowelAndFinalConsonantProduct % 28 - 1;
+        if (initialConsonantIndex < modernConsonants.length) {
+            getCodesFromArray(initialConsonantIndex, modernConsonants, 0);
+        }
+        else if (4352  + initialConsonantIndex - 12593  < compatibilityJamo.length) {
+            getCodesFromArray(4352  + initialConsonantIndex, compatibilityJamo, 12593 );
+        }
+        if (vowelIndex < modernVowels.length) {
+            getCodesFromArray(vowelIndex, modernVowels, 0);
+        }
+        else if (4449  + vowelIndex - 12593  < compatibilityJamo.length) {
+            getCodesFromArray(4449  + vowelIndex - 12593 , compatibilityJamo, 12593 );
+        }
+        if (finalConsonantIndex >= 0) {
+            if (finalConsonantIndex < modernFinalConsonants.length) {
+                getCodesFromArray(finalConsonantIndex, modernFinalConsonants, 0);
+            }
+            else if (4520  + finalConsonantIndex - 12593  < compatibilityJamo.length) {
+                getCodesFromArray(4520  + finalConsonantIndex - 12593 , compatibilityJamo, 12593 );
+            }
+        }
+        if (codeBufferLength > 0) {
+            return codeBuffer.subarray(0, codeBufferLength);
+        }
+    }
+    return undefined;
+}
+function getCodesFromArray(code, array, arrayStartIndex) {
+    if (code >= arrayStartIndex && code < arrayStartIndex + array.length) {
+        addCodesToBuffer(array[code - arrayStartIndex]);
+    }
+}
+function addCodesToBuffer(codes) {
+    if (codes === 0 ) {
+        return;
+    }
+    codeBuffer[codeBufferLength++] = codes & 0xFF;
+    if (codes >> 8) {
+        codeBuffer[codeBufferLength++] = (codes >> 8) & 0xFF;
+    }
+    if (codes >> 16) {
+        codeBuffer[codeBufferLength++] = (codes >> 16) & 0xFF;
+    }
+}
+const modernConsonants = ( new Uint8Array([
+    114 ,
+    82 ,
+    115 ,
+    101 ,
+    69 ,
+    102 ,
+    97 ,
+    113 ,
+    81 ,
+    116 ,
+    84 ,
+    100 ,
+    119 ,
+    87 ,
+    99 ,
+    122 ,
+    120 ,
+    118 ,
+    103 ,
+]));
+const modernVowels = ( new Uint16Array([
+    107 ,
+    111 ,
+    105 ,
+    79 ,
+    106 ,
+    112 ,
+    117 ,
+    80 ,
+    104 ,
+    27496 ,
+    28520 ,
+    27752 ,
+    121 ,
+    110 ,
+    27246 ,
+    28782 ,
+    27758 ,
+    98 ,
+    109 ,
+    27757 ,
+    108 ,
+]));
+const modernFinalConsonants = ( new Uint16Array([
+    114 ,
+    82 ,
+    29810 ,
+    115 ,
+    30579 ,
+    26483 ,
+    101 ,
+    102 ,
+    29286 ,
+    24934 ,
+    29030 ,
+    29798 ,
+    30822 ,
+    30310 ,
+    26470 ,
+    97 ,
+    113 ,
+    29809 ,
+    116 ,
+    84 ,
+    100 ,
+    119 ,
+    99 ,
+    122 ,
+    120 ,
+    118 ,
+    103 ,
+]));
+const compatibilityJamo = ( new Uint16Array([
+    114 ,
+    82 ,
+    29810 ,
+    115 ,
+    30579 ,
+    26483 ,
+    101 ,
+    69 ,
+    102 ,
+    29286 ,
+    24934 ,
+    29030 ,
+    29798 ,
+    30822 ,
+    30310 ,
+    26470 ,
+    97 ,
+    113 ,
+    81 ,
+    29809 ,
+    116 ,
+    84 ,
+    100 ,
+    119 ,
+    87 ,
+    99 ,
+    122 ,
+    120 ,
+    118 ,
+    103 ,
+    107 ,
+    111 ,
+    105 ,
+    79 ,
+    106 ,
+    112 ,
+    117 ,
+    80 ,
+    104 ,
+    27496 ,
+    28520 ,
+    27752 ,
+    121 ,
+    110 ,
+    27246 ,
+    28782 ,
+    27758 ,
+    98 ,
+    109 ,
+    27757 ,
+    108 ,
+]));
+export { getKoreanAltChars };

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

@@ -0,0 +1,31 @@
+class ArrayNavigator {
+    constructor(items, start = 0, end = items.length, index = start - 1) {
+        this.items = items;
+        this.start = start;
+        this.end = end;
+        this.index = index;
+    }
+    current() {
+        if (this.index === this.start - 1 || this.index === this.end) {
+            return null;
+        }
+        return this.items[this.index];
+    }
+    next() {
+        this.index = Math.min(this.index + 1, this.end);
+        return this.current();
+    }
+    previous() {
+        this.index = Math.max(this.index - 1, this.start - 1);
+        return this.current();
+    }
+    first() {
+        this.index = this.start;
+        return this.current();
+    }
+    last() {
+        this.index = this.end - 1;
+        return this.current();
+    }
+}
+export { ArrayNavigator };

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

@@ -0,0 +1,237 @@
+import { onUnexpectedError } from './errors.js';
+import { toDisposable } from './lifecycle.js';
+import { ResourceMap } from './map.js';
+import { isNative, webWorkerOrigin, isWeb } from './platform.js';
+import { equalsIgnoreCase, startsWithIgnoreCase } from './strings.js';
+import { URI } from './uri.js';
+var Schemas;
+( (function(Schemas) {
+    Schemas.inMemory = 'inmemory';
+    Schemas.vscode = 'vscode';
+    Schemas.internal = 'private';
+    Schemas.walkThrough = 'walkThrough';
+    Schemas.walkThroughSnippet = 'walkThroughSnippet';
+    Schemas.http = 'http';
+    Schemas.https = 'https';
+    Schemas.file = 'file';
+    Schemas.mailto = 'mailto';
+    Schemas.untitled = 'untitled';
+    Schemas.data = 'data';
+    Schemas.command = 'command';
+    Schemas.vscodeRemote = 'vscode-remote';
+    Schemas.vscodeRemoteResource = 'vscode-remote-resource';
+    Schemas.vscodeManagedRemoteResource = 'vscode-managed-remote-resource';
+    Schemas.vscodeUserData = 'vscode-userdata';
+    Schemas.vscodeCustomEditor = 'vscode-custom-editor';
+    Schemas.vscodeNotebookCell = 'vscode-notebook-cell';
+    Schemas.vscodeNotebookCellMetadata = 'vscode-notebook-cell-metadata';
+    Schemas.vscodeNotebookCellOutput = 'vscode-notebook-cell-output';
+    Schemas.vscodeInteractiveInput = 'vscode-interactive-input';
+    Schemas.vscodeSettings = 'vscode-settings';
+    Schemas.vscodeWorkspaceTrust = 'vscode-workspace-trust';
+    Schemas.vscodeTerminal = 'vscode-terminal';
+    Schemas.vscodeChatSesssion = 'vscode-chat-editor';
+    Schemas.webviewPanel = 'webview-panel';
+    Schemas.vscodeWebview = 'vscode-webview';
+    Schemas.extension = 'extension';
+    Schemas.vscodeFileResource = 'vscode-file';
+    Schemas.tmp = 'tmp';
+    Schemas.vsls = 'vsls';
+    Schemas.vscodeSourceControl = 'vscode-scm';
+})(Schemas || (Schemas = {})));
+function matchesScheme(target, scheme) {
+    if (URI.isUri(target)) {
+        return equalsIgnoreCase(target.scheme, scheme);
+    }
+    else {
+        return startsWithIgnoreCase(target, scheme + ':');
+    }
+}
+function matchesSomeScheme(target, ...schemes) {
+    return ( schemes.some(scheme => matchesScheme(target, scheme)));
+}
+const connectionTokenQueryName = 'tkn';
+class RemoteAuthoritiesImpl {
+    constructor() {
+        this._hosts = Object.create(null);
+        this._ports = Object.create(null);
+        this._connectionTokens = Object.create(null);
+        this._preferredWebSchema = 'http';
+        this._delegate = null;
+        this._remoteResourcesPath = `/${Schemas.vscodeRemoteResource}`;
+    }
+    setPreferredWebSchema(schema) {
+        this._preferredWebSchema = schema;
+    }
+    setDelegate(delegate) {
+        this._delegate = delegate;
+    }
+    setServerRootPath(serverRootPath) {
+        this._remoteResourcesPath = `${serverRootPath}/${Schemas.vscodeRemoteResource}`;
+    }
+    set(authority, host, port) {
+        this._hosts[authority] = host;
+        this._ports[authority] = port;
+    }
+    setConnectionToken(authority, connectionToken) {
+        this._connectionTokens[authority] = connectionToken;
+    }
+    getPreferredWebSchema() {
+        return this._preferredWebSchema;
+    }
+    rewrite(uri) {
+        if (this._delegate) {
+            try {
+                return this._delegate(uri);
+            }
+            catch (err) {
+                onUnexpectedError(err);
+                return uri;
+            }
+        }
+        const authority = uri.authority;
+        let host = this._hosts[authority];
+        if (host && host.indexOf(':') !== -1 && host.indexOf('[') === -1) {
+            host = `[${host}]`;
+        }
+        const port = this._ports[authority];
+        const connectionToken = this._connectionTokens[authority];
+        let query = `path=${encodeURIComponent(uri.path)}`;
+        if (typeof connectionToken === 'string') {
+            query += `&${connectionTokenQueryName}=${encodeURIComponent(connectionToken)}`;
+        }
+        return ( URI.from({
+            scheme: isWeb ? this._preferredWebSchema : Schemas.vscodeRemoteResource,
+            authority: `${host}:${port}`,
+            path: this._remoteResourcesPath,
+            query
+        }));
+    }
+}
+const RemoteAuthorities = ( new RemoteAuthoritiesImpl());
+const builtinExtensionsPath = 'vs/../../extensions';
+const nodeModulesPath = 'vs/../../node_modules';
+const nodeModulesAsarPath = 'vs/../../node_modules.asar';
+const nodeModulesAsarUnpackedPath = 'vs/../../node_modules.asar.unpacked';
+const VSCODE_AUTHORITY = 'vscode-app';
+class FileAccessImpl {
+    constructor() {
+        this.staticBrowserUris = ( new ResourceMap());
+        this.appResourcePathUrls = ( new Map());
+        this.moduleContentProvider = ( new Map());
+    }
+    static { this.FALLBACK_AUTHORITY = VSCODE_AUTHORITY; }
+    registerModuleContentProvider(moduleId, contentLoader) {
+        this.moduleContentProvider.set(moduleId, contentLoader);
+    }
+    toModuleContent(moduleId) {
+        return this.moduleContentProvider.get(moduleId)();
+    }
+    registerAppResourcePathUrl(moduleId, url) {
+        this.appResourcePathUrls.set(moduleId, url);
+    }
+    toUrl(moduleId) {
+        let url = this.appResourcePathUrls.get(moduleId);
+        if (typeof url === 'function') {
+            url = url();
+        }
+        return ( ( new URL(url ?? moduleId, globalThis.location?.href ?? import.meta.url)).toString());
+    }
+    asBrowserUri(resourcePath) {
+        const uri = this.toUri(resourcePath, { toUrl: this.toUrl.bind(this) });
+        return this.uriToBrowserUri(uri);
+    }
+    uriToBrowserUri(uri) {
+        if (uri.scheme === Schemas.vscodeRemote) {
+            return RemoteAuthorities.rewrite(uri);
+        }
+        if (
+        uri.scheme === Schemas.file &&
+            (
+            (
+            isNative || (webWorkerOrigin === `${Schemas.vscodeFileResource}://${FileAccessImpl.FALLBACK_AUTHORITY}`)))) {
+            return uri.with({
+                scheme: Schemas.vscodeFileResource,
+                authority: uri.authority || FileAccessImpl.FALLBACK_AUTHORITY,
+                query: null,
+                fragment: null
+            });
+        }
+        return this.staticBrowserUris.get(uri) ?? uri;
+    }
+    asFileUri(resourcePath) {
+        const uri = this.toUri(resourcePath, { toUrl: this.toUrl.bind(this) });
+        return this.uriToFileUri(uri);
+    }
+    uriToFileUri(uri) {
+        if (uri.scheme === Schemas.vscodeFileResource) {
+            return uri.with({
+                scheme: Schemas.file,
+                authority: uri.authority !== FileAccessImpl.FALLBACK_AUTHORITY ? uri.authority : null,
+                query: null,
+                fragment: null
+            });
+        }
+        return uri;
+    }
+    toUri(uriOrModule, moduleIdToUrl) {
+        if (URI.isUri(uriOrModule)) {
+            return uriOrModule;
+        }
+        return ( URI.parse(moduleIdToUrl.toUrl(uriOrModule)));
+    }
+    registerStaticBrowserUri(uri, browserUri) {
+        this.staticBrowserUris.set(uri, browserUri);
+        return toDisposable(() => {
+            if (this.staticBrowserUris.get(uri) === browserUri) {
+                this.staticBrowserUris.delete(uri);
+            }
+        });
+    }
+    getRegisteredBrowserUris() {
+        return ( this.staticBrowserUris.keys());
+    }
+}
+const FileAccess = ( new FileAccessImpl());
+var COI;
+( (function(COI) {
+    const coiHeaders = ( new Map([
+        ['1', { 'Cross-Origin-Opener-Policy': 'same-origin' }],
+        ['2', { 'Cross-Origin-Embedder-Policy': 'require-corp' }],
+        ['3', { 'Cross-Origin-Opener-Policy': 'same-origin', 'Cross-Origin-Embedder-Policy': 'require-corp' }],
+    ]));
+    COI.CoopAndCoep = ( Object.freeze(coiHeaders.get('3')));
+    const coiSearchParamName = 'vscode-coi';
+    function getHeadersFromQuery(url) {
+        let params;
+        if (typeof url === 'string') {
+            params = ( new URL(url)).searchParams;
+        }
+        else if (url instanceof URL) {
+            params = url.searchParams;
+        }
+        else if (URI.isUri(url)) {
+            params = ( new URL(( url.toString(true)))).searchParams;
+        }
+        const value = params?.get(coiSearchParamName);
+        if (!value) {
+            return undefined;
+        }
+        return coiHeaders.get(value);
+    }
+    COI.getHeadersFromQuery = getHeadersFromQuery;
+    function addSearchParam(urlOrSearch, coop, coep) {
+        if (!globalThis.crossOriginIsolated) {
+            return;
+        }
+        const value = coop && coep ? '3' : coep ? '2' : '1';
+        if (urlOrSearch instanceof URLSearchParams) {
+            urlOrSearch.set(coiSearchParamName, value);
+        }
+        else {
+            urlOrSearch[coiSearchParamName] = value;
+        }
+    }
+    COI.addSearchParam = addSearchParam;
+})(COI || (COI = {})));
+export { COI, FileAccess, RemoteAuthorities, Schemas, VSCODE_AUTHORITY, builtinExtensionsPath, connectionTokenQueryName, matchesScheme, matchesSomeScheme, nodeModulesAsarPath, nodeModulesAsarUnpackedPath, nodeModulesPath };

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

@@ -0,0 +1,55 @@
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+function rot(index, modulo) {
+    return (modulo + (index % modulo)) % modulo;
+}
+class Counter {
+    constructor() {
+        this._next = 0;
+    }
+    getNext() {
+        return this._next++;
+    }
+}
+class MovingAverage {
+    constructor() {
+        this._n = 1;
+        this._val = 0;
+    }
+    update(value) {
+        this._val = this._val + (value - this._val) / this._n;
+        this._n += 1;
+        return this._val;
+    }
+    get value() {
+        return this._val;
+    }
+}
+class SlidingWindowAverage {
+    constructor(size) {
+        this._n = 0;
+        this._val = 0;
+        this._values = [];
+        this._index = 0;
+        this._sum = 0;
+        this._values = ( new Array(size));
+        this._values.fill(0, 0, size);
+    }
+    update(value) {
+        const oldValue = this._values[this._index];
+        this._values[this._index] = value;
+        this._index = (this._index + 1) % this._values.length;
+        this._sum -= oldValue;
+        this._sum += value;
+        if (this._n < this._values.length) {
+            this._n += 1;
+        }
+        this._val = this._sum / this._n;
+        return this._val;
+    }
+    get value() {
+        return this._val;
+    }
+}
+export { Counter, MovingAverage, SlidingWindowAverage, clamp, rot };