@umbraco-cms/backoffice 15.3.0 → 15.4.0-rc

package/dist-cms/monaco-editor/vs/base/common/keybindings.js

@@ -0,0 +1,123 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { illegalArgument } from './errors.js';
+export function decodeKeybinding(keybinding, OS) {
+    if (typeof keybinding === 'number') {
+        if (keybinding === 0) {
+            return null;
+        }
+        const firstChord = (keybinding & 0x0000FFFF) >>> 0;
+        const secondChord = (keybinding & 0xFFFF0000) >>> 16;
+        if (secondChord !== 0) {
+            return new Keybinding([
+                createSimpleKeybinding(firstChord, OS),
+                createSimpleKeybinding(secondChord, OS)
+            ]);
+        }
+        return new Keybinding([createSimpleKeybinding(firstChord, OS)]);
+    }
+    else {
+        const chords = [];
+        for (let i = 0; i < keybinding.length; i++) {
+            chords.push(createSimpleKeybinding(keybinding[i], OS));
+        }
+        return new Keybinding(chords);
+    }
+}
+export function createSimpleKeybinding(keybinding, OS) {
+    const ctrlCmd = (keybinding & 2048 /* BinaryKeybindingsMask.CtrlCmd */ ? true : false);
+    const winCtrl = (keybinding & 256 /* BinaryKeybindingsMask.WinCtrl */ ? true : false);
+    const ctrlKey = (OS === 2 /* OperatingSystem.Macintosh */ ? winCtrl : ctrlCmd);
+    const shiftKey = (keybinding & 1024 /* BinaryKeybindingsMask.Shift */ ? true : false);
+    const altKey = (keybinding & 512 /* BinaryKeybindingsMask.Alt */ ? true : false);
+    const metaKey = (OS === 2 /* OperatingSystem.Macintosh */ ? ctrlCmd : winCtrl);
+    const keyCode = (keybinding & 255 /* BinaryKeybindingsMask.KeyCode */);
+    return new KeyCodeChord(ctrlKey, shiftKey, altKey, metaKey, keyCode);
+}
+/**
+ * Represents a chord which uses the `keyCode` field of keyboard events.
+ * A chord is a combination of keys pressed simultaneously.
+ */
+export class KeyCodeChord {
+    constructor(ctrlKey, shiftKey, altKey, metaKey, keyCode) {
+        this.ctrlKey = ctrlKey;
+        this.shiftKey = shiftKey;
+        this.altKey = altKey;
+        this.metaKey = metaKey;
+        this.keyCode = keyCode;
+    }
+    equals(other) {
+        return (other instanceof KeyCodeChord
+            && this.ctrlKey === other.ctrlKey
+            && this.shiftKey === other.shiftKey
+            && this.altKey === other.altKey
+            && this.metaKey === other.metaKey
+            && this.keyCode === other.keyCode);
+    }
+    isModifierKey() {
+        return (this.keyCode === 0 /* KeyCode.Unknown */
+            || this.keyCode === 5 /* KeyCode.Ctrl */
+            || this.keyCode === 57 /* KeyCode.Meta */
+            || this.keyCode === 6 /* KeyCode.Alt */
+            || this.keyCode === 4 /* KeyCode.Shift */);
+    }
+    /**
+     * Does this keybinding refer to the key code of a modifier and it also has the modifier flag?
+     */
+    isDuplicateModifierCase() {
+        return ((this.ctrlKey && this.keyCode === 5 /* KeyCode.Ctrl */)
+            || (this.shiftKey && this.keyCode === 4 /* KeyCode.Shift */)
+            || (this.altKey && this.keyCode === 6 /* KeyCode.Alt */)
+            || (this.metaKey && this.keyCode === 57 /* KeyCode.Meta */));
+    }
+}
+/**
+ * Represents a chord which uses the `code` field of keyboard events.
+ * A chord is a combination of keys pressed simultaneously.
+ */
+export class ScanCodeChord {
+    constructor(ctrlKey, shiftKey, altKey, metaKey, scanCode) {
+        this.ctrlKey = ctrlKey;
+        this.shiftKey = shiftKey;
+        this.altKey = altKey;
+        this.metaKey = metaKey;
+        this.scanCode = scanCode;
+    }
+    /**
+     * Does this keybinding refer to the key code of a modifier and it also has the modifier flag?
+     */
+    isDuplicateModifierCase() {
+        return ((this.ctrlKey && (this.scanCode === 157 /* ScanCode.ControlLeft */ || this.scanCode === 161 /* ScanCode.ControlRight */))
+            || (this.shiftKey && (this.scanCode === 158 /* ScanCode.ShiftLeft */ || this.scanCode === 162 /* ScanCode.ShiftRight */))
+            || (this.altKey && (this.scanCode === 159 /* ScanCode.AltLeft */ || this.scanCode === 163 /* ScanCode.AltRight */))
+            || (this.metaKey && (this.scanCode === 160 /* ScanCode.MetaLeft */ || this.scanCode === 164 /* ScanCode.MetaRight */)));
+    }
+}
+/**
+ * A keybinding is a sequence of chords.
+ */
+export class Keybinding {
+    constructor(chords) {
+        if (chords.length === 0) {
+            throw illegalArgument(`chords`);
+        }
+        this.chords = chords;
+    }
+}
+export class ResolvedChord {
+    constructor(ctrlKey, shiftKey, altKey, metaKey, keyLabel, keyAriaLabel) {
+        this.ctrlKey = ctrlKey;
+        this.shiftKey = shiftKey;
+        this.altKey = altKey;
+        this.metaKey = metaKey;
+        this.keyLabel = keyLabel;
+        this.keyAriaLabel = keyAriaLabel;
+    }
+}
+/**
+ * A resolved keybinding. Consists of one or multiple chords.
+ */
+export class ResolvedKeybinding {
+}

package/dist-cms/monaco-editor/vs/base/common/labels.js

@@ -0,0 +1,9 @@
+import { hasDriveLetter } from './extpath.js';
+import { isWindows } from './platform.js';
+export function normalizeDriveLetter(path, isWindowsOS = isWindows) {
+    if (hasDriveLetter(path, isWindowsOS)) {
+        return path.charAt(0).toUpperCase() + path.slice(1);
+    }
+    return path;
+}
+let normalizedUserHomeCached = Object.create(null);

package/dist-cms/monaco-editor/vs/base/common/lazy.js

@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export class Lazy {
+    constructor(executor) {
+        this.executor = executor;
+        this._didRun = false;
+    }
+    /**
+     * Get the wrapped value.
+     *
+     * This will force evaluation of the lazy value if it has not been resolved yet. Lazy values are only
+     * resolved once. `getValue` will re-throw exceptions that are hit while resolving the value
+     */
+    get value() {
+        if (!this._didRun) {
+            try {
+                this._value = this.executor();
+            }
+            catch (err) {
+                this._error = err;
+            }
+            finally {
+                this._didRun = true;
+            }
+        }
+        if (this._error) {
+            throw this._error;
+        }
+        return this._value;
+    }
+    /**
+     * Get the wrapped value without forcing evaluation.
+     */
+    get rawValue() { return this._value; }
+}

package/dist-cms/monaco-editor/vs/base/common/lifecycle.js

@@ -0,0 +1,355 @@
+import { createSingleCallFunction } from './functional.js';
+import { Iterable } from './iterator.js';
+// #region Disposable Tracking
+/**
+ * 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;
+let disposableTracker = null;
+export function setDisposableTracker(tracker) {
+    disposableTracker = tracker;
+}
+if (TRACK_DISPOSABLES) {
+    const __is_disposable_tracked__ = '__is_disposable_tracked__';
+    setDisposableTracker(new class {
+        trackDisposable(x) {
+            const stack = new Error('Potentially leaked disposable').stack;
+            setTimeout(() => {
+                if (!x[__is_disposable_tracked__]) {
+                    console.log(stack);
+                }
+            }, 3000);
+        }
+        setParent(child, parent) {
+            if (child && child !== Disposable.None) {
+                try {
+                    child[__is_disposable_tracked__] = true;
+                }
+                catch {
+                    // noop
+                }
+            }
+        }
+        markAsDisposed(disposable) {
+            if (disposable && disposable !== Disposable.None) {
+                try {
+                    disposable[__is_disposable_tracked__] = true;
+                }
+                catch {
+                    // noop
+                }
+            }
+        }
+        markAsSingleton(disposable) { }
+    });
+}
+export function trackDisposable(x) {
+    disposableTracker?.trackDisposable(x);
+    return x;
+}
+export function markAsDisposed(disposable) {
+    disposableTracker?.markAsDisposed(disposable);
+}
+function setParentOfDisposable(child, parent) {
+    disposableTracker?.setParent(child, parent);
+}
+function setParentOfDisposables(children, parent) {
+    if (!disposableTracker) {
+        return;
+    }
+    for (const child of children) {
+        disposableTracker.setParent(child, parent);
+    }
+}
+/**
+ * Indicates that the given object is a singleton which does not need to be disposed.
+*/
+export function markAsSingleton(singleton) {
+    disposableTracker?.markAsSingleton(singleton);
+    return singleton;
+}
+/**
+ * Check if `thing` is {@link IDisposable disposable}.
+ */
+export function isDisposable(thing) {
+    return typeof thing === 'object' && thing !== null && typeof thing.dispose === 'function' && thing.dispose.length === 0;
+}
+export function dispose(arg) {
+    if (Iterable.is(arg)) {
+        const errors = [];
+        for (const d of arg) {
+            if (d) {
+                try {
+                    d.dispose();
+                }
+                catch (e) {
+                    errors.push(e);
+                }
+            }
+        }
+        if (errors.length === 1) {
+            throw errors[0];
+        }
+        else if (errors.length > 1) {
+            throw new AggregateError(errors, 'Encountered errors while disposing of store');
+        }
+        return Array.isArray(arg) ? [] : arg;
+    }
+    else if (arg) {
+        arg.dispose();
+        return arg;
+    }
+}
+/**
+ * Combine multiple disposable values into a single {@link IDisposable}.
+ */
+export function combinedDisposable(...disposables) {
+    const parent = toDisposable(() => dispose(disposables));
+    setParentOfDisposables(disposables, parent);
+    return parent;
+}
+/**
+ * Turn a function that implements dispose into an {@link IDisposable}.
+ *
+ * @param fn Clean up function, guaranteed to be called only **once**.
+ */
+export function toDisposable(fn) {
+    const self = trackDisposable({
+        dispose: createSingleCallFunction(() => {
+            markAsDisposed(self);
+            fn();
+        })
+    });
+    return self;
+}
+/**
+ * Manages a collection of disposable values.
+ *
+ * This is the preferred way to manage multiple disposables. A `DisposableStore` is safer to work with than an
+ * `IDisposable[]` as it considers edge cases, such as registering the same value multiple times or adding an item to a
+ * store that has already been disposed of.
+ */
+export class DisposableStore {
+    static { this.DISABLE_DISPOSED_WARNING = false; }
+    constructor() {
+        this._toDispose = new Set();
+        this._isDisposed = false;
+        trackDisposable(this);
+    }
+    /**
+     * 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;
+        }
+        markAsDisposed(this);
+        this._isDisposed = true;
+        this.clear();
+    }
+    /**
+     * @return `true` if this object has been disposed of.
+     */
+    get isDisposed() {
+        return this._isDisposed;
+    }
+    /**
+     * Dispose of all registered disposables but do not mark this object as disposed.
+     */
+    clear() {
+        if (this._toDispose.size === 0) {
+            return;
+        }
+        try {
+            dispose(this._toDispose);
+        }
+        finally {
+            this._toDispose.clear();
+        }
+    }
+    /**
+     * Add a new {@link IDisposable disposable} to the collection.
+     */
+    add(o) {
+        if (!o) {
+            return o;
+        }
+        if (o === this) {
+            throw new Error('Cannot register a disposable on itself!');
+        }
+        setParentOfDisposable(o, this);
+        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(o);
+        }
+        return o;
+    }
+    /**
+     * Deletes the value from the store, but does not dispose it.
+     */
+    deleteAndLeak(o) {
+        if (!o) {
+            return;
+        }
+        if (this._toDispose.has(o)) {
+            this._toDispose.delete(o);
+            setParentOfDisposable(o, null);
+        }
+    }
+}
+/**
+ * Abstract base class for a {@link IDisposable disposable} object.
+ *
+ * Subclasses can {@linkcode _register} disposables that will be automatically cleaned up when this object is disposed of.
+ */
+export class Disposable {
+    /**
+     * A disposable that does nothing when it is disposed of.
+     *
+     * TODO: This should not be a static property.
+     */
+    static { this.None = Object.freeze({ dispose() { } }); }
+    constructor() {
+        this._store = new DisposableStore();
+        trackDisposable(this);
+        setParentOfDisposable(this._store, this);
+    }
+    dispose() {
+        markAsDisposed(this);
+        this._store.dispose();
+    }
+    /**
+     * Adds `o` to the collection of disposables managed by this object.
+     */
+    _register(o) {
+        if (o === this) {
+            throw new Error('Cannot register a disposable on itself!');
+        }
+        return this._store.add(o);
+    }
+}
+/**
+ * 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 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;
+        }
+        this._value?.dispose();
+        if (value) {
+            setParentOfDisposable(value, this);
+        }
+        this._value = value;
+    }
+    /**
+     * Resets the stored value and disposed of the previously stored value.
+     */
+    clear() {
+        this.value = undefined;
+    }
+    dispose() {
+        this._isDisposed = true;
+        markAsDisposed(this);
+        this._value?.dispose();
+        this._value = undefined;
+    }
+}
+export class RefCountedDisposable {
+    constructor(_disposable) {
+        this._disposable = _disposable;
+        this._counter = 1;
+    }
+    acquire() {
+        this._counter++;
+        return this;
+    }
+    release() {
+        if (--this._counter === 0) {
+            this._disposable.dispose();
+        }
+        return this;
+    }
+}
+export class ImmortalReference {
+    constructor(object) {
+        this.object = object;
+    }
+    dispose() { }
+}
+/**
+ * A map the manages the lifecycle of the values that it stores.
+ */
+export class DisposableMap {
+    constructor() {
+        this._store = new Map();
+        this._isDisposed = false;
+        trackDisposable(this);
+    }
+    /**
+     * 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() {
+        markAsDisposed(this);
+        this._isDisposed = true;
+        this.clearAndDisposeAll();
+    }
+    /**
+     * Disposes of all stored values and clear the map, but DO NOT mark this object as disposed.
+     */
+    clearAndDisposeAll() {
+        if (!this._store.size) {
+            return;
+        }
+        try {
+            dispose(this._store.values());
+        }
+        finally {
+            this._store.clear();
+        }
+    }
+    get(key) {
+        return this._store.get(key);
+    }
+    set(key, value, skipDisposeOnOverwrite = false) {
+        if (this._isDisposed) {
+            console.warn(new Error('Trying to add a disposable to a DisposableMap that has already been disposed of. The added object will be leaked!').stack);
+        }
+        if (!skipDisposeOnOverwrite) {
+            this._store.get(key)?.dispose();
+        }
+        this._store.set(key, value);
+    }
+    /**
+     * Delete the value stored for `key` from this map and also dispose of it.
+     */
+    deleteAndDispose(key) {
+        this._store.get(key)?.dispose();
+        this._store.delete(key);
+    }
+    [Symbol.iterator]() {
+        return this._store[Symbol.iterator]();
+    }
+}

package/dist-cms/monaco-editor/vs/base/common/linkedList.js

@@ -0,0 +1,124 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class Node {
+    static { this.Undefined = new Node(undefined); }
+    constructor(element) {
+        this.element = element;
+        this.next = Node.Undefined;
+        this.prev = Node.Undefined;
+    }
+}
+export 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() {
+        let node = this._first;
+        while (node !== Node.Undefined) {
+            const next = node.next;
+            node.prev = Node.Undefined;
+            node.next = Node.Undefined;
+            node = next;
+        }
+        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;
+        }
+    }
+}

package/dist-cms/monaco-editor/vs/base/common/linkedText.js

@@ -0,0 +1,45 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { memoize } from './decorators.js';
+export class LinkedText {
+    constructor(nodes) {
+        this.nodes = nodes;
+    }
+    toString() {
+        return this.nodes.map(node => typeof node === 'string' ? node : node.label).join('');
+    }
+}
+__decorate([
+    memoize
+], LinkedText.prototype, "toString", null);
+const LINK_REGEX = /\[([^\]]+)\]\(((?:https?:\/\/|command:|file:)[^\)\s]+)(?: (["'])(.+?)(\3))?\)/gi;
+export function parseLinkedText(text) {
+    const result = [];
+    let index = 0;
+    let match;
+    while (match = LINK_REGEX.exec(text)) {
+        if (match.index - index > 0) {
+            result.push(text.substring(index, match.index));
+        }
+        const [, label, href, , title] = match;
+        if (title) {
+            result.push({ label, href, title });
+        }
+        else {
+            result.push({ label, href });
+        }
+        index = match.index + match[0].length;
+    }
+    if (index < text.length) {
+        result.push(text.substring(index));
+    }
+    return new LinkedText(result);
+}