@codingame/monaco-vscode-api 26.2.1 → 27.0.0

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

@@ -0,0 +1,67 @@
+export interface IAnchor {
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+}
+export declare enum AnchorAlignment {
+    LEFT = 0,
+    RIGHT = 1
+}
+export declare enum AnchorPosition {
+    BELOW = 0,
+    ABOVE = 1
+}
+export declare enum AnchorAxisAlignment {
+    VERTICAL = 0,
+    HORIZONTAL = 1
+}
+interface IPosition {
+    readonly top: number;
+    readonly left: number;
+}
+interface ISize {
+    readonly width: number;
+    readonly height: number;
+}
+export interface IRect extends IPosition, ISize {
+}
+export declare enum LayoutAnchorPosition {
+    Before = 0,
+    After = 1
+}
+export declare enum LayoutAnchorMode {
+    AVOID = 0,
+    ALIGN = 1
+}
+export interface ILayoutAnchor {
+    offset: number;
+    size: number;
+    mode?: LayoutAnchorMode;
+    position: LayoutAnchorPosition;
+}
+export interface ILayoutResult {
+    position: number;
+    result: "ok" | "flipped" | "overlap";
+}
+/**
+ * Lays out a one dimensional view next to an anchor in a viewport.
+ *
+ * @returns The view offset within the viewport.
+ */
+export declare function layout(viewportSize: number, viewSize: number, anchor: ILayoutAnchor): ILayoutResult;
+interface ILayout2DOptions {
+    readonly anchorAlignment?: AnchorAlignment;
+    readonly anchorPosition?: AnchorPosition;
+    readonly anchorAxisAlignment?: AnchorAxisAlignment;
+}
+export interface ILayout2DResult {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+    anchorAlignment: AnchorAlignment;
+    anchorPosition: AnchorPosition;
+}
+export declare function layout2d(viewport: IRect, view: ISize, anchor: IRect, options?: ILayout2DOptions): ILayout2DResult;
+export {};

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

@@ -0,0 +1,96 @@
+
+import { Range } from './range.js';
+
+var AnchorAlignment;
+(function (AnchorAlignment) {
+    AnchorAlignment[AnchorAlignment["LEFT"] = 0] = "LEFT";
+    AnchorAlignment[AnchorAlignment["RIGHT"] = 1] = "RIGHT";
+})(AnchorAlignment || (AnchorAlignment = {}));
+var AnchorPosition;
+(function (AnchorPosition) {
+    AnchorPosition[AnchorPosition["BELOW"] = 0] = "BELOW";
+    AnchorPosition[AnchorPosition["ABOVE"] = 1] = "ABOVE";
+})(AnchorPosition || (AnchorPosition = {}));
+var AnchorAxisAlignment;
+(function (AnchorAxisAlignment) {
+    AnchorAxisAlignment[AnchorAxisAlignment["VERTICAL"] = 0] = "VERTICAL";
+    AnchorAxisAlignment[AnchorAxisAlignment["HORIZONTAL"] = 1] = "HORIZONTAL";
+})(AnchorAxisAlignment || (AnchorAxisAlignment = {}));
+var LayoutAnchorPosition;
+(function (LayoutAnchorPosition) {
+    LayoutAnchorPosition[LayoutAnchorPosition["Before"] = 0] = "Before";
+    LayoutAnchorPosition[LayoutAnchorPosition["After"] = 1] = "After";
+})(LayoutAnchorPosition || (LayoutAnchorPosition = {}));
+var LayoutAnchorMode;
+(function (LayoutAnchorMode) {
+    LayoutAnchorMode[LayoutAnchorMode["AVOID"] = 0] = "AVOID";
+    LayoutAnchorMode[LayoutAnchorMode["ALIGN"] = 1] = "ALIGN";
+})(LayoutAnchorMode || (LayoutAnchorMode = {}));
+function layout(viewportSize, viewSize, anchor) {
+    const layoutAfterAnchorBoundary = anchor.mode === LayoutAnchorMode.ALIGN ? anchor.offset : anchor.offset + anchor.size;
+    const layoutBeforeAnchorBoundary = anchor.mode === LayoutAnchorMode.ALIGN ? anchor.offset + anchor.size : anchor.offset;
+    if (anchor.position === LayoutAnchorPosition.Before) {
+        if (viewSize <= viewportSize - layoutAfterAnchorBoundary) {
+            return { position: layoutAfterAnchorBoundary, result: 'ok' };
+        }
+        if (viewSize <= layoutBeforeAnchorBoundary) {
+            return { position: layoutBeforeAnchorBoundary - viewSize, result: 'flipped' };
+        }
+        return { position: Math.max(viewportSize - viewSize, 0), result: 'overlap' };
+    }
+    else {
+        if (viewSize <= layoutBeforeAnchorBoundary) {
+            return { position: layoutBeforeAnchorBoundary - viewSize, result: 'ok' };
+        }
+        if (viewSize <= viewportSize - layoutAfterAnchorBoundary && layoutBeforeAnchorBoundary < viewSize / 2) {
+            return { position: layoutAfterAnchorBoundary, result: 'flipped' };
+        }
+        return { position: 0, result: 'overlap' };
+    }
+}
+function layout2d(viewport, view, anchor, options) {
+    let anchorAlignment = options?.anchorAlignment ?? AnchorAlignment.LEFT;
+    let anchorPosition = options?.anchorPosition ?? AnchorPosition.BELOW;
+    const anchorAxisAlignment = options?.anchorAxisAlignment ?? AnchorAxisAlignment.VERTICAL;
+    let top;
+    let left;
+    if (anchorAxisAlignment === AnchorAxisAlignment.VERTICAL) {
+        const verticalAnchor = { offset: anchor.top - viewport.top, size: anchor.height, position: anchorPosition === AnchorPosition.BELOW ? LayoutAnchorPosition.Before : LayoutAnchorPosition.After };
+        const horizontalAnchor = { offset: anchor.left, size: anchor.width, position: anchorAlignment === AnchorAlignment.LEFT ? LayoutAnchorPosition.Before : LayoutAnchorPosition.After, mode: LayoutAnchorMode.ALIGN };
+        const verticalLayoutResult = layout(viewport.height, view.height, verticalAnchor);
+        top = verticalLayoutResult.position + viewport.top;
+        if (verticalLayoutResult.result === 'flipped') {
+            anchorPosition = anchorPosition === AnchorPosition.BELOW ? AnchorPosition.ABOVE : AnchorPosition.BELOW;
+        }
+        if (Range.intersects({ start: top, end: top + view.height }, { start: verticalAnchor.offset, end: verticalAnchor.offset + verticalAnchor.size })) {
+            horizontalAnchor.mode = LayoutAnchorMode.AVOID;
+        }
+        const horizontalLayoutResult = layout(viewport.width, view.width, horizontalAnchor);
+        left = horizontalLayoutResult.position;
+        if (horizontalLayoutResult.result === 'flipped') {
+            anchorAlignment = anchorAlignment === AnchorAlignment.LEFT ? AnchorAlignment.RIGHT : AnchorAlignment.LEFT;
+        }
+    }
+    else {
+        const horizontalAnchor = { offset: anchor.left, size: anchor.width, position: anchorAlignment === AnchorAlignment.LEFT ? LayoutAnchorPosition.Before : LayoutAnchorPosition.After };
+        const verticalAnchor = { offset: anchor.top, size: anchor.height, position: anchorPosition === AnchorPosition.BELOW ? LayoutAnchorPosition.Before : LayoutAnchorPosition.After, mode: LayoutAnchorMode.ALIGN };
+        const horizontalLayoutResult = layout(viewport.width, view.width, horizontalAnchor);
+        left = horizontalLayoutResult.position;
+        if (horizontalLayoutResult.result === 'flipped') {
+            anchorAlignment = anchorAlignment === AnchorAlignment.LEFT ? AnchorAlignment.RIGHT : AnchorAlignment.LEFT;
+        }
+        if (Range.intersects({ start: left, end: left + view.width }, { start: horizontalAnchor.offset, end: horizontalAnchor.offset + horizontalAnchor.size })) {
+            verticalAnchor.mode = LayoutAnchorMode.AVOID;
+        }
+        const verticalLayoutResult = layout(viewport.height, view.height, verticalAnchor);
+        top = verticalLayoutResult.position + viewport.top;
+        if (verticalLayoutResult.result === 'flipped') {
+            anchorPosition = anchorPosition === AnchorPosition.BELOW ? AnchorPosition.ABOVE : AnchorPosition.BELOW;
+        }
+    }
+    const right = viewport.width - (left + view.width);
+    const bottom = viewport.height - (top + view.height);
+    return { top, left, bottom, right, anchorAlignment, anchorPosition };
+}
+
+export { AnchorAlignment, AnchorAxisAlignment, AnchorPosition, LayoutAnchorMode, LayoutAnchorPosition, layout, layout2d };

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

@@ -268,6 +268,38 @@ export declare class DisposableMap<K, V extends IDisposable = IDisposable> imple
         V
     ]>;
 }
+/**
+ * A set that manages the lifecycle of the values that it stores.
+ */
+export declare class DisposableSet<V extends IDisposable = IDisposable> implements IDisposable {
+    private readonly _store;
+    private _isDisposed;
+    constructor(store?: Set<V>);
+    /**
+     * Disposes of all stored values and mark this object as disposed.
+     *
+     * Trying to use this object after it has been disposed of is an error.
+     */
+    dispose(): void;
+    /**
+     * Disposes of all stored values and clear the set, but DO NOT mark this object as disposed.
+     */
+    clearAndDisposeAll(): void;
+    has(value: V): boolean;
+    get size(): number;
+    add(value: V): void;
+    /**
+     * Delete the value from this set and also dispose of it.
+     */
+    deleteAndDispose(value: V): void;
+    /**
+     * Delete the value from this set but return it. The caller is
+     * responsible for disposing of the value.
+     */
+    deleteAndLeak(value: V): V | undefined;
+    values(): IterableIterator<V>;
+    [Symbol.iterator](): IterableIterator<V>;
+}
 /**
  * Call `then` on a Promise, unless the returned disposable is disposed.
  */

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

@@ -535,6 +535,63 @@ class DisposableMap {
         return this._store[Symbol.iterator]();
     }
 }
+class DisposableSet {
+    constructor(
+        store = ( new Set())
+    ) {
+        this._isDisposed = false;
+        this._store = store;
+        trackDisposable(this);
+    }
+    dispose() {
+        markAsDisposed(this);
+        this._isDisposed = true;
+        this.clearAndDisposeAll();
+    }
+    clearAndDisposeAll() {
+        if (!this._store.size) {
+            return;
+        }
+        try {
+            dispose(( this._store.values()));
+        } finally {
+            this._store.clear();
+        }
+    }
+    has(value) {
+        return ( this._store.has(value));
+    }
+    get size() {
+        return this._store.size;
+    }
+    add(value) {
+        if (this._isDisposed) {
+            console.warn(( new Error(
+                "Trying to add a disposable to a DisposableSet that has already been disposed of. The added object will be leaked!"
+            )).stack);
+        }
+        this._store.add(value);
+        setParentOfDisposable(value, this);
+    }
+    deleteAndDispose(value) {
+        if (this._store.delete(value)) {
+            value.dispose();
+        }
+    }
+    deleteAndLeak(value) {
+        if (this._store.delete(value)) {
+            setParentOfDisposable(value, null);
+            return value;
+        }
+        return undefined;
+    }
+    values() {
+        return ( this._store.values());
+    }
+    [Symbol.iterator]() {
+        return this._store[Symbol.iterator]();
+    }
+}
 function thenIfNotDisposed(promise, then) {
     let disposed = false;
     promise.then(result => {
@@ -563,4 +620,4 @@ class DisposableResourceMap extends DisposableMap {
     }
 }
 
-export { AsyncReferenceCollection, Disposable, DisposableMap, DisposableResourceMap, DisposableStore, DisposableTracker, GCBasedDisposableTracker, ImmortalReference, MandatoryMutableDisposable, MutableDisposable, RefCountedDisposable, ReferenceCollection, combinedDisposable, dispose, disposeIfDisposable, isDisposable, markAsDisposed, markAsSingleton, setDisposableTracker, thenIfNotDisposed, thenRegisterOrDispose, toDisposable, trackDisposable };
+export { AsyncReferenceCollection, Disposable, DisposableMap, DisposableResourceMap, DisposableSet, DisposableStore, DisposableTracker, GCBasedDisposableTracker, ImmortalReference, MandatoryMutableDisposable, MutableDisposable, RefCountedDisposable, ReferenceCollection, combinedDisposable, dispose, disposeIfDisposable, isDisposable, markAsDisposed, markAsSingleton, setDisposableTracker, thenIfNotDisposed, thenRegisterOrDispose, toDisposable, trackDisposable };

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

@@ -28,9 +28,9 @@ const mapExtToMediaMimes = {
     ".flv": "video/x-flv",
     ".gif": "image/gif",
     ".ico": "image/x-icon",
-    ".jpe": "image/jpg",
-    ".jpeg": "image/jpg",
-    ".jpg": "image/jpg",
+    ".jpe": ["image/jpg", "image/jpeg"],
+    ".jpeg": ["image/jpg", "image/jpeg"],
+    ".jpg": ["image/jpg", "image/jpeg"],
     ".m1v": "video/mpeg",
     ".m2a": "audio/mpeg",
     ".m2v": "video/mpeg",
@@ -83,11 +83,13 @@ function getMediaOrTextMime(path) {
 }
 function getMediaMime(path) {
     const ext = extname(path);
-    return mapExtToMediaMimes[ext.toLowerCase()];
+    const mimeType = mapExtToMediaMimes[ext.toLowerCase()];
+    return Array.isArray(mimeType) ? mimeType[0] : mimeType;
 }
 function getExtensionForMimeType(mimeType) {
     for (const extension in mapExtToMediaMimes) {
-        if (mapExtToMediaMimes[extension] === mimeType) {
+        const value = mapExtToMediaMimes[extension];
+        if (Array.isArray(value) ? value.includes(mimeType) : value === mimeType) {
             return extension;
         }
     }

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

@@ -19,6 +19,7 @@ export interface INodeProcess {
         chrome?: string;
     };
     type?: string;
+    isEmbeddedApp?: boolean;
     cwd: () => string;
 }
 export declare enum Platform {

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

@@ -319,6 +319,7 @@ export interface IDefaultChatAgent {
     readonly extensionId: string;
     readonly chatExtensionId: string;
     readonly chatExtensionOutputId: string;
+    readonly chatExtensionOutputExtensionStateCommand: string;
     readonly documentationUrl: string;
     readonly skusDocumentationUrl: string;
     readonly publicCodeMatchesUrl: string;
@@ -347,6 +348,7 @@ export interface IDefaultChatAgent {
             name: string;
         };
     };
+    readonly providerExtensionId: string;
     readonly providerUriSetting: string;
     readonly providerScopes: string[][];
     readonly entitlementUrl: string;

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

@@ -271,33 +271,3 @@ export declare const Ellipsis = "\u2026";
  * of throwing an exception.
  */
 export declare function multibyteAwareBtoa(str: string): string;
-/**
- * Encodes a Unicode string to Punycode according to RFC 3492.
- * This is the raw encoding without the "xn--" ACE prefix.
- *
- * @param input The Unicode string to encode.
- * @returns The Punycode-encoded ASCII string.
- * @throws Error if the input contains invalid surrogate pairs.
- *
- * @example
- * // allow-any-unicode-next-line
- * punycodeEncode('münchen') // returns 'mnchen-3ya'
- * // allow-any-unicode-next-line
- * punycodeEncode('bücher') // returns 'bcher-kva'
- * // allow-any-unicode-next-line
- * punycodeEncode('日本語') // returns 'wgv71a119e'
- */
-export declare function punycodeEncode(input: string): string;
-/**
- * Encodes a domain label using Punycode with the ACE prefix "xn--".
- * If the label contains only ASCII characters, it is returned unchanged.
- *
- * @param label The domain label to encode.
- * @returns The ACE-encoded label with "xn--" prefix, or the original label if all ASCII.
- *
- * @example
- * // allow-any-unicode-next-line
- * toPunycodeACE('münchen') // returns 'xn--mnchen-3ya'
- * toPunycodeACE('example') // returns 'example' (no encoding needed)
- */
-export declare function toPunycodeACE(label: string): string;

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

@@ -887,16 +887,5 @@ function toBinary(str) {
 function multibyteAwareBtoa(str) {
     return btoa(toBinary(str));
 }
-var PunycodeConstants;
-(function(PunycodeConstants) {
-    PunycodeConstants[PunycodeConstants["BASE"] = 36] = "BASE";
-    PunycodeConstants[PunycodeConstants["TMIN"] = 1] = "TMIN";
-    PunycodeConstants[PunycodeConstants["TMAX"] = 26] = "TMAX";
-    PunycodeConstants[PunycodeConstants["SKEW"] = 38] = "SKEW";
-    PunycodeConstants[PunycodeConstants["DAMP"] = 700] = "DAMP";
-    PunycodeConstants[PunycodeConstants["INITIAL_BIAS"] = 72] = "INITIAL_BIAS";
-    PunycodeConstants[PunycodeConstants["INITIAL_N"] = 128] = "INITIAL_N";
-    PunycodeConstants[PunycodeConstants["DELIMITER"] = 45] = "DELIMITER";
-})(PunycodeConstants || (PunycodeConstants = {}));
 
 export { AmbiguousCharacters, CodePointIterator, Ellipsis, GraphemeBreakType, GraphemeIterator, InvisibleCharacters, UNUSUAL_LINE_TERMINATORS, UTF8_BOM_CHARACTER, commonPrefixLength, commonSuffixLength, compare, compareIgnoreCase, compareSubstring, compareSubstringIgnoreCase, computeCodePoint, containsRTL, containsUnusualLineTerminators, containsUppercaseCharacter, convertSimple2RegExpPattern, count, createRegExp, endsWithIgnoreCase, equals, equalsIgnoreCase, escape, escapeRegExpCharacters, firstNonWhitespaceIndex, forAnsiStringParts, format, format2, fuzzyContains, getCharContainingOffset, getLeadingWhitespace, getLeftDeleteOffset, getNLines, getNextCodePoint, htmlAttributeEncodeValue, isAsciiDigit, isBasicASCII, isEmojiImprecise, isFalsyOrWhitespace, isFullWidthCharacter, isHighSurrogate, isLowSurrogate, isLowerAsciiLetter, isUpperAsciiLetter, joinStrings, lastNonWhitespaceIndex, lcut, ltrim, multibyteAwareBtoa, nextCharLength, noBreakWhitespace, prevCharLength, rcut, regExpLeadsToEndlessLoop, removeAnsiEscapeCodes, removeAnsiEscapeCodesFromPrompt, rtrim, singleLetterHash, splitLines, splitLinesIncludeSeparators, startsWithIgnoreCase, startsWithUTF8BOM, trim, truncate, truncateMiddle, uppercaseFirstLetter };

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

@@ -14,7 +14,11 @@ function _validateUri(ret, _strict) {
         ));
     }
     if (ret.scheme && !_schemePattern.test(ret.scheme)) {
-        throw ( new Error("[UriError]: Scheme contains illegal characters."));
+        const matches = [...ret.scheme.matchAll(/[^\w\d+.-]/gu)];
+        const detail = matches.length > 0 ? ` Found '${matches[0][0]}' at index ${matches[0].index} (${matches.length} total)` : "";
+        throw ( new Error(
+            `[UriError]: Scheme contains illegal characters.${detail} (len:${ret.scheme.length})`
+        ));
     }
     if (ret.path) {
         if (ret.authority) {

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

@@ -4,71 +4,47 @@
  * Tracks positions for error reporting and node locations.
  *
  * Limitations:
- * - No multi-line strings or block literals
  * - No anchors or references
  * - No complex types (dates, binary)
- * - No special handling for escape sequences in strings
- * - Indentation must be consistent (spaces only, no tabs)
- *
- * Notes:
- * - New line separators can be either "\n" or "\r\n". The input string is split into lines internally.
+ * - No single pair implicit entries
  *
  * @param input A string containing the YAML-like input
  * @param errors Array to collect parsing errors
- * @param options Parsing options
- * @returns The parsed representation (ObjectNode, ArrayNode, or primitive node)
+ * @returns The parsed representation (YamlMapNode, YamlSequenceNode, or YamlScalarNode)
  */
 export declare function parse(input: string, errors?: YamlParseError[], options?: ParseOptions): YamlNode | undefined;
-export interface YamlParseError {
-    readonly message: string;
-    readonly start: Position;
-    readonly end: Position;
-    readonly code: string;
-}
-export interface ParseOptions {
-    readonly allowDuplicateKeys?: boolean;
-}
-export interface Position {
-    readonly line: number;
-    readonly character: number;
-}
-export interface YamlStringNode {
-    readonly type: "string";
+export interface YamlScalarNode {
+    readonly type: "scalar";
     readonly value: string;
-    readonly start: Position;
-    readonly end: Position;
-}
-export interface YamlNumberNode {
-    readonly type: "number";
-    readonly value: number;
-    readonly start: Position;
-    readonly end: Position;
+    readonly rawValue: string;
+    readonly startOffset: number;
+    readonly endOffset: number;
+    readonly format: "single" | "double" | "none" | "literal" | "folded";
 }
-export interface YamlBooleanNode {
-    readonly type: "boolean";
-    readonly value: boolean;
-    readonly start: Position;
-    readonly end: Position;
-}
-export interface YamlNullNode {
-    readonly type: "null";
-    readonly value: null;
-    readonly start: Position;
-    readonly end: Position;
-}
-export interface YamlObjectNode {
-    readonly type: "object";
+export interface YamlMapNode {
+    readonly type: "map";
     readonly properties: {
-        key: YamlStringNode;
+        key: YamlScalarNode;
         value: YamlNode;
     }[];
-    readonly start: Position;
-    readonly end: Position;
+    readonly style: "block" | "flow";
+    readonly startOffset: number;
+    readonly endOffset: number;
 }
-export interface YamlArrayNode {
-    readonly type: "array";
+export interface YamlSequenceNode {
+    readonly type: "sequence";
     readonly items: YamlNode[];
-    readonly start: Position;
-    readonly end: Position;
+    readonly style: "block" | "flow";
+    readonly startOffset: number;
+    readonly endOffset: number;
+}
+export type YamlNode = YamlSequenceNode | YamlMapNode | YamlScalarNode;
+export interface YamlParseError {
+    readonly message: string;
+    readonly startOffset: number;
+    readonly endOffset: number;
+    readonly code: string;
+}
+export interface ParseOptions {
+    readonly allowDuplicateKeys?: boolean;
 }
-export type YamlNode = YamlStringNode | YamlNumberNode | YamlBooleanNode | YamlNullNode | YamlObjectNode | YamlArrayNode;