@codingame/monaco-vscode-api 4.5.0 → 4.5.2

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

@@ -0,0 +1,59 @@
+import { Event } from '../../../base/common/event.js';
+import { Disposable, IDisposable } from '../../../base/common/lifecycle.js';
+import { ReadableStreamEvents } from '../../../base/common/stream.js';
+import { URI } from '../../../base/common/uri.js';
+import { IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithOpenReadWriteCloseCapability, IFileSystemProviderWithFileReadStreamCapability, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileAtomicWriteCapability, IFileSystemProviderWithFileAtomicDeleteCapability, FileSystemProviderCapabilities, IStat, FileType, IFileWriteOptions, IFileOpenOptions, IFileOverwriteOptions, IFileDeleteOptions, IFileChange, IWatchOptions } from './files.js';
+
+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);
+}
+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 { InMemoryFileSystemProvider };

package/vscode/src/vs/platform/history/browser/contextScopedHistoryWidget.js

@@ -8,11 +8,8 @@ import { KeybindingsRegistry } from '../../keybinding/common/keybindingsRegistry
 import { localizeWithPath } from '../../../nls.js';
 import { toDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
 import { isActiveElement } from '../../../base/browser/dom.js';
-const historyNavigationVisible = ( new RawContextKey('suggestWidgetVisible', false, ( localizeWithPath(
-    'vs/platform/history/browser/contextScopedHistoryWidget',
-    'suggestWidgetVisible',
-    "Whether suggestion are visible"
-))));
+const _moduleId = "vs/platform/history/browser/contextScopedHistoryWidget";
+const historyNavigationVisible = ( (new RawContextKey('suggestWidgetVisible', false, ( localizeWithPath(_moduleId, 0, "Whether suggestion are visible")))));
 const HistoryNavigationWidgetFocusContext = 'historyNavigationWidgetFocus';
 const HistoryNavigationForwardsEnablementContext = 'historyNavigationForwardsEnabled';
 const HistoryNavigationBackwardsEnablementContext = 'historyNavigationBackwardsEnabled';
@@ -20,13 +17,13 @@ let lastFocusedWidget = undefined;
 const widgets = [];
 function registerAndCreateHistoryNavigationContext(scopedContextKeyService, widget) {
     if (widgets.includes(widget)) {
-        throw new Error('Cannot register the same widget multiple times');
+        throw ( (new Error('Cannot register the same widget multiple times')));
     }
     widgets.push(widget);
-    const disposableStore = ( new DisposableStore());
-    const historyNavigationWidgetFocus = ( new RawContextKey(HistoryNavigationWidgetFocusContext, false)).bindTo(scopedContextKeyService);
-    const historyNavigationForwardsEnablement = ( new RawContextKey(HistoryNavigationForwardsEnablementContext, true)).bindTo(scopedContextKeyService);
-    const historyNavigationBackwardsEnablement = ( new RawContextKey(HistoryNavigationBackwardsEnablementContext, true)).bindTo(scopedContextKeyService);
+    const disposableStore = ( (new DisposableStore()));
+    const historyNavigationWidgetFocus = ( (new RawContextKey(HistoryNavigationWidgetFocusContext, false))).bindTo(scopedContextKeyService);
+    const historyNavigationForwardsEnablement = ( (new RawContextKey(HistoryNavigationForwardsEnablementContext, true))).bindTo(scopedContextKeyService);
+    const historyNavigationBackwardsEnablement = ( (new RawContextKey(HistoryNavigationBackwardsEnablementContext, true))).bindTo(scopedContextKeyService);
     const onDidFocus = () => {
         historyNavigationWidgetFocus.set(true);
         lastFocusedWidget = widget;
@@ -61,9 +58,9 @@ let ContextScopedHistoryInputBox = class ContextScopedHistoryInputBox extends Hi
         this._register(registerAndCreateHistoryNavigationContext(scopedContextKeyService, this));
     }
 };
-ContextScopedHistoryInputBox = ( __decorate([
-    ( __param(3, IContextKeyService))
-], ContextScopedHistoryInputBox));
+ContextScopedHistoryInputBox = ( (__decorate([
+    ( (__param(3, IContextKeyService)))
+], ContextScopedHistoryInputBox)));
 let ContextScopedFindInput = class ContextScopedFindInput extends FindInput {
     constructor(container, contextViewProvider, options, contextKeyService) {
         super(container, contextViewProvider, options);
@@ -71,9 +68,9 @@ let ContextScopedFindInput = class ContextScopedFindInput extends FindInput {
         this._register(registerAndCreateHistoryNavigationContext(scopedContextKeyService, this.inputBox));
     }
 };
-ContextScopedFindInput = ( __decorate([
-    ( __param(3, IContextKeyService))
-], ContextScopedFindInput));
+ContextScopedFindInput = ( (__decorate([
+    ( (__param(3, IContextKeyService)))
+], ContextScopedFindInput)));
 let ContextScopedReplaceInput = class ContextScopedReplaceInput extends ReplaceInput {
     constructor(container, contextViewProvider, options, contextKeyService, showReplaceOptions = false) {
         super(container, contextViewProvider, showReplaceOptions, options);
@@ -81,13 +78,18 @@ let ContextScopedReplaceInput = class ContextScopedReplaceInput extends ReplaceI
         this._register(registerAndCreateHistoryNavigationContext(scopedContextKeyService, this.inputBox));
     }
 };
-ContextScopedReplaceInput = ( __decorate([
-    ( __param(3, IContextKeyService))
-], ContextScopedReplaceInput));
+ContextScopedReplaceInput = ( (__decorate([
+    ( (__param(3, IContextKeyService)))
+], ContextScopedReplaceInput)));
 KeybindingsRegistry.registerCommandAndKeybindingRule({
     id: 'history.showPrevious',
     weight: 200 ,
-    when: ( ContextKeyExpr.and(( ContextKeyExpr.has(HistoryNavigationWidgetFocusContext)), ( ContextKeyExpr.equals(HistoryNavigationBackwardsEnablementContext, true)), ContextKeyExpr.not('isComposing'), ( historyNavigationVisible.isEqualTo(false)))),
+    when: ( (ContextKeyExpr.and(
+         (ContextKeyExpr.has(HistoryNavigationWidgetFocusContext)),
+         (ContextKeyExpr.equals(HistoryNavigationBackwardsEnablementContext, true)),
+        ContextKeyExpr.not('isComposing'),
+         (historyNavigationVisible.isEqualTo(false))
+    ))),
     primary: 16 ,
     secondary: [512  | 16 ],
     handler: (accessor) => {
@@ -97,7 +99,12 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
 KeybindingsRegistry.registerCommandAndKeybindingRule({
     id: 'history.showNext',
     weight: 200 ,
-    when: ( ContextKeyExpr.and(( ContextKeyExpr.has(HistoryNavigationWidgetFocusContext)), ( ContextKeyExpr.equals(HistoryNavigationForwardsEnablementContext, true)), ContextKeyExpr.not('isComposing'), ( historyNavigationVisible.isEqualTo(false)))),
+    when: ( (ContextKeyExpr.and(
+         (ContextKeyExpr.has(HistoryNavigationWidgetFocusContext)),
+         (ContextKeyExpr.equals(HistoryNavigationForwardsEnablementContext, true)),
+        ContextKeyExpr.not('isComposing'),
+         (historyNavigationVisible.isEqualTo(false))
+    ))),
     primary: 18 ,
     secondary: [512  | 18 ],
     handler: (accessor) => {

package/vscode/src/vs/platform/hover/browser/hover.js

@@ -60,7 +60,7 @@ let WorkbenchHoverDelegate = class WorkbenchHoverDelegate extends Disposable {
     }
     setInstantHoverTimeLimit(timeLimit) {
         if (!this.instantHover) {
-            throw new Error('Instant hover is not enabled');
+            throw ( new Error('Instant hover is not enabled'));
         }
         this.timeLimit = timeLimit;
     }
@@ -77,7 +77,7 @@ WorkbenchHoverDelegate = ( __decorate([
 ], WorkbenchHoverDelegate));
 const nativeHoverDelegate = {
     showHover: function () {
-        throw new Error('Native hover function not implemented.');
+        throw ( new Error('Native hover function not implemented.'));
     },
     delay: 0,
     showNativeHover: true

package/vscode/src/vs/platform/instantiation/common/instantiation.js

@@ -24,7 +24,7 @@ function createDecorator(serviceId) {
     }
     const id = function (target, key, index) {
         if (arguments.length !== 3) {
-            throw new Error('@IServiceName-decorator can only be used to decorate a parameter');
+            throw ( new Error('@IServiceName-decorator can only be used to decorate a parameter'));
         }
         storeServiceDependency(id, target, index);
     };

package/vscode/src/vs/platform/instantiation/common/instantiationService.js

@@ -37,7 +37,7 @@ class InstantiationService {
                     }
                     const result = this._getOrCreateServiceInstance(id, _trace);
                     if (!result) {
-                        throw new Error(`[invokeFunction] unknown service '${id}'`);
+                        throw ( new Error(`[invokeFunction] unknown service '${id}'`));
                     }
                     return result;
                 }
@@ -94,7 +94,7 @@ class InstantiationService {
             this._parent._setServiceInstance(id, instance);
         }
         else {
-            throw new Error('illegalState - setting UNKNOWN service instance');
+            throw ( new Error('illegalState - setting UNKNOWN service instance'));
         }
     }
     _getServiceInstanceOrDescriptor(id) {
@@ -121,7 +121,7 @@ class InstantiationService {
     }
     _safeCreateAndCacheServiceInstance(id, desc, _trace) {
         if (( this._activeInstantiations.has(id))) {
-            throw new Error(`illegal state - RECURSIVELY instantiating service '${id}'`);
+            throw ( new Error(`illegal state - RECURSIVELY instantiating service '${id}'`));
         }
         this._activeInstantiations.add(id);
         try {
@@ -139,7 +139,7 @@ class InstantiationService {
             const item = stack.pop();
             graph.lookupOrInsertNode(item);
             if (cycleCount++ > 1000) {
-                throw new CyclicDependencyError(graph);
+                throw ( new CyclicDependencyError(graph));
             }
             for (const dependency of _util.getServiceDependencies(item.desc.ctor)) {
                 const instanceOrDesc = this._getServiceInstanceOrDescriptor(dependency.id);
@@ -160,7 +160,7 @@ class InstantiationService {
             const roots = graph.roots();
             if (roots.length === 0) {
                 if (!graph.isEmpty()) {
-                    throw new CyclicDependencyError(graph);
+                    throw ( new CyclicDependencyError(graph));
                 }
                 break;
             }
@@ -183,7 +183,7 @@ class InstantiationService {
             return this._parent._createServiceInstanceWithOwner(id, ctor, args, supportsDelayedInstantiation, _trace);
         }
         else {
-            throw new Error(`illegalState - creating UNKNOWN service instance ${ctor.name}`);
+            throw ( new Error(`illegalState - creating UNKNOWN service instance ${ctor.name}`));
         }
     }
     _createServiceInstance(id, ctor, args = [], supportsDelayedInstantiation, _trace) {
@@ -260,7 +260,7 @@ class InstantiationService {
             console.warn(msg);
         }
         if (this._strict) {
-            throw new Error(msg);
+            throw ( new Error(msg));
         }
     }
 }

package/vscode/src/vs/platform/keybinding/common/abstractKeybindingService.js

@@ -6,6 +6,7 @@ import { IME } from '../../../base/common/ime.js';
 import { Disposable } from '../../../base/common/lifecycle.js';
 import { localizeWithPath } from '../../../nls.js';
 import { NoMatchingKb } from './keybindingResolver.js';
+const _moduleId = "vs/platform/keybinding/common/abstractKeybindingService";
 const HIGH_FREQ_COMMANDS = /^(cursor|delete|undo|redo|tab|editor\.action\.clipboard)/;
 class AbstractKeybindingService extends Disposable {
     get onDidUpdateKeybindings() {
@@ -21,13 +22,13 @@ class AbstractKeybindingService extends Disposable {
         this._telemetryService = _telemetryService;
         this._notificationService = _notificationService;
         this._logService = _logService;
-        this._onDidUpdateKeybindings = this._register(( new Emitter()));
+        this._onDidUpdateKeybindings = this._register(( (new Emitter())));
         this._currentChords = [];
-        this._currentChordChecker = ( new IntervalTimer());
+        this._currentChordChecker = ( (new IntervalTimer()));
         this._currentChordStatusMessage = null;
         this._ignoreSingleModifiers = KeybindingModifierSet.EMPTY;
         this._currentSingleModifier = null;
-        this._currentSingleModifierClearTimeout = ( new TimeoutTimer());
+        this._currentSingleModifierClearTimeout = ( (new TimeoutTimer()));
         this._currentlyDispatchingCommandId = null;
         this._logging = false;
     }
@@ -56,7 +57,7 @@ class AbstractKeybindingService extends Disposable {
         return 0;
     }
     lookupKeybindings(commandId) {
-        return coalesce(( this._getResolver().lookupKeybindings(commandId).map(item => item.resolvedKeybinding)));
+        return coalesce(( (this._getResolver().lookupKeybindings(commandId).map(item => item.resolvedKeybinding))));
     }
     lookupKeybinding(commandId, context) {
         const result = this._getResolver().lookupPrimaryKeybinding(commandId, context || this._contextKeyService);
@@ -81,7 +82,7 @@ class AbstractKeybindingService extends Disposable {
             return NoMatchingKb;
         }
         const contextValue = this._contextKeyService.getContext(target);
-        const currentChords = ( this._currentChords.map((({ keypress }) => keypress)));
+        const currentChords = ( (this._currentChords.map((({ keypress }) => keypress))));
         return this._getResolver().resolve(contextValue, currentChords, firstChord);
     }
     _scheduleLeaveChordMode() {
@@ -103,17 +104,17 @@ class AbstractKeybindingService extends Disposable {
                 throw illegalState('impossible');
             case 1:
                 this._currentChordStatusMessage = this._notificationService.status(( localizeWithPath(
-                    'vs/platform/keybinding/common/abstractKeybindingService',
-                    'first.chord',
+                    _moduleId,
+                    0,
                     "({0}) was pressed. Waiting for second key of chord...",
                     keypressLabel
                 )));
                 break;
             default: {
-                const fullKeypressLabel = ( this._currentChords.map(({ label }) => label)).join(', ');
+                const fullKeypressLabel = ( (this._currentChords.map(({ label }) => label))).join(', ');
                 this._currentChordStatusMessage = this._notificationService.status(( localizeWithPath(
-                    'vs/platform/keybinding/common/abstractKeybindingService',
-                    'next.chord',
+                    _moduleId,
+                    1,
                     "({0}) was pressed. Waiting for next key of chord...",
                     fullKeypressLabel
                 )));
@@ -150,7 +151,7 @@ class AbstractKeybindingService extends Disposable {
         const keybinding = this.resolveKeyboardEvent(e);
         const [singleModifier,] = keybinding.getSingleModifierDispatchChords();
         if (singleModifier) {
-            if (( this._ignoreSingleModifiers.has(singleModifier))) {
+            if (( (this._ignoreSingleModifiers.has(singleModifier)))) {
                 this._log(`+ Ignoring single modifier ${singleModifier} due to it being pressed together with other keys.`);
                 this._ignoreSingleModifiers = KeybindingModifierSet.EMPTY;
                 this._currentSingleModifierClearTimeout.cancel();
@@ -179,7 +180,7 @@ class AbstractKeybindingService extends Disposable {
             return false;
         }
         const [firstChord,] = keybinding.getChords();
-        this._ignoreSingleModifiers = ( new KeybindingModifierSet(firstChord));
+        this._ignoreSingleModifiers = ( (new KeybindingModifierSet(firstChord)));
         if (this._currentSingleModifier !== null) {
             this._log(`+ Clearing single modifier due to other key up.`);
         }
@@ -202,7 +203,7 @@ class AbstractKeybindingService extends Disposable {
         }
         else {
             [userPressedChord,] = userKeypress.getDispatchChords();
-            currentChords = ( this._currentChords.map(({ keypress }) => keypress));
+            currentChords = ( (this._currentChords.map(({ keypress }) => keypress)));
         }
         if (userPressedChord === null) {
             this._log(`\\ Keyboard event cannot be dispatched in keydown phase.`);
@@ -215,11 +216,11 @@ class AbstractKeybindingService extends Disposable {
             case 0 : {
                 this._logService.trace('KeybindingService#dispatch', keypressLabel, `[ No matching keybinding ]`);
                 if (this.inChordMode) {
-                    const currentChordsLabel = ( this._currentChords.map(({ label }) => label)).join(', ');
+                    const currentChordsLabel = ( (this._currentChords.map(({ label }) => label))).join(', ');
                     this._log(`+ Leaving multi-chord mode: Nothing bound to "${currentChordsLabel}, ${keypressLabel}".`);
                     this._notificationService.status(( localizeWithPath(
-                        'vs/platform/keybinding/common/abstractKeybindingService',
-                        'missing.chord',
+                        _moduleId,
+                        2,
                         "The key combination ({0}, {1}) is not a command.",
                         currentChordsLabel,
                         keypressLabel
@@ -240,11 +241,11 @@ class AbstractKeybindingService extends Disposable {
                 this._logService.trace('KeybindingService#dispatch', keypressLabel, `[ Will dispatch command ${resolveResult.commandId} ]`);
                 if (resolveResult.commandId === null || resolveResult.commandId === '') {
                     if (this.inChordMode) {
-                        const currentChordsLabel = ( this._currentChords.map(({ label }) => label)).join(', ');
+                        const currentChordsLabel = ( (this._currentChords.map(({ label }) => label))).join(', ');
                         this._log(`+ Leaving chord mode: Nothing bound to "${currentChordsLabel}, ${keypressLabel}".`);
                         this._notificationService.status(( localizeWithPath(
-                            'vs/platform/keybinding/common/abstractKeybindingService',
-                            'missing.chord',
+                            _moduleId,
+                            2,
                             "The key combination ({0}, {1}) is not a command.",
                             currentChordsLabel,
                             keypressLabel
@@ -293,7 +294,7 @@ class AbstractKeybindingService extends Disposable {
     }
 }
 class KeybindingModifierSet {
-    static { this.EMPTY = ( new KeybindingModifierSet(null)); }
+    static { this.EMPTY = ( (new KeybindingModifierSet(null))); }
     constructor(source) {
         this._ctrlKey = source ? source.ctrlKey : false;
         this._shiftKey = source ? source.shiftKey : false;

package/vscode/src/vs/platform/languagePacks/common/languagePacks.js

@@ -1,9 +1,78 @@
-import '../../../base/common/cancellation.js';
-import '../../../base/common/lifecycle.js';
-import '../../../base/common/platform.js';
-import '../../../nls.js';
-import '../../instantiation/common/instantiation.js';
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { CancellationTokenSource } from '../../../base/common/cancellation.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { language } from '../../../base/common/platform.js';
+import { localizeWithPath } from '../../../nls.js';
+import { IExtensionGalleryService } from '../../extensionManagement/common/extensionManagement.service.js';
+const _moduleId = "vs/platform/languagePacks/common/languagePacks";
 function getLocale(extension) {
     return extension.tags.find(t => t.startsWith('lp-'))?.split('lp-')[1];
 }
-export { getLocale };
+let LanguagePackBaseService = class LanguagePackBaseService extends Disposable {
+    constructor(extensionGalleryService) {
+        super();
+        this.extensionGalleryService = extensionGalleryService;
+    }
+    async getAvailableLanguages() {
+        const timeout = ( (new CancellationTokenSource()));
+        setTimeout(() => timeout.cancel(), 1000);
+        let result;
+        try {
+            result = await this.extensionGalleryService.query({
+                text: 'category:"language packs"',
+                pageSize: 20
+            }, timeout.token);
+        }
+        catch (_) {
+            return [];
+        }
+        const languagePackExtensions = result.firstPage.filter(e => e.properties.localizedLanguages?.length && ( (e.tags.some(t => t.startsWith('lp-')))));
+        const allFromMarketplace = ( (languagePackExtensions.map(lp => {
+            const languageName = lp.properties.localizedLanguages?.[0];
+            const locale = getLocale(lp);
+            const baseQuickPick = this.createQuickPickItem(locale, languageName, lp);
+            return {
+                ...baseQuickPick,
+                extensionId: lp.identifier.id,
+                galleryExtension: lp
+            };
+        })));
+        allFromMarketplace.push(this.createQuickPickItem('en', 'English'));
+        return allFromMarketplace;
+    }
+    createQuickPickItem(locale, languageName, languagePack) {
+        const label = languageName ?? locale;
+        let description;
+        if (label !== locale) {
+            description = `(${locale})`;
+        }
+        if (locale.toLowerCase() === language.toLowerCase()) {
+            description ??= '';
+            description += ( localizeWithPath(_moduleId, 0, " (Current)"));
+        }
+        if (languagePack?.installCount) {
+            description ??= '';
+            const count = languagePack.installCount;
+            let countLabel;
+            if (count > 1000000) {
+                countLabel = `${Math.floor(count / 100000) / 10}M`;
+            }
+            else if (count > 1000) {
+                countLabel = `${Math.floor(count / 1000)}K`;
+            }
+            else {
+                countLabel = String(count);
+            }
+            description += ` $(cloud-download) ${countLabel}`;
+        }
+        return {
+            id: locale,
+            label,
+            description
+        };
+    }
+};
+LanguagePackBaseService = ( (__decorate([
+    ( (__param(0, IExtensionGalleryService)))
+], LanguagePackBaseService)));
+export { LanguagePackBaseService, getLocale };

package/vscode/src/vs/platform/layout/browser/zIndexRegistry.js

@@ -29,11 +29,13 @@ class ZIndexRegistry {
     }
     registerZIndex(relativeLayer, z, name) {
         if (this.zIndexMap.get(name)) {
-            throw new Error(`z-index with name ${name} has already been registered.`);
+            throw ( new Error(`z-index with name ${name} has already been registered.`));
         }
         const proposedZValue = relativeLayer + z;
         if (findBase(proposedZValue) !== relativeLayer) {
-            throw new Error(`Relative layer: ${relativeLayer} + z-index: ${z} exceeds next layer ${proposedZValue}.`);
+            throw ( new Error(
+                `Relative layer: ${relativeLayer} + z-index: ${z} exceeds next layer ${proposedZValue}.`
+            ));
         }
         this.zIndexMap.set(name, proposedZValue);
         this.scheduler.schedule();