@codingame/monaco-vscode-2f06fe84-148e-5e6b-a7ca-c7989c5f128a-common 12.0.0

package/empty.js

@@ -0,0 +1 @@
+export {}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@codingame/monaco-vscode-2f06fe84-148e-5e6b-a7ca-c7989c5f128a-common",
+  "version": "12.0.0",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - common package (files, storage, user-data-profile)",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "dependencies": {
+    "@codingame/monaco-vscode-e571cbbb-526b-5d8b-92c5-a0437d2dabb3-common": "12.0.0",
+    "vscode": "npm:@codingame/monaco-vscode-api@12.0.0"
+  },
+  "peerDependencies": {},
+  "peerDependenciesMeta": {},
+  "exports": {
+    ".": {
+      "default": "./empty.js"
+    },
+    "./vscode/*": {
+      "default": "./vscode/src/*.js",
+      "types": "./vscode/src/*.d.ts"
+    },
+    "./*": {
+      "default": "./*.js",
+      "types": "./*.d.ts"
+    }
+  }
+}

package/vscode/src/vs/base/browser/indexedDB.d.ts

@@ -0,0 +1,19 @@
+export declare class DBClosedError extends Error {
+    readonly code = "DBClosed";
+    constructor(dbName: string);
+}
+export declare class IndexedDB {
+    private readonly name;
+    static create(name: string, version: number | undefined, stores: string[]): Promise<IndexedDB>;
+    private static openDatabase;
+    private static doOpenDatabase;
+    private static deleteDatabase;
+    private database;
+    private readonly pendingTransactions;
+    constructor(database: IDBDatabase, name: string);
+    hasPendingTransactions(): boolean;
+    close(): void;
+    runInTransaction<T>(store: string, transactionMode: IDBTransactionMode, dbRequestFn: (store: IDBObjectStore) => IDBRequest<T>[]): Promise<T[]>;
+    runInTransaction<T>(store: string, transactionMode: IDBTransactionMode, dbRequestFn: (store: IDBObjectStore) => IDBRequest<T>): Promise<T>;
+    getKeyValues<V>(store: string, isValid: (value: unknown) => value is V): Promise<Map<string, V>>;
+}

package/vscode/src/vs/base/browser/indexedDB.js

@@ -0,0 +1,149 @@
+
+import { toErrorMessage } from 'vscode/vscode/vs/base/common/errorMessage';
+import { getErrorMessage, ErrorNoTelemetry } from 'vscode/vscode/vs/base/common/errors';
+import { mark } from 'vscode/vscode/vs/base/common/performance';
+
+class MissingStoresError extends Error {
+    constructor(db) {
+        super('Missing stores');
+        this.db = db;
+    }
+}
+class DBClosedError extends Error {
+    constructor(dbName) {
+        super(`IndexedDB database '${dbName}' is closed.`);
+        this.code = 'DBClosed';
+    }
+}
+class IndexedDB {
+    static async create(name, version, stores) {
+        const database = await IndexedDB.openDatabase(name, version, stores);
+        return ( new IndexedDB(database, name));
+    }
+    static async openDatabase(name, version, stores) {
+        mark(`code/willOpenDatabase/${name}`);
+        try {
+            return await IndexedDB.doOpenDatabase(name, version, stores);
+        }
+        catch (err) {
+            if (err instanceof MissingStoresError) {
+                console.info(`Attempting to recreate the IndexedDB once.`, name);
+                try {
+                    await IndexedDB.deleteDatabase(err.db);
+                }
+                catch (error) {
+                    console.error(`Error while deleting the IndexedDB`, getErrorMessage(error));
+                    throw error;
+                }
+                return await IndexedDB.doOpenDatabase(name, version, stores);
+            }
+            throw err;
+        }
+        finally {
+            mark(`code/didOpenDatabase/${name}`);
+        }
+    }
+    static doOpenDatabase(name, version, stores) {
+        return ( new Promise((c, e) => {
+            const request = indexedDB.open(name, version);
+            request.onerror = () => e(request.error);
+            request.onsuccess = () => {
+                const db = request.result;
+                for (const store of stores) {
+                    if (!db.objectStoreNames.contains(store)) {
+                        console.error(`Error while opening IndexedDB. Could not find '${store}'' object store`);
+                        e(( new MissingStoresError(db)));
+                        return;
+                    }
+                }
+                c(db);
+            };
+            request.onupgradeneeded = () => {
+                const db = request.result;
+                for (const store of stores) {
+                    if (!db.objectStoreNames.contains(store)) {
+                        db.createObjectStore(store);
+                    }
+                }
+            };
+        }));
+    }
+    static deleteDatabase(database) {
+        return ( new Promise((c, e) => {
+            database.close();
+            const deleteRequest = indexedDB.deleteDatabase(database.name);
+            deleteRequest.onerror = (err) => e(deleteRequest.error);
+            deleteRequest.onsuccess = () => c();
+        }));
+    }
+    constructor(database, name) {
+        this.name = name;
+        this.database = null;
+        this.pendingTransactions = [];
+        this.database = database;
+    }
+    hasPendingTransactions() {
+        return this.pendingTransactions.length > 0;
+    }
+    close() {
+        if (this.pendingTransactions.length) {
+            this.pendingTransactions.splice(0, this.pendingTransactions.length).forEach(transaction => transaction.abort());
+        }
+        this.database?.close();
+        this.database = null;
+    }
+    async runInTransaction(store, transactionMode, dbRequestFn) {
+        if (!this.database) {
+            throw ( new DBClosedError(this.name));
+        }
+        const transaction = this.database.transaction(store, transactionMode);
+        this.pendingTransactions.push(transaction);
+        return ( new Promise((c, e) => {
+            transaction.oncomplete = () => {
+                if (Array.isArray(request)) {
+                    c(( request.map(r => r.result)));
+                }
+                else {
+                    c(request.result);
+                }
+            };
+            transaction.onerror = () => e(transaction.error ? ErrorNoTelemetry.fromError(transaction.error) : ( new ErrorNoTelemetry('unknown error')));
+            transaction.onabort = () => e(transaction.error ? ErrorNoTelemetry.fromError(transaction.error) : ( new ErrorNoTelemetry('unknown error')));
+            const request = dbRequestFn(transaction.objectStore(store));
+        })).finally(() => this.pendingTransactions.splice(this.pendingTransactions.indexOf(transaction), 1));
+    }
+    async getKeyValues(store, isValid) {
+        if (!this.database) {
+            throw ( new DBClosedError(this.name));
+        }
+        const transaction = this.database.transaction(store, 'readonly');
+        this.pendingTransactions.push(transaction);
+        return ( new Promise(resolve => {
+            const items = ( new Map());
+            const objectStore = transaction.objectStore(store);
+            const cursor = objectStore.openCursor();
+            if (!cursor) {
+                return resolve(items);
+            }
+            cursor.onsuccess = () => {
+                if (cursor.result) {
+                    if (isValid(cursor.result.value)) {
+                        items.set(( cursor.result.key.toString()), cursor.result.value);
+                    }
+                    cursor.result.continue();
+                }
+                else {
+                    resolve(items);
+                }
+            };
+            const onError = (error) => {
+                console.error(`IndexedDB getKeyValues(): ${toErrorMessage(error, true)}`);
+                resolve(items);
+            };
+            cursor.onerror = () => onError(cursor.error);
+            transaction.onerror = () => onError(transaction.error);
+        })).finally(() => this.pendingTransactions.splice(this.pendingTransactions.indexOf(transaction), 1));
+    }
+}
+
+export { DBClosedError, IndexedDB };

package/vscode/src/vs/platform/files/common/inMemoryFilesystemProvider.d.ts

@@ -0,0 +1,60 @@
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { ReadableStreamEvents } from "vscode/vscode/vs/base/common/stream";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IFileDeleteOptions, IFileOverwriteOptions, FileSystemProviderCapabilities, FileType, IFileWriteOptions, IFileChange, IFileSystemProviderWithFileReadWriteCapability, IStat, IWatchOptions, IFileSystemProviderWithOpenReadWriteCloseCapability, IFileOpenOptions, IFileSystemProviderWithFileAtomicDeleteCapability, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileAtomicWriteCapability, IFileSystemProviderWithFileReadStreamCapability } from "vscode/vscode/vs/platform/files/common/files";
+declare class File implements IStat {
+    readonly type: FileType.File;
+    readonly ctime: number;
+    mtime: number;
+    size: number;
+    name: string;
+    data?: Uint8Array;
+    constructor(name: string);
+}
+declare class Directory implements IStat {
+    readonly type: FileType.Directory;
+    readonly ctime: number;
+    mtime: number;
+    size: number;
+    name: string;
+    readonly entries: Map<string, File | Directory>;
+    constructor(name: string);
+}
+export declare class InMemoryFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithOpenReadWriteCloseCapability, IFileSystemProviderWithFileReadStreamCapability, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileAtomicWriteCapability, IFileSystemProviderWithFileAtomicDeleteCapability {
+    private memoryFdCounter;
+    private readonly fdMemory;
+    private _onDidChangeCapabilities;
+    readonly onDidChangeCapabilities: Event<void>;
+    private _capabilities;
+    get capabilities(): FileSystemProviderCapabilities;
+    setReadOnly(readonly: boolean): void;
+    root: Directory;
+    stat(resource: URI): Promise<IStat>;
+    readdir(resource: URI): Promise<[
+        string,
+        FileType
+    ][]>;
+    readFile(resource: URI): Promise<Uint8Array>;
+    readFileStream(resource: URI): ReadableStreamEvents<Uint8Array>;
+    writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
+    open(resource: URI, opts: IFileOpenOptions): Promise<number>;
+    close(fd: number): Promise<void>;
+    read(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
+    write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
+    rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
+    delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
+    mkdir(resource: URI): Promise<void>;
+    private _lookup;
+    private _lookupAsDirectory;
+    private _lookupAsFile;
+    private _lookupParentDirectory;
+    private readonly _onDidChangeFile;
+    readonly onDidChangeFile: Event<readonly IFileChange[]>;
+    private _bufferedChanges;
+    private _fireSoonHandle?;
+    watch(resource: URI, opts: IWatchOptions): IDisposable;
+    private _fireSoon;
+    dispose(): void;
+}
+export {};

package/vscode/src/vs/platform/files/common/inMemoryFilesystemProvider.js

@@ -0,0 +1,223 @@
+
+import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { basename, dirname } from 'vscode/vscode/vs/base/common/resources';
+import { newWriteableStream } from 'vscode/vscode/vs/base/common/stream';
+import { FileType, FileSystemProviderCapabilities, createFileSystemProviderError, FileSystemProviderErrorCode, FileChangeType } from 'vscode/vscode/vs/platform/files/common/files';
+
+class File {
+    constructor(name) {
+        this.type = FileType.File;
+        this.ctime = Date.now();
+        this.mtime = Date.now();
+        this.size = 0;
+        this.name = name;
+    }
+}
+class Directory {
+    constructor(name) {
+        this.type = FileType.Directory;
+        this.ctime = Date.now();
+        this.mtime = Date.now();
+        this.size = 0;
+        this.name = name;
+        this.entries = ( new Map());
+    }
+}
+class InMemoryFileSystemProvider extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.memoryFdCounter = 0;
+        this.fdMemory = ( new Map());
+        this._onDidChangeCapabilities = this._register(( new Emitter()));
+        this.onDidChangeCapabilities = this._onDidChangeCapabilities.event;
+        this._capabilities = FileSystemProviderCapabilities.FileReadWrite | FileSystemProviderCapabilities.PathCaseSensitive;
+        this.root = ( new Directory(''));
+        this._onDidChangeFile = this._register(( new Emitter()));
+        this.onDidChangeFile = this._onDidChangeFile.event;
+        this._bufferedChanges = [];
+    }
+    get capabilities() { return this._capabilities; }
+    setReadOnly(readonly) {
+        const isReadonly = !!(this._capabilities & FileSystemProviderCapabilities.Readonly);
+        if (readonly !== isReadonly) {
+            this._capabilities = readonly ? FileSystemProviderCapabilities.Readonly | FileSystemProviderCapabilities.PathCaseSensitive | FileSystemProviderCapabilities.FileReadWrite
+                : FileSystemProviderCapabilities.FileReadWrite | FileSystemProviderCapabilities.PathCaseSensitive;
+            this._onDidChangeCapabilities.fire();
+        }
+    }
+    async stat(resource) {
+        return this._lookup(resource, false);
+    }
+    async readdir(resource) {
+        const entry = this._lookupAsDirectory(resource, false);
+        const result = [];
+        entry.entries.forEach((child, name) => result.push([name, child.type]));
+        return result;
+    }
+    async readFile(resource) {
+        const data = this._lookupAsFile(resource, false).data;
+        if (data) {
+            return data;
+        }
+        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+    }
+    readFileStream(resource) {
+        const data = this._lookupAsFile(resource, false).data;
+        const stream = newWriteableStream(data => VSBuffer.concat(( data.map(data => VSBuffer.wrap(data)))).buffer);
+        stream.end(data);
+        return stream;
+    }
+    async writeFile(resource, content, opts) {
+        const basename$1 = basename(resource);
+        const parent = this._lookupParentDirectory(resource);
+        let entry = parent.entries.get(basename$1);
+        if (entry instanceof Directory) {
+            throw createFileSystemProviderError('file is directory', FileSystemProviderErrorCode.FileIsADirectory);
+        }
+        if (!entry && !opts.create) {
+            throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+        }
+        if (entry && opts.create && !opts.overwrite) {
+            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
+        }
+        if (!entry) {
+            entry = ( new File(basename$1));
+            parent.entries.set(basename$1, entry);
+            this._fireSoon({ type: FileChangeType.ADDED, resource });
+        }
+        entry.mtime = Date.now();
+        entry.size = content.byteLength;
+        entry.data = content;
+        this._fireSoon({ type: FileChangeType.UPDATED, resource });
+    }
+    open(resource, opts) {
+        const data = this._lookupAsFile(resource, false).data;
+        if (data) {
+            const fd = this.memoryFdCounter++;
+            this.fdMemory.set(fd, data);
+            return Promise.resolve(fd);
+        }
+        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+    }
+    close(fd) {
+        this.fdMemory.delete(fd);
+        return Promise.resolve();
+    }
+    read(fd, pos, data, offset, length) {
+        const memory = this.fdMemory.get(fd);
+        if (!memory) {
+            throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
+        }
+        const toWrite = VSBuffer.wrap(memory).slice(pos, pos + length);
+        data.set(toWrite.buffer, offset);
+        return Promise.resolve(toWrite.byteLength);
+    }
+    write(fd, pos, data, offset, length) {
+        const memory = this.fdMemory.get(fd);
+        if (!memory) {
+            throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
+        }
+        const toWrite = VSBuffer.wrap(data).slice(offset, offset + length);
+        memory.set(toWrite.buffer, pos);
+        return Promise.resolve(toWrite.byteLength);
+    }
+    async rename(from, to, opts) {
+        if (!opts.overwrite && this._lookup(to, true)) {
+            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
+        }
+        const entry = this._lookup(from, false);
+        const oldParent = this._lookupParentDirectory(from);
+        const newParent = this._lookupParentDirectory(to);
+        const newName = basename(to);
+        oldParent.entries.delete(entry.name);
+        entry.name = newName;
+        newParent.entries.set(newName, entry);
+        this._fireSoon({ type: FileChangeType.DELETED, resource: from }, { type: FileChangeType.ADDED, resource: to });
+    }
+    async delete(resource, opts) {
+        const dirname$1 = dirname(resource);
+        const basename$1 = basename(resource);
+        const parent = this._lookupAsDirectory(dirname$1, false);
+        if (( parent.entries.has(basename$1))) {
+            parent.entries.delete(basename$1);
+            parent.mtime = Date.now();
+            parent.size -= 1;
+            this._fireSoon({ type: FileChangeType.UPDATED, resource: dirname$1 }, { resource, type: FileChangeType.DELETED });
+        }
+    }
+    async mkdir(resource) {
+        if (this._lookup(resource, true)) {
+            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
+        }
+        const basename$1 = basename(resource);
+        const dirname$1 = dirname(resource);
+        const parent = this._lookupAsDirectory(dirname$1, false);
+        const entry = ( new Directory(basename$1));
+        parent.entries.set(entry.name, entry);
+        parent.mtime = Date.now();
+        parent.size += 1;
+        this._fireSoon({ type: FileChangeType.UPDATED, resource: dirname$1 }, { type: FileChangeType.ADDED, resource });
+    }
+    _lookup(uri, silent) {
+        const parts = uri.path.split('/');
+        let entry = this.root;
+        for (const part of parts) {
+            if (!part) {
+                continue;
+            }
+            let child;
+            if (entry instanceof Directory) {
+                child = entry.entries.get(part);
+            }
+            if (!child) {
+                if (!silent) {
+                    throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+                }
+                else {
+                    return undefined;
+                }
+            }
+            entry = child;
+        }
+        return entry;
+    }
+    _lookupAsDirectory(uri, silent) {
+        const entry = this._lookup(uri, silent);
+        if (entry instanceof Directory) {
+            return entry;
+        }
+        throw createFileSystemProviderError('file not a directory', FileSystemProviderErrorCode.FileNotADirectory);
+    }
+    _lookupAsFile(uri, silent) {
+        const entry = this._lookup(uri, silent);
+        if (entry instanceof File) {
+            return entry;
+        }
+        throw createFileSystemProviderError('file is a directory', FileSystemProviderErrorCode.FileIsADirectory);
+    }
+    _lookupParentDirectory(uri) {
+        const dirname$1 = dirname(uri);
+        return this._lookupAsDirectory(dirname$1, false);
+    }
+    watch(resource, opts) {
+        return Disposable.None;
+    }
+    _fireSoon(...changes) {
+        this._bufferedChanges.push(...changes);
+        if (this._fireSoonHandle) {
+            clearTimeout(this._fireSoonHandle);
+        }
+        this._fireSoonHandle = setTimeout(() => {
+            this._onDidChangeFile.fire(this._bufferedChanges);
+            this._bufferedChanges.length = 0;
+        }, 5);
+    }
+    dispose() {
+        super.dispose();
+        this.fdMemory.clear();
+    }
+}
+
+export { InMemoryFileSystemProvider };

package/vscode/src/vs/workbench/services/storage/browser/storageService.d.ts

@@ -0,0 +1,74 @@
+import { Disposable, IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IStorage, IStorageDatabase, IStorageItemsChangeEvent, IUpdateRequest } from "vscode/vscode/vs/base/parts/storage/common/storage";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { AbstractStorageService, StorageScope } from "vscode/vscode/vs/platform/storage/common/storage";
+import { IUserDataProfile } from "vscode/vscode/vs/platform/userDataProfile/common/userDataProfile";
+import { IAnyWorkspaceIdentifier } from "vscode/vscode/vs/platform/workspace/common/workspace";
+import { IUserDataProfileService } from "vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service";
+export declare class BrowserStorageService extends AbstractStorageService {
+    private workspace;
+    private readonly userDataProfileService;
+    private readonly logService;
+    private static BROWSER_DEFAULT_FLUSH_INTERVAL;
+    private applicationStorage;
+    private applicationStorageDatabase;
+    private readonly applicationStoragePromise;
+    private profileStorage;
+    private profileStorageDatabase;
+    private profileStorageProfile;
+    private readonly profileStorageDisposables;
+    private workspaceStorage;
+    private workspaceStorageDatabase;
+    private readonly workspaceStorageDisposables;
+    get hasPendingUpdate(): boolean;
+    constructor(workspace: IAnyWorkspaceIdentifier, userDataProfileService: IUserDataProfileService, logService: ILogService);
+    private registerListeners;
+    protected doInitialize(): Promise<void>;
+    private createApplicationStorage;
+    private createProfileStorage;
+    private createWorkspaceStorage;
+    private updateIsNew;
+    protected getStorage(scope: StorageScope): IStorage | undefined;
+    protected getLogDetails(scope: StorageScope): string | undefined;
+    protected switchToProfile(toProfile: IUserDataProfile): Promise<void>;
+    protected switchToWorkspace(toWorkspace: IAnyWorkspaceIdentifier, preserveData: boolean): Promise<void>;
+    protected shouldFlushWhenIdle(): boolean;
+    close(): void;
+    clear(): Promise<void>;
+    hasScope(scope: IAnyWorkspaceIdentifier | IUserDataProfile): boolean;
+}
+interface IIndexedDBStorageDatabase extends IStorageDatabase, IDisposable {
+    readonly name: string;
+    readonly hasPendingUpdate: boolean;
+    clear(): Promise<void>;
+}
+interface IndexedDBStorageDatabaseOptions {
+    id: string;
+    broadcastChanges?: boolean;
+}
+export declare class IndexedDBStorageDatabase extends Disposable implements IIndexedDBStorageDatabase {
+    private readonly logService;
+    static createApplicationStorage(logService: ILogService): Promise<IIndexedDBStorageDatabase>;
+    static createProfileStorage(profile: IUserDataProfile, logService: ILogService): Promise<IIndexedDBStorageDatabase>;
+    static createWorkspaceStorage(workspaceId: string, logService: ILogService): Promise<IIndexedDBStorageDatabase>;
+    static create(options: IndexedDBStorageDatabaseOptions, logService: ILogService): Promise<IIndexedDBStorageDatabase>;
+    private static readonly STORAGE_DATABASE_PREFIX;
+    private static readonly STORAGE_OBJECT_STORE;
+    private readonly _onDidChangeItemsExternal;
+    readonly onDidChangeItemsExternal: import("vscode/vscode/vs/base/common/event").Event<IStorageItemsChangeEvent>;
+    private broadcastChannel;
+    private pendingUpdate;
+    get hasPendingUpdate(): boolean;
+    readonly name: string;
+    private readonly whenConnected;
+    private constructor();
+    private registerListeners;
+    private connect;
+    getItems(): Promise<Map<string, string>>;
+    updateItems(request: IUpdateRequest): Promise<void>;
+    private doUpdateItems;
+    optimize(): Promise<void>;
+    close(): Promise<void>;
+    clear(): Promise<void>;
+}
+export {};

package/vscode/src/vs/workbench/services/storage/browser/storageService.js

@@ -0,0 +1,293 @@
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
+import { BroadcastDataChannel } from '@codingame/monaco-vscode-e571cbbb-526b-5d8b-92c5-a0437d2dabb3-common/vscode/vs/base/browser/broadcast';
+import { isSafari } from 'vscode/vscode/vs/base/browser/browser';
+import { getActiveWindow } from 'vscode/vscode/vs/base/browser/dom';
+import { IndexedDB } from '../../../../base/browser/indexedDB.js';
+import { DeferredPromise, Promises } from 'vscode/vscode/vs/base/common/async';
+import { toErrorMessage } from 'vscode/vscode/vs/base/common/errorMessage';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { DisposableStore, Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { assertIsDefined } from 'vscode/vscode/vs/base/common/types';
+import { Storage, InMemoryStorageDatabase, isStorageItemsChangeEvent } from 'vscode/vscode/vs/base/parts/storage/common/storage';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { AbstractStorageService, StorageScope, isProfileUsingDefaultStorage, IS_NEW_KEY, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { isUserDataProfile } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile';
+
+var BrowserStorageService_1;
+let BrowserStorageService = class BrowserStorageService extends AbstractStorageService {
+    static { BrowserStorageService_1 = this; }
+    static { this.BROWSER_DEFAULT_FLUSH_INTERVAL = 5 * 1000; }
+    get hasPendingUpdate() {
+        return Boolean(this.applicationStorageDatabase?.hasPendingUpdate ||
+            this.profileStorageDatabase?.hasPendingUpdate ||
+            this.workspaceStorageDatabase?.hasPendingUpdate);
+    }
+    constructor(workspace, userDataProfileService, logService) {
+        super({ flushInterval: BrowserStorageService_1.BROWSER_DEFAULT_FLUSH_INTERVAL });
+        this.workspace = workspace;
+        this.userDataProfileService = userDataProfileService;
+        this.logService = logService;
+        this.applicationStoragePromise = ( new DeferredPromise());
+        this.profileStorageProfile = this.userDataProfileService.currentProfile;
+        this.profileStorageDisposables = this._register(( new DisposableStore()));
+        this.workspaceStorageDisposables = this._register(( new DisposableStore()));
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.userDataProfileService.onDidChangeCurrentProfile(e => e.join(this.switchToProfile(e.profile))));
+    }
+    async doInitialize() {
+        await Promises.settled([
+            this.createApplicationStorage(),
+            this.createProfileStorage(this.profileStorageProfile),
+            this.createWorkspaceStorage()
+        ]);
+    }
+    async createApplicationStorage() {
+        const applicationStorageIndexedDB = await IndexedDBStorageDatabase.createApplicationStorage(this.logService);
+        this.applicationStorageDatabase = this._register(applicationStorageIndexedDB);
+        this.applicationStorage = this._register(( new Storage(this.applicationStorageDatabase)));
+        this._register(this.applicationStorage.onDidChangeStorage(e => this.emitDidChangeValue(StorageScope.APPLICATION, e)));
+        await this.applicationStorage.init();
+        this.updateIsNew(this.applicationStorage);
+        this.applicationStoragePromise.complete({ indexedDb: applicationStorageIndexedDB, storage: this.applicationStorage });
+    }
+    async createProfileStorage(profile) {
+        this.profileStorageDisposables.clear();
+        this.profileStorageProfile = profile;
+        if (isProfileUsingDefaultStorage(this.profileStorageProfile)) {
+            const { indexedDb: applicationStorageIndexedDB, storage: applicationStorage } = await this.applicationStoragePromise.p;
+            this.profileStorageDatabase = applicationStorageIndexedDB;
+            this.profileStorage = applicationStorage;
+            this.profileStorageDisposables.add(this.profileStorage.onDidChangeStorage(e => this.emitDidChangeValue(StorageScope.PROFILE, e)));
+        }
+        else {
+            const profileStorageIndexedDB = await IndexedDBStorageDatabase.createProfileStorage(this.profileStorageProfile, this.logService);
+            this.profileStorageDatabase = this.profileStorageDisposables.add(profileStorageIndexedDB);
+            this.profileStorage = this.profileStorageDisposables.add(( new Storage(this.profileStorageDatabase)));
+            this.profileStorageDisposables.add(this.profileStorage.onDidChangeStorage(e => this.emitDidChangeValue(StorageScope.PROFILE, e)));
+            await this.profileStorage.init();
+            this.updateIsNew(this.profileStorage);
+        }
+    }
+    async createWorkspaceStorage() {
+        this.workspaceStorageDisposables.clear();
+        const workspaceStorageIndexedDB = await IndexedDBStorageDatabase.createWorkspaceStorage(this.workspace.id, this.logService);
+        this.workspaceStorageDatabase = this.workspaceStorageDisposables.add(workspaceStorageIndexedDB);
+        this.workspaceStorage = this.workspaceStorageDisposables.add(( new Storage(this.workspaceStorageDatabase)));
+        this.workspaceStorageDisposables.add(this.workspaceStorage.onDidChangeStorage(e => this.emitDidChangeValue(StorageScope.WORKSPACE, e)));
+        await this.workspaceStorage.init();
+        this.updateIsNew(this.workspaceStorage);
+    }
+    updateIsNew(storage) {
+        const firstOpen = storage.getBoolean(IS_NEW_KEY);
+        if (firstOpen === undefined) {
+            storage.set(IS_NEW_KEY, true);
+        }
+        else if (firstOpen) {
+            storage.set(IS_NEW_KEY, false);
+        }
+    }
+    getStorage(scope) {
+        switch (scope) {
+            case StorageScope.APPLICATION:
+                return this.applicationStorage;
+            case StorageScope.PROFILE:
+                return this.profileStorage;
+            default:
+                return this.workspaceStorage;
+        }
+    }
+    getLogDetails(scope) {
+        switch (scope) {
+            case StorageScope.APPLICATION:
+                return this.applicationStorageDatabase?.name;
+            case StorageScope.PROFILE:
+                return this.profileStorageDatabase?.name;
+            default:
+                return this.workspaceStorageDatabase?.name;
+        }
+    }
+    async switchToProfile(toProfile) {
+        if (!this.canSwitchProfile(this.profileStorageProfile, toProfile)) {
+            return;
+        }
+        const oldProfileStorage = assertIsDefined(this.profileStorage);
+        const oldItems = oldProfileStorage.items;
+        if (oldProfileStorage !== this.applicationStorage) {
+            await oldProfileStorage.close();
+        }
+        await this.createProfileStorage(toProfile);
+        this.switchData(oldItems, assertIsDefined(this.profileStorage), StorageScope.PROFILE);
+    }
+    async switchToWorkspace(toWorkspace, preserveData) {
+        const oldWorkspaceStorage = assertIsDefined(this.workspaceStorage);
+        const oldItems = preserveData ? oldWorkspaceStorage.items : ( new Map());
+        await oldWorkspaceStorage.close();
+        this.workspace = toWorkspace;
+        await this.createWorkspaceStorage();
+        this.switchData(oldItems, assertIsDefined(this.workspaceStorage), StorageScope.WORKSPACE);
+    }
+    shouldFlushWhenIdle() {
+        return getActiveWindow().document.hasFocus() && !this.hasPendingUpdate;
+    }
+    close() {
+        if (isSafari) {
+            this.applicationStorage?.close();
+            this.profileStorageDatabase?.close();
+            this.workspaceStorageDatabase?.close();
+        }
+        this.dispose();
+    }
+    async clear() {
+        for (const scope of [StorageScope.APPLICATION, StorageScope.PROFILE, StorageScope.WORKSPACE]) {
+            for (const target of [StorageTarget.USER, StorageTarget.MACHINE]) {
+                for (const key of ( this.keys(scope, target))) {
+                    this.remove(key, scope);
+                }
+            }
+            await this.getStorage(scope)?.whenFlushed();
+        }
+        await Promises.settled([
+            this.applicationStorageDatabase?.clear() ?? Promise.resolve(),
+            this.profileStorageDatabase?.clear() ?? Promise.resolve(),
+            this.workspaceStorageDatabase?.clear() ?? Promise.resolve()
+        ]);
+    }
+    hasScope(scope) {
+        if (isUserDataProfile(scope)) {
+            return this.profileStorageProfile.id === scope.id;
+        }
+        return this.workspace.id === scope.id;
+    }
+};
+BrowserStorageService = BrowserStorageService_1 = ( __decorate([
+    ( __param(2, ILogService))
+], BrowserStorageService));
+class InMemoryIndexedDBStorageDatabase extends InMemoryStorageDatabase {
+    constructor() {
+        super(...arguments);
+        this.hasPendingUpdate = false;
+        this.name = 'in-memory-indexedb-storage';
+    }
+    async clear() {
+        (await this.getItems()).clear();
+    }
+    dispose() {
+    }
+}
+class IndexedDBStorageDatabase extends Disposable {
+    static async createApplicationStorage(logService) {
+        return IndexedDBStorageDatabase.create({ id: 'global', broadcastChanges: true }, logService);
+    }
+    static async createProfileStorage(profile, logService) {
+        return IndexedDBStorageDatabase.create({ id: `global-${profile.id}`, broadcastChanges: true }, logService);
+    }
+    static async createWorkspaceStorage(workspaceId, logService) {
+        return IndexedDBStorageDatabase.create({ id: workspaceId }, logService);
+    }
+    static async create(options, logService) {
+        try {
+            const database = ( new IndexedDBStorageDatabase(options, logService));
+            await database.whenConnected;
+            return database;
+        }
+        catch (error) {
+            logService.error(`[IndexedDB Storage ${options.id}] create(): ${toErrorMessage(error, true)}`);
+            return ( new InMemoryIndexedDBStorageDatabase());
+        }
+    }
+    static { this.STORAGE_DATABASE_PREFIX = 'vscode-web-state-db-'; }
+    static { this.STORAGE_OBJECT_STORE = 'ItemTable'; }
+    get hasPendingUpdate() { return !!this.pendingUpdate; }
+    constructor(options, logService) {
+        super();
+        this.logService = logService;
+        this._onDidChangeItemsExternal = this._register(( new Emitter()));
+        this.onDidChangeItemsExternal = this._onDidChangeItemsExternal.event;
+        this.pendingUpdate = undefined;
+        this.name = `${IndexedDBStorageDatabase.STORAGE_DATABASE_PREFIX}${options.id}`;
+        this.broadcastChannel = options.broadcastChanges ? this._register(( new BroadcastDataChannel(this.name))) : undefined;
+        this.whenConnected = this.connect();
+        this.registerListeners();
+    }
+    registerListeners() {
+        if (this.broadcastChannel) {
+            this._register(this.broadcastChannel.onDidReceiveData(data => {
+                if (isStorageItemsChangeEvent(data)) {
+                    this._onDidChangeItemsExternal.fire(data);
+                }
+            }));
+        }
+    }
+    async connect() {
+        try {
+            return await IndexedDB.create(this.name, undefined, [IndexedDBStorageDatabase.STORAGE_OBJECT_STORE]);
+        }
+        catch (error) {
+            this.logService.error(`[IndexedDB Storage ${this.name}] connect() error: ${toErrorMessage(error)}`);
+            throw error;
+        }
+    }
+    async getItems() {
+        const db = await this.whenConnected;
+        function isValid(value) {
+            return typeof value === 'string';
+        }
+        return db.getKeyValues(IndexedDBStorageDatabase.STORAGE_OBJECT_STORE, isValid);
+    }
+    async updateItems(request) {
+        let didUpdate = false;
+        this.pendingUpdate = this.doUpdateItems(request);
+        try {
+            didUpdate = await this.pendingUpdate;
+        }
+        finally {
+            this.pendingUpdate = undefined;
+        }
+        if (this.broadcastChannel && didUpdate) {
+            const event = {
+                changed: request.insert,
+                deleted: request.delete
+            };
+            this.broadcastChannel.postData(event);
+        }
+    }
+    async doUpdateItems(request) {
+        const toInsert = request.insert;
+        const toDelete = request.delete;
+        if ((!toInsert && !toDelete) || (toInsert?.size === 0 && toDelete?.size === 0)) {
+            return false;
+        }
+        const db = await this.whenConnected;
+        await db.runInTransaction(IndexedDBStorageDatabase.STORAGE_OBJECT_STORE, 'readwrite', objectStore => {
+            const requests = [];
+            if (toInsert) {
+                for (const [key, value] of toInsert) {
+                    requests.push(objectStore.put(value, key));
+                }
+            }
+            if (toDelete) {
+                for (const key of toDelete) {
+                    requests.push(objectStore.delete(key));
+                }
+            }
+            return requests;
+        });
+        return true;
+    }
+    async optimize() {
+    }
+    async close() {
+        const db = await this.whenConnected;
+        await this.pendingUpdate;
+        return db.close();
+    }
+    async clear() {
+        const db = await this.whenConnected;
+        await db.runInTransaction(IndexedDBStorageDatabase.STORAGE_OBJECT_STORE, 'readwrite', objectStore => objectStore.clear());
+    }
+}
+
+export { BrowserStorageService, IndexedDBStorageDatabase };