@codingame/monaco-vscode-api 15.0.3 → 16.0.0

package/vscode/src/vs/base/browser/{defaultWorkerFactory.js → webWorkerFactory.js}

@@ -1,11 +1,13 @@
 
 import { createTrustedTypesPolicy } from './trustedTypes.js';
 import { onUnexpectedError } from '../common/errors.js';
-import { COI, FileAccess } from '../common/network.js';
-import { logOnceWebWorkerWarning, SimpleWorkerClient } from '../common/worker/simpleWorker.js';
+import { COI } from '../common/network.js';
+import { URI } from '../common/uri.js';
+import { WebWorkerClient } from '../common/worker/webWorker.js';
 import { Disposable, toDisposable } from '../common/lifecycle.js';
 import { coalesce } from '../common/arrays.js';
 import '../../nls.js';
+import { Emitter } from '../common/event.js';
 import { getNLSMessages, getNLSLanguage } from '../../nls.messages.js';
 
 let ttPolicy;
@@ -24,7 +26,8 @@ function createBlobWorker(blobUrl, options) {
         { ...options, type: 'module' }
     ));
 }
-function getWorker(esmWorkerLocation, label) {
+function getWorker(descriptor, id) {
+    const label = descriptor.label || 'anonymous' + id;
     const monacoEnvironment = globalThis.MonacoEnvironment;
     if (monacoEnvironment) {
         if (typeof monacoEnvironment.getWorker === 'function') {
@@ -38,6 +41,7 @@ function getWorker(esmWorkerLocation, label) {
             ));
         }
     }
+    const esmWorkerLocation = descriptor.esmModuleLocation;
     if (esmWorkerLocation) {
         const workerUrl = getWorkerBootstrapUrl(label, ( esmWorkerLocation.toString(true)));
         const worker = ( new Worker(
@@ -98,32 +102,43 @@ function isPromiseLike(obj) {
     return false;
 }
 class WebWorker extends Disposable {
-    constructor(esmWorkerLocation, moduleId, id, label, onMessageCallback, onErrorCallback) {
+    static { this.LAST_WORKER_ID = 0; }
+    constructor(descriptorOrWorker) {
         super();
-        this.id = id;
-        this.label = label;
-        const workerOrPromise = getWorker(esmWorkerLocation, label);
+        this._onMessage = this._register(( new Emitter()));
+        this.onMessage = this._onMessage.event;
+        this._onError = this._register(( new Emitter()));
+        this.onError = this._onError.event;
+        this.id = ++WebWorker.LAST_WORKER_ID;
+        const workerOrPromise = (descriptorOrWorker instanceof Worker
+            ? descriptorOrWorker
+            : getWorker(descriptorOrWorker, this.id));
         if (isPromiseLike(workerOrPromise)) {
             this.worker = workerOrPromise;
         }
         else {
             this.worker = Promise.resolve(workerOrPromise);
         }
-        this.postMessage(moduleId, []);
+        this.postMessage('-please-ignore-', []);
+        const errorHandler = (ev) => {
+            this._onError.fire(ev);
+        };
         this.worker.then((w) => {
-            w.onmessage = function (ev) {
-                onMessageCallback(ev.data);
+            w.onmessage = (ev) => {
+                this._onMessage.fire(ev.data);
+            };
+            w.onmessageerror = (ev) => {
+                this._onError.fire(ev);
             };
-            w.onmessageerror = onErrorCallback;
             if (typeof w.addEventListener === 'function') {
-                w.addEventListener('error', onErrorCallback);
+                w.addEventListener('error', errorHandler);
             }
         });
         this._register(toDisposable(() => {
             this.worker?.then(w => {
                 w.onmessage = null;
                 w.onmessageerror = null;
-                w.removeEventListener('error', onErrorCallback);
+                w.removeEventListener('error', errorHandler);
                 w.terminate();
             });
             this.worker = null;
@@ -139,45 +154,20 @@ class WebWorker extends Disposable {
             }
             catch (err) {
                 onUnexpectedError(err);
-                onUnexpectedError(( new Error(`FAILED to post message to '${this.label}'-worker`, { cause: err })));
+                onUnexpectedError(( new Error(`FAILED to post message to worker`, { cause: err })));
             }
         });
     }
 }
-class WorkerDescriptor {
-    constructor(moduleId, label) {
-        this.moduleId = moduleId;
+class WebWorkerDescriptor {
+    constructor(esmModuleLocation, label) {
+        this.esmModuleLocation = esmModuleLocation;
         this.label = label;
-        this.esmModuleLocation = ( FileAccess.asBrowserUri(`${moduleId}Main.js`));
-    }
-}
-class DefaultWorkerFactory {
-    static { this.LAST_WORKER_ID = 0; }
-    constructor() {
-        this._webWorkerFailedBeforeError = false;
-    }
-    create(desc, onMessageCallback, onErrorCallback) {
-        const workerId = (++DefaultWorkerFactory.LAST_WORKER_ID);
-        if (this._webWorkerFailedBeforeError) {
-            throw this._webWorkerFailedBeforeError;
-        }
-        return ( new WebWorker(
-            desc.esmModuleLocation,
-            desc.moduleId,
-            workerId,
-            desc.label || 'anonymous' + workerId,
-            onMessageCallback,
-            (err) => {
-                logOnceWebWorkerWarning(err);
-                this._webWorkerFailedBeforeError = err;
-                onErrorCallback(err);
-            }
-        ));
     }
 }
 function createWebWorker(arg0, arg1) {
-    const workerDescriptor = (typeof arg0 === 'string' ? ( new WorkerDescriptor(arg0, arg1)) : arg0);
-    return ( new SimpleWorkerClient(( new DefaultWorkerFactory()), workerDescriptor));
+    const workerDescriptorOrWorker = (URI.isUri(arg0) ? ( new WebWorkerDescriptor(arg0, arg1)) : arg0);
+    return ( new WebWorkerClient(( new WebWorker(workerDescriptorOrWorker))));
 }
 
-export { WorkerDescriptor, createBlobWorker, createWebWorker };
+export { WebWorkerDescriptor, createBlobWorker, createWebWorker };

package/vscode/src/vs/base/common/arrays.d.ts

@@ -51,6 +51,7 @@ export declare function asArray<T>(x: T | readonly T[]): readonly T[];
 export declare function getRandomElement<T>(arr: T[]): T | undefined;
 export declare function insertInto<T>(array: T[], start: number, newItems: T[]): void;
 export declare function splice<T>(array: T[], start: number, deleteCount: number, newItems: T[]): T[];
+export declare const pick: <TObject, TKeyName extends keyof TObject>(key: TKeyName) => (obj: TObject) => TObject[TKeyName];
 export type CompareResult = number;
 export declare namespace CompareResult {
     function isLessThan(result: CompareResult): boolean;

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

@@ -363,6 +363,11 @@ function splice(array, start, deleteCount, newItems) {
 function getActualStartIndex(array, start) {
     return start < 0 ? Math.max(start + array.length, 0) : Math.min(start, array.length);
 }
+const pick = (key) => {
+    return (obj) => {
+        return obj[key];
+    };
+};
 var CompareResult;
 (function (CompareResult) {
     function isLessThan(result) {
@@ -555,4 +560,4 @@ async function findAsync(array, predicate) {
     return results.find(r => r.ok)?.element;
 }
 
-export { ArrayQueue, CallbackIterable, CompareResult, Permutation, arrayInsert, asArray, binarySearch, binarySearch2, booleanComparator, coalesce, coalesceInPlace, commonPrefixLength, compareBy, compareUndefinedSmallest, delta, distinct, equals, findAsync, forEachAdjacent, forEachWithNeighbors, groupAdjacentBy, groupBy, index, insert, insertInto, isFalsyOrEmpty, isNonEmptyArray, mapArrayOrNot, move, numberComparator, pushMany, pushToEnd, pushToStart, quickSelect, range, remove, removeFastWithoutKeepingOrder, reverseOrder, shuffle, sortedDiff, splice, tail, tieBreakComparators, top, uniqueFilter };
+export { ArrayQueue, CallbackIterable, CompareResult, Permutation, arrayInsert, asArray, binarySearch, binarySearch2, booleanComparator, coalesce, coalesceInPlace, commonPrefixLength, compareBy, compareUndefinedSmallest, delta, distinct, equals, findAsync, forEachAdjacent, forEachWithNeighbors, groupAdjacentBy, groupBy, index, insert, insertInto, isFalsyOrEmpty, isNonEmptyArray, mapArrayOrNot, move, numberComparator, pick, pushMany, pushToEnd, pushToStart, quickSelect, range, remove, removeFastWithoutKeepingOrder, reverseOrder, shuffle, sortedDiff, splice, tail, tieBreakComparators, top, uniqueFilter };

package/vscode/src/vs/base/common/diff/diff.d.ts

@@ -57,3 +57,4 @@ export declare class LcsDiff {
     private ChangesOverlap;
     private ClipDiagonalBound;
 }
+export declare function computeLevenshteinDistance(firstString: string, secondString: string): number;

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

@@ -682,5 +682,130 @@ class LcsDiff {
         }
     }
 }
+const precomputedEqualityArray = ( new Uint32Array(0x10000));
+const computeLevenshteinDistanceForShortStrings = (firstString, secondString) => {
+    const firstStringLength = firstString.length;
+    const secondStringLength = secondString.length;
+    const lastBitMask = 1 << (firstStringLength - 1);
+    let positiveVector = -1;
+    let negativeVector = 0;
+    let distance = firstStringLength;
+    let index = firstStringLength;
+    while (index--) {
+        precomputedEqualityArray[firstString.charCodeAt(index)] |= 1 << index;
+    }
+    for (index = 0; index < secondStringLength; index++) {
+        let equalityMask = precomputedEqualityArray[secondString.charCodeAt(index)];
+        const combinedVector = equalityMask | negativeVector;
+        equalityMask |= ((equalityMask & positiveVector) + positiveVector) ^ positiveVector;
+        negativeVector |= ~(equalityMask | positiveVector);
+        positiveVector &= equalityMask;
+        if (negativeVector & lastBitMask) {
+            distance++;
+        }
+        if (positiveVector & lastBitMask) {
+            distance--;
+        }
+        negativeVector = (negativeVector << 1) | 1;
+        positiveVector = (positiveVector << 1) | ~(combinedVector | negativeVector);
+        negativeVector &= combinedVector;
+    }
+    index = firstStringLength;
+    while (index--) {
+        precomputedEqualityArray[firstString.charCodeAt(index)] = 0;
+    }
+    return distance;
+};
+function computeLevenshteinDistanceForLongStrings(firstString, secondString) {
+    const firstStringLength = firstString.length;
+    const secondStringLength = secondString.length;
+    const horizontalBitArray = [];
+    const verticalBitArray = [];
+    const horizontalSize = Math.ceil(firstStringLength / 32);
+    const verticalSize = Math.ceil(secondStringLength / 32);
+    for (let i = 0; i < horizontalSize; i++) {
+        horizontalBitArray[i] = -1;
+        verticalBitArray[i] = 0;
+    }
+    let verticalIndex = 0;
+    for (; verticalIndex < verticalSize - 1; verticalIndex++) {
+        let negativeVector = 0;
+        let positiveVector = -1;
+        const start = verticalIndex * 32;
+        const verticalLength = Math.min(32, secondStringLength) + start;
+        for (let k = start; k < verticalLength; k++) {
+            precomputedEqualityArray[secondString.charCodeAt(k)] |= 1 << k;
+        }
+        for (let i = 0; i < firstStringLength; i++) {
+            const equalityMask = precomputedEqualityArray[firstString.charCodeAt(i)];
+            const previousBit = (horizontalBitArray[(i / 32) | 0] >>> i) & 1;
+            const matchBit = (verticalBitArray[(i / 32) | 0] >>> i) & 1;
+            const combinedVector = equalityMask | negativeVector;
+            const combinedHorizontalVector = ((((equalityMask | matchBit) & positiveVector) + positiveVector) ^ positiveVector) | equalityMask | matchBit;
+            let positiveHorizontalVector = negativeVector | ~(combinedHorizontalVector | positiveVector);
+            let negativeHorizontalVector = positiveVector & combinedHorizontalVector;
+            if ((positiveHorizontalVector >>> 31) ^ previousBit) {
+                horizontalBitArray[(i / 32) | 0] ^= 1 << i;
+            }
+            if ((negativeHorizontalVector >>> 31) ^ matchBit) {
+                verticalBitArray[(i / 32) | 0] ^= 1 << i;
+            }
+            positiveHorizontalVector = (positiveHorizontalVector << 1) | previousBit;
+            negativeHorizontalVector = (negativeHorizontalVector << 1) | matchBit;
+            positiveVector = negativeHorizontalVector | ~(combinedVector | positiveHorizontalVector);
+            negativeVector = positiveHorizontalVector & combinedVector;
+        }
+        for (let k = start; k < verticalLength; k++) {
+            precomputedEqualityArray[secondString.charCodeAt(k)] = 0;
+        }
+    }
+    let negativeVector = 0;
+    let positiveVector = -1;
+    const start = verticalIndex * 32;
+    const verticalLength = Math.min(32, secondStringLength - start) + start;
+    for (let k = start; k < verticalLength; k++) {
+        precomputedEqualityArray[secondString.charCodeAt(k)] |= 1 << k;
+    }
+    let distance = secondStringLength;
+    for (let i = 0; i < firstStringLength; i++) {
+        const equalityMask = precomputedEqualityArray[firstString.charCodeAt(i)];
+        const previousBit = (horizontalBitArray[(i / 32) | 0] >>> i) & 1;
+        const matchBit = (verticalBitArray[(i / 32) | 0] >>> i) & 1;
+        const combinedVector = equalityMask | negativeVector;
+        const combinedHorizontalVector = ((((equalityMask | matchBit) & positiveVector) + positiveVector) ^ positiveVector) | equalityMask | matchBit;
+        let positiveHorizontalVector = negativeVector | ~(combinedHorizontalVector | positiveVector);
+        let negativeHorizontalVector = positiveVector & combinedHorizontalVector;
+        distance += (positiveHorizontalVector >>> (secondStringLength - 1)) & 1;
+        distance -= (negativeHorizontalVector >>> (secondStringLength - 1)) & 1;
+        if ((positiveHorizontalVector >>> 31) ^ previousBit) {
+            horizontalBitArray[(i / 32) | 0] ^= 1 << i;
+        }
+        if ((negativeHorizontalVector >>> 31) ^ matchBit) {
+            verticalBitArray[(i / 32) | 0] ^= 1 << i;
+        }
+        positiveHorizontalVector = (positiveHorizontalVector << 1) | previousBit;
+        negativeHorizontalVector = (negativeHorizontalVector << 1) | matchBit;
+        positiveVector = negativeHorizontalVector | ~(combinedVector | positiveHorizontalVector);
+        negativeVector = positiveHorizontalVector & combinedVector;
+    }
+    for (let k = start; k < verticalLength; k++) {
+        precomputedEqualityArray[secondString.charCodeAt(k)] = 0;
+    }
+    return distance;
+}
+function computeLevenshteinDistance(firstString, secondString) {
+    if (firstString.length < secondString.length) {
+        const temp = secondString;
+        secondString = firstString;
+        firstString = temp;
+    }
+    if (secondString.length === 0) {
+        return firstString.length;
+    }
+    if (firstString.length <= 32) {
+        return computeLevenshteinDistanceForShortStrings(firstString, secondString);
+    }
+    return computeLevenshteinDistanceForLongStrings(firstString, secondString);
+}
 
-export { LcsDiff, StringDiffSequence, stringDiff };
+export { LcsDiff, StringDiffSequence, computeLevenshteinDistance, stringDiff };

package/vscode/src/vs/base/common/history.d.ts

@@ -13,6 +13,7 @@ export declare class HistoryNavigator<T> implements INavigator<T> {
     private _history;
     private _limit;
     private _navigator;
+    private _disposable;
     constructor(_history?: IHistory<T>, limit?: number);
     getHistory(): T[];
     add(t: T): void;
@@ -30,6 +31,7 @@ export declare class HistoryNavigator<T> implements INavigator<T> {
     private _reduceToLimit;
     private _currentPosition;
     private get _elements();
+    dispose(): void;
 }
 export declare class HistoryNavigator2<T> {
     private capacity;

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

@@ -8,7 +8,7 @@ class HistoryNavigator {
         this._limit = limit;
         this._onChange();
         if (this._history.onDidChange) {
-            this._history.onDidChange(() => this._onChange());
+            this._disposable = this._history.onDidChange(() => this._onChange());
         }
     }
     getHistory() {
@@ -82,6 +82,12 @@ class HistoryNavigator {
         this._history.forEach(e => elements.push(e));
         return elements;
     }
+    dispose() {
+        if (this._disposable) {
+            this._disposable.dispose();
+            this._disposable = undefined;
+        }
+    }
 }
 class HistoryNavigator2 {
     get size() { return this._size; }

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

@@ -0,0 +1,80 @@
+
+import { env } from './process.js';
+
+function isHotReloadEnabled() {
+    return env && !!env['VSCODE_DEV_DEBUG'];
+}
+function registerHotReloadHandler(handler) {
+    if (!isHotReloadEnabled()) {
+        return { dispose() { } };
+    }
+    else {
+        const handlers = registerGlobalHotReloadHandler();
+        handlers.add(handler);
+        return {
+            dispose() { handlers.delete(handler); }
+        };
+    }
+}
+function registerGlobalHotReloadHandler() {
+    if (!hotReloadHandlers) {
+        hotReloadHandlers = ( new Set());
+    }
+    const g = globalThis;
+    if (!g.$hotReload_applyNewExports) {
+        g.$hotReload_applyNewExports = args => {
+            const args2 = { config: { mode: undefined }, ...args };
+            const results = [];
+            for (const h of hotReloadHandlers) {
+                const result = h(args2);
+                if (result) {
+                    results.push(result);
+                }
+            }
+            if (results.length > 0) {
+                return newExports => {
+                    let result = false;
+                    for (const r of results) {
+                        if (r(newExports)) {
+                            result = true;
+                        }
+                    }
+                    return result;
+                };
+            }
+            return undefined;
+        };
+    }
+    return hotReloadHandlers;
+}
+let hotReloadHandlers = undefined;
+if (isHotReloadEnabled()) {
+    registerHotReloadHandler(({ oldExports, newSrc, config }) => {
+        if (config.mode !== 'patch-prototype') {
+            return undefined;
+        }
+        return newExports => {
+            for (const key in newExports) {
+                const exportedItem = newExports[key];
+                console.log(`[hot-reload] Patching prototype methods of '${key}'`, { exportedItem });
+                if (typeof exportedItem === 'function' && exportedItem.prototype) {
+                    const oldExportedItem = oldExports[key];
+                    if (oldExportedItem) {
+                        for (const prop of Object.getOwnPropertyNames(exportedItem.prototype)) {
+                            const descriptor = Object.getOwnPropertyDescriptor(exportedItem.prototype, prop);
+                            const oldDescriptor = Object.getOwnPropertyDescriptor(oldExportedItem.prototype, prop);
+                            if (descriptor?.value?.toString() !== oldDescriptor?.value?.toString()) {
+                                console.log(`[hot-reload] Patching prototype method '${key}.${prop}'`);
+                            }
+                            Object.defineProperty(oldExportedItem.prototype, prop, descriptor);
+                        }
+                        newExports[key] = oldExportedItem;
+                    }
+                }
+            }
+            return true;
+        };
+    });
+}
+
+export { isHotReloadEnabled, registerHotReloadHandler };

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

@@ -1,15 +1,44 @@
 
-import './process.js';
+import { isHotReloadEnabled, registerHotReloadHandler } from './hotReload.js';
 import './observableInternal/index.js';
-import { constObservable } from './observableInternal/utils.js';
+import { observableSignalFromEvent, constObservable } from './observableInternal/utils.js';
+import { observableValue } from './observableInternal/base.js';
 
 function readHotReloadableExport(value, reader) {
+    observeHotReloadableExports([value], reader);
     return value;
 }
+function observeHotReloadableExports(values, reader) {
+    if (isHotReloadEnabled()) {
+        const o = observableSignalFromEvent('reload', event => registerHotReloadHandler(({ oldExports }) => {
+            if (!( [...( Object.values(oldExports))].some(v => values.includes(v)))) {
+                return undefined;
+            }
+            return (_newExports) => {
+                event(undefined);
+                return true;
+            };
+        }));
+        o.read(reader);
+    }
+}
+const classes = ( new Map());
 function createHotClass(clazz) {
-    {
+    if (!isHotReloadEnabled()) {
         return constObservable(clazz);
     }
+    const id = clazz.name;
+    let existing = classes.get(id);
+    if (!existing) {
+        existing = observableValue(id, clazz);
+        classes.set(id, existing);
+    }
+    else {
+        setTimeout(() => {
+            existing.set(clazz, undefined);
+        }, 0);
+    }
+    return existing;
 }
 
-export { createHotClass, readHotReloadableExport };
+export { createHotClass, observeHotReloadableExports, readHotReloadableExport };

package/vscode/src/vs/base/common/htmlContent.d.ts

@@ -48,3 +48,8 @@ export declare function parseHrefAndDimensions(href: string): {
     href: string;
     dimensions: string[];
 };
+export declare function markdownCommandLink(command: {
+    title: string;
+    id: string;
+    arguments?: unknown[];
+}): string;

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

@@ -1,6 +1,7 @@
 
 import { illegalArgument } from './errors.js';
 import { escapeIcons } from './iconLabels.js';
+import { Schemas } from './network.js';
 import { isEqual } from './resources.js';
 import { escapeRegExpCharacters } from './strings.js';
 import { URI } from './uri.js';
@@ -12,9 +13,6 @@ var MarkdownStringTextNewlineStyle;
 })(MarkdownStringTextNewlineStyle || (MarkdownStringTextNewlineStyle = {}));
 class MarkdownString {
     static lift(dto) {
-        if (dto instanceof MarkdownString) {
-            return dto;
-        }
         const markdownString = ( new MarkdownString(dto.value, dto));
         markdownString.uris = dto.uris;
         markdownString.baseUri = dto.baseUri ? URI.revive(dto.baseUri) : undefined;
@@ -154,5 +152,13 @@ function parseHrefAndDimensions(href) {
     }
     return { href, dimensions };
 }
+function markdownCommandLink(command) {
+    const uri = ( ( URI.from({
+        scheme: Schemas.command,
+        path: command.id,
+        query: command.arguments?.length ? encodeURIComponent(JSON.stringify(command.arguments)) : undefined,
+    })).toString());
+    return `[${escapeMarkdownSyntaxTokens(command.title)}](${uri})`;
+}
 
-export { MarkdownString, MarkdownStringTextNewlineStyle, appendEscapedMarkdownCodeBlockFence, escapeDoubleQuotes, escapeMarkdownSyntaxTokens, isEmptyMarkdownString, isMarkdownString, markdownStringEqual, parseHrefAndDimensions, removeMarkdownEscapes };
+export { MarkdownString, MarkdownStringTextNewlineStyle, appendEscapedMarkdownCodeBlockFence, escapeDoubleQuotes, escapeMarkdownSyntaxTokens, isEmptyMarkdownString, isMarkdownString, markdownCommandLink, markdownStringEqual, parseHrefAndDimensions, removeMarkdownEscapes };

package/vscode/src/vs/base/common/iterator.d.ts

@@ -16,6 +16,7 @@ export declare namespace Iterable {
     function flatMap<T, R>(iterable: Iterable<T>, fn: (t: T, index: number) => Iterable<R>): Iterable<R>;
     function concat<T>(...iterables: (Iterable<T> | T)[]): Iterable<T>;
     function reduce<T, R>(iterable: Iterable<T>, reducer: (previousValue: R, currentValue: T) => R, initialValue: R): R;
+    function length<T>(iterable: Iterable<T>): number;
     function slice<T>(arr: ReadonlyArray<T>, from: number, to?: number): Iterable<T>;
     function consume<T>(iterable: Iterable<T>, atMost?: number): [
         T[],

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

@@ -103,6 +103,14 @@ var Iterable;
         return value;
     }
     Iterable.reduce = reduce;
+    function length(iterable) {
+        let count = 0;
+        for (const _ of iterable) {
+            count++;
+        }
+        return count;
+    }
+    Iterable.length = length;
     function* slice(arr, from, to = arr.length) {
         if (from < -arr.length) {
             from = 0;

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

@@ -758,6 +758,41 @@ function findNodeAtLocation(root, path) {
     }
     return node;
 }
+function getNodePath(node) {
+    if (!node.parent || !node.parent.children) {
+        return [];
+    }
+    const path = getNodePath(node.parent);
+    if (node.parent.type === 'property') {
+        const key = node.parent.children[0].value;
+        path.push(key);
+    }
+    else if (node.parent.type === 'array') {
+        const index = node.parent.children.indexOf(node);
+        if (index !== -1) {
+            path.push(index);
+        }
+    }
+    return path;
+}
+function contains(node, offset, includeRightBound = false) {
+    return (offset >= node.offset && offset < (node.offset + node.length)) || includeRightBound && (offset === (node.offset + node.length));
+}
+function findNodeAtOffset(node, offset, includeRightBound = false) {
+    if (contains(node, offset, includeRightBound)) {
+        const children = node.children;
+        if (Array.isArray(children)) {
+            for (let i = 0; i < children.length && children[i].offset <= offset; i++) {
+                const item = findNodeAtOffset(children[i], offset, includeRightBound);
+                if (item) {
+                    return item;
+                }
+            }
+        }
+        return node;
+    }
+    return undefined;
+}
 function visit(text, visitor, options = ParseOptions.DEFAULT) {
     const _scanner = createScanner(text, false);
     function toNoArgVisit(visitFunction) {
@@ -1003,4 +1038,4 @@ function getNodeType(value) {
     }
 }
 
-export { ParseErrorCode, ParseOptions, ScanError, SyntaxKind, createScanner, findNodeAtLocation, getLocation, getNodeType, parse, parseTree, visit };
+export { ParseErrorCode, ParseOptions, ScanError, SyntaxKind, contains, createScanner, findNodeAtLocation, findNodeAtOffset, getLocation, getNodePath, getNodeType, parse, parseTree, visit };

package/vscode/src/vs/base/common/lifecycle.d.ts

@@ -139,3 +139,4 @@ export declare class DisposableMap<K, V extends IDisposable = IDisposable> imple
         V
     ]>;
 }
+export declare function thenIfNotDisposed<T>(promise: Promise<T>, then: (result: T) => void): IDisposable;

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

@@ -488,5 +488,17 @@ class DisposableMap {
         return this._store[Symbol.iterator]();
     }
 }
+function thenIfNotDisposed(promise, then) {
+    let disposed = false;
+    promise.then(result => {
+        if (disposed) {
+            return;
+        }
+        then(result);
+    });
+    return toDisposable(() => {
+        disposed = true;
+    });
+}
 
-export { AsyncReferenceCollection, Disposable, DisposableMap, DisposableStore, DisposableTracker, GCBasedDisposableTracker, ImmortalReference, MandatoryMutableDisposable, MutableDisposable, RefCountedDisposable, ReferenceCollection, combinedDisposable, dispose, disposeIfDisposable, isDisposable, markAsDisposed, markAsSingleton, setDisposableTracker, toDisposable, trackDisposable };
+export { AsyncReferenceCollection, Disposable, DisposableMap, DisposableStore, DisposableTracker, GCBasedDisposableTracker, ImmortalReference, MandatoryMutableDisposable, MutableDisposable, RefCountedDisposable, ReferenceCollection, combinedDisposable, dispose, disposeIfDisposable, isDisposable, markAsDisposed, markAsSingleton, setDisposableTracker, thenIfNotDisposed, toDisposable, trackDisposable };

package/vscode/src/vs/base/common/marshallingIds.d.ts

@@ -20,5 +20,6 @@ export declare enum MarshalledId {
     ChatViewContext = 19,
     LanguageModelToolResult = 20,
     LanguageModelTextPart = 21,
-    LanguageModelPromptTsxPart = 22
+    LanguageModelPromptTsxPart = 22,
+    LanguageModelDataPart = 23
 }

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

@@ -24,6 +24,7 @@ var MarshalledId;
     MarshalledId[MarshalledId["LanguageModelToolResult"] = 20] = "LanguageModelToolResult";
     MarshalledId[MarshalledId["LanguageModelTextPart"] = 21] = "LanguageModelTextPart";
     MarshalledId[MarshalledId["LanguageModelPromptTsxPart"] = 22] = "LanguageModelPromptTsxPart";
+    MarshalledId[MarshalledId["LanguageModelDataPart"] = 23] = "LanguageModelDataPart";
 })(MarshalledId || (MarshalledId = {}));
 
 export { MarshalledId };

package/vscode/src/vs/base/common/mime.d.ts

@@ -5,6 +5,7 @@ export declare const Mimes: Readonly<{
     markdown: "text/markdown";
     latex: "text/latex";
     uriList: "text/uri-list";
+    html: "text/html";
 }>;
 export declare function getMediaOrTextMime(path: string): string | undefined;
 export declare function getMediaMime(path: string): string | undefined;

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

@@ -8,6 +8,7 @@ const Mimes = ( Object.freeze({
     markdown: 'text/markdown',
     latex: 'text/latex',
     uriList: 'text/uri-list',
+    html: 'text/html',
 }));
 const mapExtToTextMimes = {
     '.css': 'text/css',

package/vscode/src/vs/base/common/network.d.ts

@@ -94,6 +94,7 @@ declare class FileAccessImpl {
 }
 export declare const FileAccess: FileAccessImpl;
 export declare const CacheControlheaders: Record<string, string>;
+export declare const DocumentPolicyheaders: Record<string, string>;
 export declare namespace COI {
     const CoopAndCoep: Readonly<Record<string, string> | undefined>;
     function getHeadersFromQuery(url: string | URI | URL): Record<string, string> | undefined;