@umbraco-cms/backoffice 15.3.0 → 15.4.0-rc

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

@@ -0,0 +1,258 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as strings from './strings.js';
+/**
+ * Return a hash value for an object.
+ */
+export function hash(obj) {
+    return doHash(obj, 0);
+}
+export function doHash(obj, hashVal) {
+    switch (typeof obj) {
+        case 'object':
+            if (obj === null) {
+                return numberHash(349, hashVal);
+            }
+            else if (Array.isArray(obj)) {
+                return arrayHash(obj, hashVal);
+            }
+            return objectHash(obj, hashVal);
+        case 'string':
+            return stringHash(obj, hashVal);
+        case 'boolean':
+            return booleanHash(obj, hashVal);
+        case 'number':
+            return numberHash(obj, hashVal);
+        case 'undefined':
+            return numberHash(937, hashVal);
+        default:
+            return numberHash(617, hashVal);
+    }
+}
+export function numberHash(val, initialHashVal) {
+    return (((initialHashVal << 5) - initialHashVal) + val) | 0; // hashVal * 31 + ch, keep as int32
+}
+function booleanHash(b, initialHashVal) {
+    return numberHash(b ? 433 : 863, initialHashVal);
+}
+export function stringHash(s, hashVal) {
+    hashVal = numberHash(149417, hashVal);
+    for (let i = 0, length = s.length; i < length; i++) {
+        hashVal = numberHash(s.charCodeAt(i), hashVal);
+    }
+    return hashVal;
+}
+function arrayHash(arr, initialHashVal) {
+    initialHashVal = numberHash(104579, initialHashVal);
+    return arr.reduce((hashVal, item) => doHash(item, hashVal), initialHashVal);
+}
+function objectHash(obj, initialHashVal) {
+    initialHashVal = numberHash(181387, initialHashVal);
+    return Object.keys(obj).sort().reduce((hashVal, key) => {
+        hashVal = stringHash(key, hashVal);
+        return doHash(obj[key], hashVal);
+    }, initialHashVal);
+}
+function leftRotate(value, bits, totalBits = 32) {
+    // delta + bits = totalBits
+    const delta = totalBits - bits;
+    // All ones, expect `delta` zeros aligned to the right
+    const mask = ~((1 << delta) - 1);
+    // Join (value left-shifted `bits` bits) with (masked value right-shifted `delta` bits)
+    return ((value << bits) | ((mask & value) >>> delta)) >>> 0;
+}
+function fill(dest, index = 0, count = dest.byteLength, value = 0) {
+    for (let i = 0; i < count; i++) {
+        dest[index + i] = value;
+    }
+}
+function leftPad(value, length, char = '0') {
+    while (value.length < length) {
+        value = char + value;
+    }
+    return value;
+}
+export function toHexString(bufferOrValue, bitsize = 32) {
+    if (bufferOrValue instanceof ArrayBuffer) {
+        return Array.from(new Uint8Array(bufferOrValue)).map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+    return leftPad((bufferOrValue >>> 0).toString(16), bitsize / 4);
+}
+/**
+ * A SHA1 implementation that works with strings and does not allocate.
+ */
+export class StringSHA1 {
+    static { this._bigBlock32 = new DataView(new ArrayBuffer(320)); } // 80 * 4 = 320
+    constructor() {
+        this._h0 = 0x67452301;
+        this._h1 = 0xEFCDAB89;
+        this._h2 = 0x98BADCFE;
+        this._h3 = 0x10325476;
+        this._h4 = 0xC3D2E1F0;
+        this._buff = new Uint8Array(64 /* SHA1Constant.BLOCK_SIZE */ + 3 /* to fit any utf-8 */);
+        this._buffDV = new DataView(this._buff.buffer);
+        this._buffLen = 0;
+        this._totalLen = 0;
+        this._leftoverHighSurrogate = 0;
+        this._finished = false;
+    }
+    update(str) {
+        const strLen = str.length;
+        if (strLen === 0) {
+            return;
+        }
+        const buff = this._buff;
+        let buffLen = this._buffLen;
+        let leftoverHighSurrogate = this._leftoverHighSurrogate;
+        let charCode;
+        let offset;
+        if (leftoverHighSurrogate !== 0) {
+            charCode = leftoverHighSurrogate;
+            offset = -1;
+            leftoverHighSurrogate = 0;
+        }
+        else {
+            charCode = str.charCodeAt(0);
+            offset = 0;
+        }
+        while (true) {
+            let codePoint = charCode;
+            if (strings.isHighSurrogate(charCode)) {
+                if (offset + 1 < strLen) {
+                    const nextCharCode = str.charCodeAt(offset + 1);
+                    if (strings.isLowSurrogate(nextCharCode)) {
+                        offset++;
+                        codePoint = strings.computeCodePoint(charCode, nextCharCode);
+                    }
+                    else {
+                        // illegal => unicode replacement character
+                        codePoint = 65533 /* SHA1Constant.UNICODE_REPLACEMENT */;
+                    }
+                }
+                else {
+                    // last character is a surrogate pair
+                    leftoverHighSurrogate = charCode;
+                    break;
+                }
+            }
+            else if (strings.isLowSurrogate(charCode)) {
+                // illegal => unicode replacement character
+                codePoint = 65533 /* SHA1Constant.UNICODE_REPLACEMENT */;
+            }
+            buffLen = this._push(buff, buffLen, codePoint);
+            offset++;
+            if (offset < strLen) {
+                charCode = str.charCodeAt(offset);
+            }
+            else {
+                break;
+            }
+        }
+        this._buffLen = buffLen;
+        this._leftoverHighSurrogate = leftoverHighSurrogate;
+    }
+    _push(buff, buffLen, codePoint) {
+        if (codePoint < 0x0080) {
+            buff[buffLen++] = codePoint;
+        }
+        else if (codePoint < 0x0800) {
+            buff[buffLen++] = 0b11000000 | ((codePoint & 0b00000000000000000000011111000000) >>> 6);
+            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);
+        }
+        else if (codePoint < 0x10000) {
+            buff[buffLen++] = 0b11100000 | ((codePoint & 0b00000000000000001111000000000000) >>> 12);
+            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);
+            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);
+        }
+        else {
+            buff[buffLen++] = 0b11110000 | ((codePoint & 0b00000000000111000000000000000000) >>> 18);
+            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000111111000000000000) >>> 12);
+            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);
+            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);
+        }
+        if (buffLen >= 64 /* SHA1Constant.BLOCK_SIZE */) {
+            this._step();
+            buffLen -= 64 /* SHA1Constant.BLOCK_SIZE */;
+            this._totalLen += 64 /* SHA1Constant.BLOCK_SIZE */;
+            // take last 3 in case of UTF8 overflow
+            buff[0] = buff[64 /* SHA1Constant.BLOCK_SIZE */ + 0];
+            buff[1] = buff[64 /* SHA1Constant.BLOCK_SIZE */ + 1];
+            buff[2] = buff[64 /* SHA1Constant.BLOCK_SIZE */ + 2];
+        }
+        return buffLen;
+    }
+    digest() {
+        if (!this._finished) {
+            this._finished = true;
+            if (this._leftoverHighSurrogate) {
+                // illegal => unicode replacement character
+                this._leftoverHighSurrogate = 0;
+                this._buffLen = this._push(this._buff, this._buffLen, 65533 /* SHA1Constant.UNICODE_REPLACEMENT */);
+            }
+            this._totalLen += this._buffLen;
+            this._wrapUp();
+        }
+        return toHexString(this._h0) + toHexString(this._h1) + toHexString(this._h2) + toHexString(this._h3) + toHexString(this._h4);
+    }
+    _wrapUp() {
+        this._buff[this._buffLen++] = 0x80;
+        fill(this._buff, this._buffLen);
+        if (this._buffLen > 56) {
+            this._step();
+            fill(this._buff);
+        }
+        // this will fit because the mantissa can cover up to 52 bits
+        const ml = 8 * this._totalLen;
+        this._buffDV.setUint32(56, Math.floor(ml / 4294967296), false);
+        this._buffDV.setUint32(60, ml % 4294967296, false);
+        this._step();
+    }
+    _step() {
+        const bigBlock32 = StringSHA1._bigBlock32;
+        const data = this._buffDV;
+        for (let j = 0; j < 64 /* 16*4 */; j += 4) {
+            bigBlock32.setUint32(j, data.getUint32(j, false), false);
+        }
+        for (let j = 64; j < 320 /* 80*4 */; j += 4) {
+            bigBlock32.setUint32(j, leftRotate((bigBlock32.getUint32(j - 12, false) ^ bigBlock32.getUint32(j - 32, false) ^ bigBlock32.getUint32(j - 56, false) ^ bigBlock32.getUint32(j - 64, false)), 1), false);
+        }
+        let a = this._h0;
+        let b = this._h1;
+        let c = this._h2;
+        let d = this._h3;
+        let e = this._h4;
+        let f, k;
+        let temp;
+        for (let j = 0; j < 80; j++) {
+            if (j < 20) {
+                f = (b & c) | ((~b) & d);
+                k = 0x5A827999;
+            }
+            else if (j < 40) {
+                f = b ^ c ^ d;
+                k = 0x6ED9EBA1;
+            }
+            else if (j < 60) {
+                f = (b & c) | (b & d) | (c & d);
+                k = 0x8F1BBCDC;
+            }
+            else {
+                f = b ^ c ^ d;
+                k = 0xCA62C1D6;
+            }
+            temp = (leftRotate(a, 5) + f + e + k + bigBlock32.getUint32(j * 4, false)) & 0xffffffff;
+            e = d;
+            d = c;
+            c = leftRotate(b, 30);
+            b = a;
+            a = temp;
+        }
+        this._h0 = (this._h0 + a) & 0xffffffff;
+        this._h1 = (this._h1 + b) & 0xffffffff;
+        this._h2 = (this._h2 + c) & 0xffffffff;
+        this._h3 = (this._h3 + d) & 0xffffffff;
+        this._h4 = (this._h4 + e) & 0xffffffff;
+    }
+}

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

@@ -0,0 +1,24 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export class HierarchicalKind {
+    static { this.sep = '.'; }
+    static { this.None = new HierarchicalKind('@@none@@'); } // Special kind that matches nothing
+    static { this.Empty = new HierarchicalKind(''); }
+    constructor(value) {
+        this.value = value;
+    }
+    equals(other) {
+        return this.value === other.value;
+    }
+    contains(other) {
+        return this.equals(other) || this.value === '' || other.value.startsWith(this.value + HierarchicalKind.sep);
+    }
+    intersects(other) {
+        return this.contains(other) || other.contains(this);
+    }
+    append(...parts) {
+        return new HierarchicalKind((this.value ? [this.value, ...parts] : parts).join(HierarchicalKind.sep));
+    }
+}

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

@@ -0,0 +1,73 @@
+import { ArrayNavigator } from './navigator.js';
+export class HistoryNavigator {
+    constructor(history = [], limit = 10) {
+        this._initialize(history);
+        this._limit = limit;
+        this._onChange();
+    }
+    getHistory() {
+        return this._elements;
+    }
+    add(t) {
+        this._history.delete(t);
+        this._history.add(t);
+        this._onChange();
+    }
+    next() {
+        // This will navigate past the end of the last element, and in that case the input should be cleared
+        return this._navigator.next();
+    }
+    previous() {
+        if (this._currentPosition() !== 0) {
+            return this._navigator.previous();
+        }
+        return null;
+    }
+    current() {
+        return this._navigator.current();
+    }
+    first() {
+        return this._navigator.first();
+    }
+    last() {
+        return this._navigator.last();
+    }
+    isLast() {
+        return this._currentPosition() >= this._elements.length - 1;
+    }
+    isNowhere() {
+        return this._navigator.current() === null;
+    }
+    has(t) {
+        return this._history.has(t);
+    }
+    _onChange() {
+        this._reduceToLimit();
+        const elements = this._elements;
+        this._navigator = new ArrayNavigator(elements, 0, elements.length, elements.length);
+    }
+    _reduceToLimit() {
+        const data = this._elements;
+        if (data.length > this._limit) {
+            this._initialize(data.slice(data.length - this._limit));
+        }
+    }
+    _currentPosition() {
+        const currentElement = this._navigator.current();
+        if (!currentElement) {
+            return -1;
+        }
+        return this._elements.indexOf(currentElement);
+    }
+    _initialize(history) {
+        this._history = new Set();
+        for (const entry of history) {
+            this._history.add(entry);
+        }
+    }
+    get _elements() {
+        const elements = [];
+        this._history.forEach(e => elements.push(e));
+        return elements;
+    }
+}

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

@@ -0,0 +1,81 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { env } from './process.js';
+export function isHotReloadEnabled() {
+    return env && !!env['VSCODE_DEV'];
+}
+export function registerHotReloadHandler(handler) {
+    if (!isHotReloadEnabled()) {
+        return { dispose() { } };
+    }
+    else {
+        const handlers = registerGlobalHotReloadHandler();
+        handlers.add(handler);
+        return {
+            dispose() { handlers.delete(handler); }
+        };
+    }
+}
+function registerGlobalHotReloadHandler() {
+    if (!hotReloadHandlers) {
+        hotReloadHandlers = new Set();
+    }
+    const g = globalThis;
+    if (!g.$hotReload_applyNewExports) {
+        g.$hotReload_applyNewExports = args => {
+            const args2 = { config: { mode: undefined }, ...args };
+            const results = [];
+            for (const h of hotReloadHandlers) {
+                const result = h(args2);
+                if (result) {
+                    results.push(result);
+                }
+            }
+            if (results.length > 0) {
+                return newExports => {
+                    let result = false;
+                    for (const r of results) {
+                        if (r(newExports)) {
+                            result = true;
+                        }
+                    }
+                    return result;
+                };
+            }
+            return undefined;
+        };
+    }
+    return hotReloadHandlers;
+}
+let hotReloadHandlers = undefined;
+if (isHotReloadEnabled()) {
+    // This code does not run in production.
+    registerHotReloadHandler(({ oldExports, newSrc, config }) => {
+        if (config.mode !== 'patch-prototype') {
+            return undefined;
+        }
+        return newExports => {
+            for (const key in newExports) {
+                const exportedItem = newExports[key];
+                console.log(`[hot-reload] Patching prototype methods of '${key}'`, { exportedItem });
+                if (typeof exportedItem === 'function' && exportedItem.prototype) {
+                    const oldExportedItem = oldExports[key];
+                    if (oldExportedItem) {
+                        for (const prop of Object.getOwnPropertyNames(exportedItem.prototype)) {
+                            const descriptor = Object.getOwnPropertyDescriptor(exportedItem.prototype, prop);
+                            const oldDescriptor = Object.getOwnPropertyDescriptor(oldExportedItem.prototype, prop);
+                            if (descriptor?.value?.toString() !== oldDescriptor?.value?.toString()) {
+                                console.log(`[hot-reload] Patching prototype method '${key}.${prop}'`);
+                            }
+                            Object.defineProperty(oldExportedItem.prototype, prop, descriptor);
+                        }
+                        newExports[key] = oldExportedItem;
+                    }
+                }
+            }
+            return true;
+        };
+    });
+}

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

@@ -0,0 +1,24 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { isHotReloadEnabled, registerHotReloadHandler } from './hotReload.js';
+import { observableSignalFromEvent } from './observable.js';
+export function readHotReloadableExport(value, reader) {
+    observeHotReloadableExports([value], reader);
+    return value;
+}
+export function observeHotReloadableExports(values, reader) {
+    if (isHotReloadEnabled()) {
+        const o = observableSignalFromEvent('reload', event => registerHotReloadHandler(({ oldExports }) => {
+            if (![...Object.values(oldExports)].some(v => values.includes(v))) {
+                return undefined;
+            }
+            return (_newExports) => {
+                event(undefined);
+                return true;
+            };
+        }));
+        o.read(reader);
+    }
+}

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

@@ -0,0 +1,149 @@
+/*---------------------------------------------------------------------------------------------
+ *  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';
+import { escapeIcons } from './iconLabels.js';
+import { isEqual } from './resources.js';
+import { escapeRegExpCharacters } from './strings.js';
+import { URI } from './uri.js';
+export class MarkdownString {
+    constructor(value = '', isTrustedOrOptions = false) {
+        this.value = value;
+        if (typeof this.value !== 'string') {
+            throw illegalArgument('value');
+        }
+        if (typeof isTrustedOrOptions === 'boolean') {
+            this.isTrusted = isTrustedOrOptions;
+            this.supportThemeIcons = false;
+            this.supportHtml = false;
+        }
+        else {
+            this.isTrusted = isTrustedOrOptions.isTrusted ?? undefined;
+            this.supportThemeIcons = isTrustedOrOptions.supportThemeIcons ?? false;
+            this.supportHtml = isTrustedOrOptions.supportHtml ?? false;
+        }
+    }
+    appendText(value, newlineStyle = 0 /* MarkdownStringTextNewlineStyle.Paragraph */) {
+        this.value += escapeMarkdownSyntaxTokens(this.supportThemeIcons ? escapeIcons(value) : value) // CodeQL [SM02383] The Markdown is fully sanitized after being rendered.
+            .replace(/([ \t]+)/g, (_match, g1) => ' '.repeat(g1.length)) // CodeQL [SM02383] The Markdown is fully sanitized after being rendered.
+            .replace(/\>/gm, '\\>') // CodeQL [SM02383] The Markdown is fully sanitized after being rendered.
+            .replace(/\n/g, newlineStyle === 1 /* MarkdownStringTextNewlineStyle.Break */ ? '\\\n' : '\n\n'); // CodeQL [SM02383] The Markdown is fully sanitized after being rendered.
+        return this;
+    }
+    appendMarkdown(value) {
+        this.value += value;
+        return this;
+    }
+    appendCodeblock(langId, code) {
+        this.value += `\n${appendEscapedMarkdownCodeBlockFence(code, langId)}\n`;
+        return this;
+    }
+    appendLink(target, label, title) {
+        this.value += '[';
+        this.value += this._escape(label, ']');
+        this.value += '](';
+        this.value += this._escape(String(target), ')');
+        if (title) {
+            this.value += ` "${this._escape(this._escape(title, '"'), ')')}"`;
+        }
+        this.value += ')';
+        return this;
+    }
+    _escape(value, ch) {
+        const r = new RegExp(escapeRegExpCharacters(ch), 'g');
+        return value.replace(r, (match, offset) => {
+            if (value.charAt(offset - 1) !== '\\') {
+                return `\\${match}`;
+            }
+            else {
+                return match;
+            }
+        });
+    }
+}
+export function isEmptyMarkdownString(oneOrMany) {
+    if (isMarkdownString(oneOrMany)) {
+        return !oneOrMany.value;
+    }
+    else if (Array.isArray(oneOrMany)) {
+        return oneOrMany.every(isEmptyMarkdownString);
+    }
+    else {
+        return true;
+    }
+}
+export function isMarkdownString(thing) {
+    if (thing instanceof MarkdownString) {
+        return true;
+    }
+    else if (thing && typeof thing === 'object') {
+        return typeof thing.value === 'string'
+            && (typeof thing.isTrusted === 'boolean' || typeof thing.isTrusted === 'object' || thing.isTrusted === undefined)
+            && (typeof thing.supportThemeIcons === 'boolean' || thing.supportThemeIcons === undefined);
+    }
+    return false;
+}
+export function markdownStringEqual(a, b) {
+    if (a === b) {
+        return true;
+    }
+    else if (!a || !b) {
+        return false;
+    }
+    else {
+        return a.value === b.value
+            && a.isTrusted === b.isTrusted
+            && a.supportThemeIcons === b.supportThemeIcons
+            && a.supportHtml === b.supportHtml
+            && (a.baseUri === b.baseUri || !!a.baseUri && !!b.baseUri && isEqual(URI.from(a.baseUri), URI.from(b.baseUri)));
+    }
+}
+export function escapeMarkdownSyntaxTokens(text) {
+    // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash
+    return text.replace(/[\\`*_{}[\]()#+\-!~]/g, '\\$&'); // CodeQL [SM02383] Backslash is escaped in the character class
+}
+/**
+ * @see https://github.com/microsoft/vscode/issues/193746
+ */
+export function appendEscapedMarkdownCodeBlockFence(code, langId) {
+    const longestFenceLength = code.match(/^`+/gm)?.reduce((a, b) => (a.length > b.length ? a : b)).length ??
+        0;
+    const desiredFenceLength = longestFenceLength >= 3 ? longestFenceLength + 1 : 3;
+    // the markdown result
+    return [
+        `${'`'.repeat(desiredFenceLength)}${langId}`,
+        code,
+        `${'`'.repeat(desiredFenceLength)}`,
+    ].join('\n');
+}
+export function escapeDoubleQuotes(input) {
+    return input.replace(/"/g, '"');
+}
+export function removeMarkdownEscapes(text) {
+    if (!text) {
+        return text;
+    }
+    return text.replace(/\\([\\`*_{}[\]()#+\-.!~])/g, '$1');
+}
+export function parseHrefAndDimensions(href) {
+    const dimensions = [];
+    const splitted = href.split('|').map(s => s.trim());
+    href = splitted[0];
+    const parameters = splitted[1];
+    if (parameters) {
+        const heightFromParams = /height=(\d+)/.exec(parameters);
+        const widthFromParams = /width=(\d+)/.exec(parameters);
+        const height = heightFromParams ? heightFromParams[1] : '';
+        const width = widthFromParams ? widthFromParams[1] : '';
+        const widthIsFinite = isFinite(parseInt(width));
+        const heightIsFinite = isFinite(parseInt(height));
+        if (widthIsFinite) {
+            dimensions.push(`width="${width}"`);
+        }
+        if (heightIsFinite) {
+            dimensions.push(`height="${height}"`);
+        }
+    }
+    return { href, dimensions };
+}