custom-electron-titlebar 3.2.5 → 3.2.9

package/lib/vs/base/common/lifecycle.d.ts

@@ -1,67 +0,0 @@
-export declare class MultiDisposeError extends Error {
-    readonly errors: any[];
-    constructor(errors: any[]);
-}
-export interface IDisposable {
-    dispose(): void;
-}
-export declare function isDisposable<E extends object>(thing: E): thing is E & IDisposable;
-export declare function dispose<T extends IDisposable>(disposable: T): T;
-export declare function dispose<T extends IDisposable>(disposable: T | undefined): T | undefined;
-export declare function dispose<T extends IDisposable, A extends IterableIterator<T> = IterableIterator<T>>(disposables: IterableIterator<T>): A;
-export declare function dispose<T extends IDisposable>(disposables: Array<T>): Array<T>;
-export declare function dispose<T extends IDisposable>(disposables: ReadonlyArray<T>): ReadonlyArray<T>;
-export declare function combinedDisposable(...disposables: IDisposable[]): IDisposable;
-export declare function toDisposable(fn: () => void): IDisposable;
-export declare class DisposableStore implements IDisposable {
-    static DISABLE_DISPOSED_WARNING: boolean;
-    private _toDispose;
-    private _isDisposed;
-    /**
-     * Dispose of all registered disposables and mark this object as disposed.
-     *
-     * Any future disposables added to this object will be disposed of on `add`.
-     */
-    dispose(): void;
-    /**
-     * Dispose of all registered disposables but do not mark this object as disposed.
-     */
-    clear(): void;
-    add<T extends IDisposable>(t: T): T;
-}
-export declare abstract class Disposable implements IDisposable {
-    static readonly None: Readonly<IDisposable>;
-    private readonly _store;
-    constructor();
-    dispose(): void;
-    protected _register<T extends IDisposable>(t: T): T;
-}
-/**
- * Manages the lifecycle of a disposable value that may be changed.
- *
- * This ensures that when the disposable value is changed, the previously held disposable is disposed of. You can
- * also register a `MutableDisposable` on a `Disposable` to ensure it is automatically cleaned up.
- */
-export declare class MutableDisposable<T extends IDisposable> implements IDisposable {
-    private _value?;
-    private _isDisposed;
-    constructor();
-    get value(): T | undefined;
-    set value(value: T | undefined);
-    clear(): void;
-    dispose(): void;
-}
-export interface IReference<T> extends IDisposable {
-    readonly object: T;
-}
-export declare abstract class ReferenceCollection<T> {
-    private readonly references;
-    acquire(key: string, ...args: any[]): IReference<T>;
-    protected abstract createReferencedObject(key: string, ...args: any[]): T;
-    protected abstract destroyReferencedObject(key: string, object: T): void;
-}
-export declare class ImmortalReference<T> implements IReference<T> {
-    object: T;
-    constructor(object: T);
-    dispose(): void;
-}

package/lib/vs/base/common/lifecycle.js

@@ -1,234 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImmortalReference = exports.ReferenceCollection = exports.MutableDisposable = exports.Disposable = exports.DisposableStore = exports.toDisposable = exports.combinedDisposable = exports.dispose = exports.isDisposable = exports.MultiDisposeError = void 0;
-const functional_1 = require("vs/base/common/functional");
-const iterator_1 = require("vs/base/common/iterator");
-/**
- * Enables logging of potentially leaked disposables.
- *
- * A disposable is considered leaked if it is not disposed or not registered as the child of
- * another disposable. This tracking is very simple an only works for classes that either
- * extend Disposable or use a DisposableStore. This means there are a lot of false positives.
- */
-const TRACK_DISPOSABLES = false;
-const __is_disposable_tracked__ = '__is_disposable_tracked__';
-function markTracked(x) {
-    if (!TRACK_DISPOSABLES) {
-        return;
-    }
-    if (x && x !== Disposable.None) {
-        try {
-            x[__is_disposable_tracked__] = true;
-        }
-        catch {
-            // noop
-        }
-    }
-}
-function trackDisposable(x) {
-    if (!TRACK_DISPOSABLES) {
-        return x;
-    }
-    const stack = new Error('Potentially leaked disposable').stack;
-    setTimeout(() => {
-        if (!x[__is_disposable_tracked__]) {
-            console.log(stack);
-        }
-    }, 3000);
-    return x;
-}
-class MultiDisposeError extends Error {
-    constructor(errors) {
-        super(`Encounter errors while disposing of store. Errors: [${errors.join(', ')}]`);
-        this.errors = errors;
-    }
-}
-exports.MultiDisposeError = MultiDisposeError;
-function isDisposable(thing) {
-    return typeof thing.dispose === 'function' && thing.dispose.length === 0;
-}
-exports.isDisposable = isDisposable;
-function dispose(arg) {
-    if (iterator_1.Iterable.is(arg)) {
-        let errors = [];
-        for (const d of arg) {
-            if (d) {
-                markTracked(d);
-                try {
-                    d.dispose();
-                }
-                catch (e) {
-                    errors.push(e);
-                }
-            }
-        }
-        if (errors.length === 1) {
-            throw errors[0];
-        }
-        else if (errors.length > 1) {
-            throw new MultiDisposeError(errors);
-        }
-        return Array.isArray(arg) ? [] : arg;
-    }
-    else if (arg) {
-        markTracked(arg);
-        arg.dispose();
-        return arg;
-    }
-}
-exports.dispose = dispose;
-function combinedDisposable(...disposables) {
-    disposables.forEach(markTracked);
-    return trackDisposable({ dispose: () => dispose(disposables) });
-}
-exports.combinedDisposable = combinedDisposable;
-function toDisposable(fn) {
-    const self = trackDisposable({
-        dispose: () => {
-            markTracked(self);
-            fn();
-        }
-    });
-    return self;
-}
-exports.toDisposable = toDisposable;
-class DisposableStore {
-    constructor() {
-        this._toDispose = new Set();
-        this._isDisposed = false;
-    }
-    /**
-     * Dispose of all registered disposables and mark this object as disposed.
-     *
-     * Any future disposables added to this object will be disposed of on `add`.
-     */
-    dispose() {
-        if (this._isDisposed) {
-            return;
-        }
-        markTracked(this);
-        this._isDisposed = true;
-        this.clear();
-    }
-    /**
-     * Dispose of all registered disposables but do not mark this object as disposed.
-     */
-    clear() {
-        try {
-            dispose(this._toDispose.values());
-        }
-        finally {
-            this._toDispose.clear();
-        }
-    }
-    add(t) {
-        if (!t) {
-            return t;
-        }
-        if (t === this) {
-            throw new Error('Cannot register a disposable on itself!');
-        }
-        markTracked(t);
-        if (this._isDisposed) {
-            if (!DisposableStore.DISABLE_DISPOSED_WARNING) {
-                console.warn(new Error('Trying to add a disposable to a DisposableStore that has already been disposed of. The added object will be leaked!').stack);
-            }
-        }
-        else {
-            this._toDispose.add(t);
-        }
-        return t;
-    }
-}
-exports.DisposableStore = DisposableStore;
-DisposableStore.DISABLE_DISPOSED_WARNING = false;
-class Disposable {
-    constructor() {
-        this._store = new DisposableStore();
-        trackDisposable(this);
-    }
-    dispose() {
-        markTracked(this);
-        this._store.dispose();
-    }
-    _register(t) {
-        if (t === this) {
-            throw new Error('Cannot register a disposable on itself!');
-        }
-        return this._store.add(t);
-    }
-}
-exports.Disposable = Disposable;
-Disposable.None = Object.freeze({ dispose() { } });
-/**
- * Manages the lifecycle of a disposable value that may be changed.
- *
- * This ensures that when the disposable value is changed, the previously held disposable is disposed of. You can
- * also register a `MutableDisposable` on a `Disposable` to ensure it is automatically cleaned up.
- */
-class MutableDisposable {
-    constructor() {
-        this._isDisposed = false;
-        trackDisposable(this);
-    }
-    get value() {
-        return this._isDisposed ? undefined : this._value;
-    }
-    set value(value) {
-        if (this._isDisposed || value === this._value) {
-            return;
-        }
-        if (this._value) {
-            this._value.dispose();
-        }
-        if (value) {
-            markTracked(value);
-        }
-        this._value = value;
-    }
-    clear() {
-        this.value = undefined;
-    }
-    dispose() {
-        this._isDisposed = true;
-        markTracked(this);
-        if (this._value) {
-            this._value.dispose();
-        }
-        this._value = undefined;
-    }
-}
-exports.MutableDisposable = MutableDisposable;
-class ReferenceCollection {
-    constructor() {
-        this.references = new Map();
-    }
-    acquire(key, ...args) {
-        let reference = this.references.get(key);
-        if (!reference) {
-            reference = { counter: 0, object: this.createReferencedObject(key, ...args) };
-            this.references.set(key, reference);
-        }
-        const { object } = reference;
-        const dispose = functional_1.once(() => {
-            if (--reference.counter === 0) {
-                this.destroyReferencedObject(key, reference.object);
-                this.references.delete(key);
-            }
-        });
-        reference.counter++;
-        return { object, dispose };
-    }
-}
-exports.ReferenceCollection = ReferenceCollection;
-class ImmortalReference {
-    constructor(object) {
-        this.object = object;
-    }
-    dispose() { }
-}
-exports.ImmortalReference = ImmortalReference;

package/lib/vs/base/common/linkedList.d.ts

@@ -1,16 +0,0 @@
-export declare class LinkedList<E> {
-    private _first;
-    private _last;
-    private _size;
-    get size(): number;
-    isEmpty(): boolean;
-    clear(): void;
-    unshift(element: E): () => void;
-    push(element: E): () => void;
-    private _insert;
-    shift(): E | undefined;
-    pop(): E | undefined;
-    private _remove;
-    [Symbol.iterator](): Iterator<E>;
-    toArray(): E[];
-}

package/lib/vs/base/common/linkedList.js

@@ -1,128 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LinkedList = void 0;
-class Node {
-    constructor(element) {
-        this.element = element;
-        this.next = Node.Undefined;
-        this.prev = Node.Undefined;
-    }
-}
-Node.Undefined = new Node(undefined);
-class LinkedList {
-    constructor() {
-        this._first = Node.Undefined;
-        this._last = Node.Undefined;
-        this._size = 0;
-    }
-    get size() {
-        return this._size;
-    }
-    isEmpty() {
-        return this._first === Node.Undefined;
-    }
-    clear() {
-        this._first = Node.Undefined;
-        this._last = Node.Undefined;
-        this._size = 0;
-    }
-    unshift(element) {
-        return this._insert(element, false);
-    }
-    push(element) {
-        return this._insert(element, true);
-    }
-    _insert(element, atTheEnd) {
-        const newNode = new Node(element);
-        if (this._first === Node.Undefined) {
-            this._first = newNode;
-            this._last = newNode;
-        }
-        else if (atTheEnd) {
-            // push
-            const oldLast = this._last;
-            this._last = newNode;
-            newNode.prev = oldLast;
-            oldLast.next = newNode;
-        }
-        else {
-            // unshift
-            const oldFirst = this._first;
-            this._first = newNode;
-            newNode.next = oldFirst;
-            oldFirst.prev = newNode;
-        }
-        this._size += 1;
-        let didRemove = false;
-        return () => {
-            if (!didRemove) {
-                didRemove = true;
-                this._remove(newNode);
-            }
-        };
-    }
-    shift() {
-        if (this._first === Node.Undefined) {
-            return undefined;
-        }
-        else {
-            const res = this._first.element;
-            this._remove(this._first);
-            return res;
-        }
-    }
-    pop() {
-        if (this._last === Node.Undefined) {
-            return undefined;
-        }
-        else {
-            const res = this._last.element;
-            this._remove(this._last);
-            return res;
-        }
-    }
-    _remove(node) {
-        if (node.prev !== Node.Undefined && node.next !== Node.Undefined) {
-            // middle
-            const anchor = node.prev;
-            anchor.next = node.next;
-            node.next.prev = anchor;
-        }
-        else if (node.prev === Node.Undefined && node.next === Node.Undefined) {
-            // only node
-            this._first = Node.Undefined;
-            this._last = Node.Undefined;
-        }
-        else if (node.next === Node.Undefined) {
-            // last
-            this._last = this._last.prev;
-            this._last.next = Node.Undefined;
-        }
-        else if (node.prev === Node.Undefined) {
-            // first
-            this._first = this._first.next;
-            this._first.prev = Node.Undefined;
-        }
-        // done
-        this._size -= 1;
-    }
-    *[Symbol.iterator]() {
-        let node = this._first;
-        while (node !== Node.Undefined) {
-            yield node.element;
-            node = node.next;
-        }
-    }
-    toArray() {
-        const result = [];
-        for (let node = this._first; node !== Node.Undefined; node = node.next) {
-            result.push(node.element);
-        }
-        return result;
-    }
-}
-exports.LinkedList = LinkedList;

package/lib/vs/base/common/network.d.ts

@@ -1,65 +0,0 @@
-import { URI } from 'vs/base/common/uri';
-export declare namespace Schemas {
-    /**
-     * A schema that is used for models that exist in memory
-     * only and that have no correspondence on a server or such.
-     */
-    const inMemory = "inmemory";
-    /**
-     * A schema that is used for setting files
-     */
-    const vscode = "vscode";
-    /**
-     * A schema that is used for internal private files
-     */
-    const internal = "private";
-    /**
-     * A walk-through document.
-     */
-    const walkThrough = "walkThrough";
-    /**
-     * An embedded code snippet.
-     */
-    const walkThroughSnippet = "walkThroughSnippet";
-    const http = "http";
-    const https = "https";
-    const file = "file";
-    const mailto = "mailto";
-    const untitled = "untitled";
-    const data = "data";
-    const command = "command";
-    const vscodeRemote = "vscode-remote";
-    const vscodeRemoteResource = "vscode-remote-resource";
-    const userData = "vscode-userdata";
-    const vscodeCustomEditor = "vscode-custom-editor";
-    const vscodeNotebook = "vscode-notebook";
-    const vscodeNotebookCell = "vscode-notebook-cell";
-    const vscodeSettings = "vscode-settings";
-    const webviewPanel = "webview-panel";
-    /**
-     * Scheme used for loading the wrapper html and script in webviews.
-     */
-    const vscodeWebview = "vscode-webview";
-    /**
-     * Scheme used for loading resources inside of webviews.
-     */
-    const vscodeWebviewResource = "vscode-webview-resource";
-    /**
-     * Scheme used for extension pages
-     */
-    const extension = "extension";
-}
-declare class RemoteAuthoritiesImpl {
-    private readonly _hosts;
-    private readonly _ports;
-    private readonly _connectionTokens;
-    private _preferredWebSchema;
-    private _delegate;
-    setPreferredWebSchema(schema: 'http' | 'https'): void;
-    setDelegate(delegate: (uri: URI) => URI): void;
-    set(authority: string, host: string, port: number): void;
-    setConnectionToken(authority: string, connectionToken: string): void;
-    rewrite(uri: URI): URI;
-}
-export declare const RemoteAuthorities: RemoteAuthoritiesImpl;
-export {};

package/lib/vs/base/common/network.js

@@ -1,124 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RemoteAuthorities = exports.Schemas = void 0;
-const uri_1 = require("vs/base/common/uri");
-const platform = __importStar(require("vs/base/common/platform"));
-var Schemas;
-(function (Schemas) {
-    /**
-     * A schema that is used for models that exist in memory
-     * only and that have no correspondence on a server or such.
-     */
-    Schemas.inMemory = 'inmemory';
-    /**
-     * A schema that is used for setting files
-     */
-    Schemas.vscode = 'vscode';
-    /**
-     * A schema that is used for internal private files
-     */
-    Schemas.internal = 'private';
-    /**
-     * A walk-through document.
-     */
-    Schemas.walkThrough = 'walkThrough';
-    /**
-     * An embedded code snippet.
-     */
-    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.userData = 'vscode-userdata';
-    Schemas.vscodeCustomEditor = 'vscode-custom-editor';
-    Schemas.vscodeNotebook = 'vscode-notebook';
-    Schemas.vscodeNotebookCell = 'vscode-notebook-cell';
-    Schemas.vscodeSettings = 'vscode-settings';
-    Schemas.webviewPanel = 'webview-panel';
-    /**
-     * Scheme used for loading the wrapper html and script in webviews.
-     */
-    Schemas.vscodeWebview = 'vscode-webview';
-    /**
-     * Scheme used for loading resources inside of webviews.
-     */
-    Schemas.vscodeWebviewResource = 'vscode-webview-resource';
-    /**
-     * Scheme used for extension pages
-     */
-    Schemas.extension = 'extension';
-})(Schemas = exports.Schemas || (exports.Schemas = {}));
-class RemoteAuthoritiesImpl {
-    constructor() {
-        this._hosts = Object.create(null);
-        this._ports = Object.create(null);
-        this._connectionTokens = Object.create(null);
-        this._preferredWebSchema = 'http';
-        this._delegate = null;
-    }
-    setPreferredWebSchema(schema) {
-        this._preferredWebSchema = schema;
-    }
-    setDelegate(delegate) {
-        this._delegate = delegate;
-    }
-    set(authority, host, port) {
-        this._hosts[authority] = host;
-        this._ports[authority] = port;
-    }
-    setConnectionToken(authority, connectionToken) {
-        this._connectionTokens[authority] = connectionToken;
-    }
-    rewrite(uri) {
-        if (this._delegate) {
-            return this._delegate(uri);
-        }
-        const authority = uri.authority;
-        let host = this._hosts[authority];
-        if (host && 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 += `&tkn=${encodeURIComponent(connectionToken)}`;
-        }
-        return uri_1.URI.from({
-            scheme: platform.isWeb ? this._preferredWebSchema : Schemas.vscodeRemoteResource,
-            authority: `${host}:${port}`,
-            path: `/vscode-remote-resource`,
-            query
-        });
-    }
-}
-exports.RemoteAuthorities = new RemoteAuthoritiesImpl();

package/lib/vs/base/common/path.d.ts

@@ -1,39 +0,0 @@
-export interface ParsedPath {
-    root: string;
-    dir: string;
-    base: string;
-    ext: string;
-    name: string;
-}
-export interface IPath {
-    normalize(path: string): string;
-    isAbsolute(path: string): boolean;
-    join(...paths: string[]): string;
-    resolve(...pathSegments: string[]): string;
-    relative(from: string, to: string): string;
-    dirname(path: string): string;
-    basename(path: string, ext?: string): string;
-    extname(path: string): string;
-    format(pathObject: ParsedPath): string;
-    parse(path: string): ParsedPath;
-    toNamespacedPath(path: string): string;
-    sep: '\\' | '/';
-    delimiter: string;
-    win32: IPath | null;
-    posix: IPath | null;
-}
-export declare const win32: IPath;
-export declare const posix: IPath;
-export declare const normalize: (path: string) => string;
-export declare const isAbsolute: (path: string) => boolean;
-export declare const join: (...paths: string[]) => string;
-export declare const resolve: (...pathSegments: string[]) => string;
-export declare const relative: (from: string, to: string) => string;
-export declare const dirname: (path: string) => string;
-export declare const basename: (path: string, ext?: string) => string;
-export declare const extname: (path: string) => string;
-export declare const format: (pathObject: ParsedPath) => string;
-export declare const parse: (path: string) => ParsedPath;
-export declare const toNamespacedPath: (path: string) => string;
-export declare const sep: "/" | "\\";
-export declare const delimiter: string;