@umbraco-cms/backoffice 15.3.1 → 15.4.0-rc2

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

@@ -0,0 +1,153 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as nls from '../../nls.js';
+export const LANGUAGE_DEFAULT = 'en';
+let _isWindows = false;
+let _isMacintosh = false;
+let _isLinux = false;
+let _isLinuxSnap = false;
+let _isNative = false;
+let _isWeb = false;
+let _isElectron = false;
+let _isIOS = false;
+let _isCI = false;
+let _isMobile = false;
+let _locale = undefined;
+let _language = LANGUAGE_DEFAULT;
+let _platformLocale = LANGUAGE_DEFAULT;
+let _translationsConfigFile = undefined;
+let _userAgent = undefined;
+const $globalThis = globalThis;
+let nodeProcess = undefined;
+if (typeof $globalThis.vscode !== 'undefined' && typeof $globalThis.vscode.process !== 'undefined') {
+    // Native environment (sandboxed)
+    nodeProcess = $globalThis.vscode.process;
+}
+else if (typeof process !== 'undefined' && typeof process?.versions?.node === 'string') {
+    // Native environment (non-sandboxed)
+    nodeProcess = process;
+}
+const isElectronProcess = typeof nodeProcess?.versions?.electron === 'string';
+const isElectronRenderer = isElectronProcess && nodeProcess?.type === 'renderer';
+// Native environment
+if (typeof nodeProcess === 'object') {
+    _isWindows = (nodeProcess.platform === 'win32');
+    _isMacintosh = (nodeProcess.platform === 'darwin');
+    _isLinux = (nodeProcess.platform === 'linux');
+    _isLinuxSnap = _isLinux && !!nodeProcess.env['SNAP'] && !!nodeProcess.env['SNAP_REVISION'];
+    _isElectron = isElectronProcess;
+    _isCI = !!nodeProcess.env['CI'] || !!nodeProcess.env['BUILD_ARTIFACTSTAGINGDIRECTORY'];
+    _locale = LANGUAGE_DEFAULT;
+    _language = LANGUAGE_DEFAULT;
+    const rawNlsConfig = nodeProcess.env['VSCODE_NLS_CONFIG'];
+    if (rawNlsConfig) {
+        try {
+            const nlsConfig = JSON.parse(rawNlsConfig);
+            _locale = nlsConfig.userLocale;
+            _platformLocale = nlsConfig.osLocale;
+            _language = nlsConfig.resolvedLanguage || LANGUAGE_DEFAULT;
+            _translationsConfigFile = nlsConfig.languagePack?.translationsConfigFile;
+        }
+        catch (e) {
+        }
+    }
+    _isNative = true;
+}
+// Web environment
+else if (typeof navigator === 'object' && !isElectronRenderer) {
+    _userAgent = navigator.userAgent;
+    _isWindows = _userAgent.indexOf('Windows') >= 0;
+    _isMacintosh = _userAgent.indexOf('Macintosh') >= 0;
+    _isIOS = (_userAgent.indexOf('Macintosh') >= 0 || _userAgent.indexOf('iPad') >= 0 || _userAgent.indexOf('iPhone') >= 0) && !!navigator.maxTouchPoints && navigator.maxTouchPoints > 0;
+    _isLinux = _userAgent.indexOf('Linux') >= 0;
+    _isMobile = _userAgent?.indexOf('Mobi') >= 0;
+    _isWeb = true;
+    _language = nls.getNLSLanguage() || LANGUAGE_DEFAULT;
+    _locale = navigator.language.toLowerCase();
+    _platformLocale = _locale;
+}
+// Unknown environment
+else {
+    console.error('Unable to resolve platform.');
+}
+let _platform = 0 /* Platform.Web */;
+if (_isMacintosh) {
+    _platform = 1 /* Platform.Mac */;
+}
+else if (_isWindows) {
+    _platform = 3 /* Platform.Windows */;
+}
+else if (_isLinux) {
+    _platform = 2 /* Platform.Linux */;
+}
+export const isWindows = _isWindows;
+export const isMacintosh = _isMacintosh;
+export const isLinux = _isLinux;
+export const isNative = _isNative;
+export const isWeb = _isWeb;
+export const isWebWorker = (_isWeb && typeof $globalThis.importScripts === 'function');
+export const webWorkerOrigin = isWebWorker ? $globalThis.origin : undefined;
+export const isIOS = _isIOS;
+export const isMobile = _isMobile;
+export const userAgent = _userAgent;
+/**
+ * The language used for the user interface. The format of
+ * the string is all lower case (e.g. zh-tw for Traditional
+ * Chinese or de for German)
+ */
+export const language = _language;
+export const setTimeout0IsFaster = (typeof $globalThis.postMessage === 'function' && !$globalThis.importScripts);
+/**
+ * See https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#:~:text=than%204%2C%20then-,set%20timeout%20to%204,-.
+ *
+ * Works similarly to `setTimeout(0)` but doesn't suffer from the 4ms artificial delay
+ * that browsers set when the nesting level is > 5.
+ */
+export const setTimeout0 = (() => {
+    if (setTimeout0IsFaster) {
+        const pending = [];
+        $globalThis.addEventListener('message', (e) => {
+            if (e.data && e.data.vscodeScheduleAsyncWork) {
+                for (let i = 0, len = pending.length; i < len; i++) {
+                    const candidate = pending[i];
+                    if (candidate.id === e.data.vscodeScheduleAsyncWork) {
+                        pending.splice(i, 1);
+                        candidate.callback();
+                        return;
+                    }
+                }
+            }
+        });
+        let lastId = 0;
+        return (callback) => {
+            const myId = ++lastId;
+            pending.push({
+                id: myId,
+                callback: callback
+            });
+            $globalThis.postMessage({ vscodeScheduleAsyncWork: myId }, '*');
+        };
+    }
+    return (callback) => setTimeout(callback);
+})();
+export const OS = (_isMacintosh || _isIOS ? 2 /* OperatingSystem.Macintosh */ : (_isWindows ? 1 /* OperatingSystem.Windows */ : 3 /* OperatingSystem.Linux */));
+let _isLittleEndian = true;
+let _isLittleEndianComputed = false;
+export function isLittleEndian() {
+    if (!_isLittleEndianComputed) {
+        _isLittleEndianComputed = true;
+        const test = new Uint8Array(2);
+        test[0] = 1;
+        test[1] = 2;
+        const view = new Uint16Array(test.buffer);
+        _isLittleEndian = (view[0] === (2 << 8) + 1);
+    }
+    return _isLittleEndian;
+}
+export const isChrome = !!(userAgent && userAgent.indexOf('Chrome') >= 0);
+export const isFirefox = !!(userAgent && userAgent.indexOf('Firefox') >= 0);
+export const isSafari = !!(!isChrome && (userAgent && userAgent.indexOf('Safari') >= 0));
+export const isEdge = !!(userAgent && userAgent.indexOf('Edg/') >= 0);
+export const isAndroid = !!(userAgent && userAgent.indexOf('Android') >= 0);

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

@@ -0,0 +1,58 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { isMacintosh, isWindows } from './platform.js';
+let safeProcess;
+// Native sandbox environment
+const vscodeGlobal = globalThis.vscode;
+if (typeof vscodeGlobal !== 'undefined' && typeof vscodeGlobal.process !== 'undefined') {
+    const sandboxProcess = vscodeGlobal.process;
+    safeProcess = {
+        get platform() { return sandboxProcess.platform; },
+        get arch() { return sandboxProcess.arch; },
+        get env() { return sandboxProcess.env; },
+        cwd() { return sandboxProcess.cwd(); }
+    };
+}
+// Native node.js environment
+else if (typeof process !== 'undefined' && typeof process?.versions?.node === 'string') {
+    safeProcess = {
+        get platform() { return process.platform; },
+        get arch() { return process.arch; },
+        get env() { return process.env; },
+        cwd() { return process.env['VSCODE_CWD'] || process.cwd(); }
+    };
+}
+// Web environment
+else {
+    safeProcess = {
+        // Supported
+        get platform() { return isWindows ? 'win32' : isMacintosh ? 'darwin' : 'linux'; },
+        get arch() { return undefined; /* arch is undefined in web */ },
+        // Unsupported
+        get env() { return {}; },
+        cwd() { return '/'; }
+    };
+}
+/**
+ * Provides safe access to the `cwd` property in node.js, sandboxed or web
+ * environments.
+ *
+ * Note: in web, this property is hardcoded to be `/`.
+ *
+ * @skipMangle
+ */
+export const cwd = safeProcess.cwd;
+/**
+ * Provides safe access to the `env` property in node.js, sandboxed or web
+ * environments.
+ *
+ * Note: in web, this property is hardcoded to be `{}`.
+ */
+export const env = safeProcess.env;
+/**
+ * Provides safe access to the `platform` property in node.js, sandboxed or web
+ * environments.
+ */
+export const platform = safeProcess.platform;

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

@@ -0,0 +1,44 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export var Range;
+(function (Range) {
+    /**
+     * Returns the intersection between two ranges as a range itself.
+     * Returns `{ start: 0, end: 0 }` if the intersection is empty.
+     */
+    function intersect(one, other) {
+        if (one.start >= other.end || other.start >= one.end) {
+            return { start: 0, end: 0 };
+        }
+        const start = Math.max(one.start, other.start);
+        const end = Math.min(one.end, other.end);
+        if (end - start <= 0) {
+            return { start: 0, end: 0 };
+        }
+        return { start, end };
+    }
+    Range.intersect = intersect;
+    function isEmpty(range) {
+        return range.end - range.start <= 0;
+    }
+    Range.isEmpty = isEmpty;
+    function intersects(one, other) {
+        return !isEmpty(intersect(one, other));
+    }
+    Range.intersects = intersects;
+    function relativeComplement(one, other) {
+        const result = [];
+        const first = { start: one.start, end: Math.min(other.start, one.end) };
+        const second = { start: Math.max(other.end, one.start), end: one.end };
+        if (!isEmpty(first)) {
+            result.push(first);
+        }
+        if (!isEmpty(second)) {
+            result.push(second);
+        }
+        return result;
+    }
+    Range.relativeComplement = relativeComplement;
+})(Range || (Range = {}));

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

@@ -0,0 +1,256 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as extpath from './extpath.js';
+import { Schemas } from './network.js';
+import * as paths from './path.js';
+import { isLinux, isWindows } from './platform.js';
+import { compare as strCompare, equalsIgnoreCase } from './strings.js';
+import { URI, uriToFsPath } from './uri.js';
+export function originalFSPath(uri) {
+    return uriToFsPath(uri, true);
+}
+export class ExtUri {
+    constructor(_ignorePathCasing) {
+        this._ignorePathCasing = _ignorePathCasing;
+    }
+    compare(uri1, uri2, ignoreFragment = false) {
+        if (uri1 === uri2) {
+            return 0;
+        }
+        return strCompare(this.getComparisonKey(uri1, ignoreFragment), this.getComparisonKey(uri2, ignoreFragment));
+    }
+    isEqual(uri1, uri2, ignoreFragment = false) {
+        if (uri1 === uri2) {
+            return true;
+        }
+        if (!uri1 || !uri2) {
+            return false;
+        }
+        return this.getComparisonKey(uri1, ignoreFragment) === this.getComparisonKey(uri2, ignoreFragment);
+    }
+    getComparisonKey(uri, ignoreFragment = false) {
+        return uri.with({
+            path: this._ignorePathCasing(uri) ? uri.path.toLowerCase() : undefined,
+            fragment: ignoreFragment ? null : undefined
+        }).toString();
+    }
+    isEqualOrParent(base, parentCandidate, ignoreFragment = false) {
+        if (base.scheme === parentCandidate.scheme) {
+            if (base.scheme === Schemas.file) {
+                return extpath.isEqualOrParent(originalFSPath(base), originalFSPath(parentCandidate), this._ignorePathCasing(base)) && base.query === parentCandidate.query && (ignoreFragment || base.fragment === parentCandidate.fragment);
+            }
+            if (isEqualAuthority(base.authority, parentCandidate.authority)) {
+                return extpath.isEqualOrParent(base.path, parentCandidate.path, this._ignorePathCasing(base), '/') && base.query === parentCandidate.query && (ignoreFragment || base.fragment === parentCandidate.fragment);
+            }
+        }
+        return false;
+    }
+    // --- path math
+    joinPath(resource, ...pathFragment) {
+        return URI.joinPath(resource, ...pathFragment);
+    }
+    basenameOrAuthority(resource) {
+        return basename(resource) || resource.authority;
+    }
+    basename(resource) {
+        return paths.posix.basename(resource.path);
+    }
+    extname(resource) {
+        return paths.posix.extname(resource.path);
+    }
+    dirname(resource) {
+        if (resource.path.length === 0) {
+            return resource;
+        }
+        let dirname;
+        if (resource.scheme === Schemas.file) {
+            dirname = URI.file(paths.dirname(originalFSPath(resource))).path;
+        }
+        else {
+            dirname = paths.posix.dirname(resource.path);
+            if (resource.authority && dirname.length && dirname.charCodeAt(0) !== 47 /* CharCode.Slash */) {
+                console.error(`dirname("${resource.toString})) resulted in a relative path`);
+                dirname = '/'; // If a URI contains an authority component, then the path component must either be empty or begin with a CharCode.Slash ("/") character
+            }
+        }
+        return resource.with({
+            path: dirname
+        });
+    }
+    normalizePath(resource) {
+        if (!resource.path.length) {
+            return resource;
+        }
+        let normalizedPath;
+        if (resource.scheme === Schemas.file) {
+            normalizedPath = URI.file(paths.normalize(originalFSPath(resource))).path;
+        }
+        else {
+            normalizedPath = paths.posix.normalize(resource.path);
+        }
+        return resource.with({
+            path: normalizedPath
+        });
+    }
+    relativePath(from, to) {
+        if (from.scheme !== to.scheme || !isEqualAuthority(from.authority, to.authority)) {
+            return undefined;
+        }
+        if (from.scheme === Schemas.file) {
+            const relativePath = paths.relative(originalFSPath(from), originalFSPath(to));
+            return isWindows ? extpath.toSlashes(relativePath) : relativePath;
+        }
+        let fromPath = from.path || '/';
+        const toPath = to.path || '/';
+        if (this._ignorePathCasing(from)) {
+            // make casing of fromPath match toPath
+            let i = 0;
+            for (const len = Math.min(fromPath.length, toPath.length); i < len; i++) {
+                if (fromPath.charCodeAt(i) !== toPath.charCodeAt(i)) {
+                    if (fromPath.charAt(i).toLowerCase() !== toPath.charAt(i).toLowerCase()) {
+                        break;
+                    }
+                }
+            }
+            fromPath = toPath.substr(0, i) + fromPath.substr(i);
+        }
+        return paths.posix.relative(fromPath, toPath);
+    }
+    resolvePath(base, path) {
+        if (base.scheme === Schemas.file) {
+            const newURI = URI.file(paths.resolve(originalFSPath(base), path));
+            return base.with({
+                authority: newURI.authority,
+                path: newURI.path
+            });
+        }
+        path = extpath.toPosixPath(path); // we allow path to be a windows path
+        return base.with({
+            path: paths.posix.resolve(base.path, path)
+        });
+    }
+    // --- misc
+    isAbsolutePath(resource) {
+        return !!resource.path && resource.path[0] === '/';
+    }
+    isEqualAuthority(a1, a2) {
+        return a1 === a2 || (a1 !== undefined && a2 !== undefined && equalsIgnoreCase(a1, a2));
+    }
+    hasTrailingPathSeparator(resource, sep = paths.sep) {
+        if (resource.scheme === Schemas.file) {
+            const fsp = originalFSPath(resource);
+            return fsp.length > extpath.getRoot(fsp).length && fsp[fsp.length - 1] === sep;
+        }
+        else {
+            const p = resource.path;
+            return (p.length > 1 && p.charCodeAt(p.length - 1) === 47 /* CharCode.Slash */) && !(/^[a-zA-Z]:(\/$|\\$)/.test(resource.fsPath)); // ignore the slash at offset 0
+        }
+    }
+    removeTrailingPathSeparator(resource, sep = paths.sep) {
+        // Make sure that the path isn't a drive letter. A trailing separator there is not removable.
+        if (hasTrailingPathSeparator(resource, sep)) {
+            return resource.with({ path: resource.path.substr(0, resource.path.length - 1) });
+        }
+        return resource;
+    }
+    addTrailingPathSeparator(resource, sep = paths.sep) {
+        let isRootSep = false;
+        if (resource.scheme === Schemas.file) {
+            const fsp = originalFSPath(resource);
+            isRootSep = ((fsp !== undefined) && (fsp.length === extpath.getRoot(fsp).length) && (fsp[fsp.length - 1] === sep));
+        }
+        else {
+            sep = '/';
+            const p = resource.path;
+            isRootSep = p.length === 1 && p.charCodeAt(p.length - 1) === 47 /* CharCode.Slash */;
+        }
+        if (!isRootSep && !hasTrailingPathSeparator(resource, sep)) {
+            return resource.with({ path: resource.path + '/' });
+        }
+        return resource;
+    }
+}
+/**
+ * Unbiased utility that takes uris "as they are". This means it can be interchanged with
+ * uri#toString() usages. The following is true
+ * ```
+ * assertEqual(aUri.toString() === bUri.toString(), exturi.isEqual(aUri, bUri))
+ * ```
+ */
+export const extUri = new ExtUri(() => false);
+/**
+ * BIASED utility that _mostly_ ignored the case of urs paths. ONLY use this util if you
+ * understand what you are doing.
+ *
+ * This utility is INCOMPATIBLE with `uri.toString()`-usages and both CANNOT be used interchanged.
+ *
+ * When dealing with uris from files or documents, `extUri` (the unbiased friend)is sufficient
+ * because those uris come from a "trustworthy source". When creating unknown uris it's always
+ * better to use `IUriIdentityService` which exposes an `IExtUri`-instance which knows when path
+ * casing matters.
+ */
+export const extUriBiasedIgnorePathCase = new ExtUri(uri => {
+    // A file scheme resource is in the same platform as code, so ignore case for non linux platforms
+    // Resource can be from another platform. Lowering the case as an hack. Should come from File system provider
+    return uri.scheme === Schemas.file ? !isLinux : true;
+});
+/**
+ * BIASED utility that always ignores the casing of uris paths. ONLY use this util if you
+ * understand what you are doing.
+ *
+ * This utility is INCOMPATIBLE with `uri.toString()`-usages and both CANNOT be used interchanged.
+ *
+ * When dealing with uris from files or documents, `extUri` (the unbiased friend)is sufficient
+ * because those uris come from a "trustworthy source". When creating unknown uris it's always
+ * better to use `IUriIdentityService` which exposes an `IExtUri`-instance which knows when path
+ * casing matters.
+ */
+export const extUriIgnorePathCase = new ExtUri(_ => true);
+export const isEqual = extUri.isEqual.bind(extUri);
+export const isEqualOrParent = extUri.isEqualOrParent.bind(extUri);
+export const getComparisonKey = extUri.getComparisonKey.bind(extUri);
+export const basenameOrAuthority = extUri.basenameOrAuthority.bind(extUri);
+export const basename = extUri.basename.bind(extUri);
+export const extname = extUri.extname.bind(extUri);
+export const dirname = extUri.dirname.bind(extUri);
+export const joinPath = extUri.joinPath.bind(extUri);
+export const normalizePath = extUri.normalizePath.bind(extUri);
+export const relativePath = extUri.relativePath.bind(extUri);
+export const resolvePath = extUri.resolvePath.bind(extUri);
+export const isAbsolutePath = extUri.isAbsolutePath.bind(extUri);
+export const isEqualAuthority = extUri.isEqualAuthority.bind(extUri);
+export const hasTrailingPathSeparator = extUri.hasTrailingPathSeparator.bind(extUri);
+export const removeTrailingPathSeparator = extUri.removeTrailingPathSeparator.bind(extUri);
+export const addTrailingPathSeparator = extUri.addTrailingPathSeparator.bind(extUri);
+/**
+ * Data URI related helpers.
+ */
+export var DataUri;
+(function (DataUri) {
+    DataUri.META_DATA_LABEL = 'label';
+    DataUri.META_DATA_DESCRIPTION = 'description';
+    DataUri.META_DATA_SIZE = 'size';
+    DataUri.META_DATA_MIME = 'mime';
+    function parseMetaData(dataUri) {
+        const metadata = new Map();
+        // Given a URI of:  data:image/png;size:2313;label:SomeLabel;description:SomeDescription;base64,77+9UE5...
+        // the metadata is: size:2313;label:SomeLabel;description:SomeDescription
+        const meta = dataUri.path.substring(dataUri.path.indexOf(';') + 1, dataUri.path.lastIndexOf(';'));
+        meta.split(';').forEach(property => {
+            const [key, value] = property.split(':');
+            if (key && value) {
+                metadata.set(key, value);
+            }
+        });
+        // Given a URI of:  data:image/png;size:2313;label:SomeLabel;description:SomeDescription;base64,77+9UE5...
+        // the mime is: image/png
+        const mime = dataUri.path.substring(0, dataUri.path.indexOf(';'));
+        if (mime) {
+            metadata.set(DataUri.META_DATA_MIME, mime);
+        }
+        return metadata;
+    }
+    DataUri.parseMetaData = parseMetaData;
+})(DataUri || (DataUri = {}));