@codingame/monaco-vscode-api 1.85.4 → 2.0.0-rework-ci.1

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

@@ -0,0 +1,1451 @@
+import { isWebKit } from './browser.js';
+import { BrowserFeatures } from './canIUse.js';
+import { StandardKeyboardEvent } from './keyboardEvent.js';
+import { StandardMouseEvent } from './mouseEvent.js';
+import { _runWhenIdle, AbstractIdleValue, IntervalTimer } from '../common/async.js';
+import { onUnexpectedError } from '../common/errors.js';
+import { Emitter, Event } from '../common/event.js';
+import { sanitize, addHook, removeHook } from './dompurify/dompurify.js';
+import { DisposableStore, Disposable, toDisposable } from '../common/lifecycle.js';
+import { RemoteAuthorities, FileAccess, Schemas } from '../common/network.js';
+import { isIOS } from '../common/platform.js';
+import { URI } from '../common/uri.js';
+import { hash } from '../common/hash.js';
+import { mainWindow, ensureCodeWindow } from './window.js';
+const { registerWindow, getWindow, getDocument, getWindows, getWindowsCount, getWindowId, getWindowById, hasWindow, onDidRegisterWindow, onWillUnregisterWindow, onDidUnregisterWindow } = ( (function() {
+    const windows = ( new Map());
+    ensureCodeWindow(mainWindow, 1);
+    windows.set(mainWindow.vscodeWindowId, { window: mainWindow, disposables: ( new DisposableStore()) });
+    const onDidRegisterWindow = new Emitter();
+    const onDidUnregisterWindow = new Emitter();
+    const onWillUnregisterWindow = new Emitter();
+    return {
+        onDidRegisterWindow: onDidRegisterWindow.event,
+        onWillUnregisterWindow: onWillUnregisterWindow.event,
+        onDidUnregisterWindow: onDidUnregisterWindow.event,
+        registerWindow(window) {
+            if (( windows.has(window.vscodeWindowId))) {
+                return Disposable.None;
+            }
+            const disposables = ( new DisposableStore());
+            const registeredWindow = {
+                window,
+                disposables: disposables.add(( new DisposableStore()))
+            };
+            windows.set(window.vscodeWindowId, registeredWindow);
+            disposables.add(toDisposable(() => {
+                windows.delete(window.vscodeWindowId);
+                onDidUnregisterWindow.fire(window);
+            }));
+            disposables.add(addDisposableListener(window, EventType.BEFORE_UNLOAD, () => {
+                onWillUnregisterWindow.fire(window);
+            }));
+            onDidRegisterWindow.fire(registeredWindow);
+            return disposables;
+        },
+        getWindows() {
+            return ( windows.values());
+        },
+        getWindowsCount() {
+            return windows.size;
+        },
+        getWindowId(targetWindow) {
+            return targetWindow.vscodeWindowId;
+        },
+        hasWindow(windowId) {
+            return ( windows.has(windowId));
+        },
+        getWindowById(windowId) {
+            return windows.get(windowId);
+        },
+        getWindow(e) {
+            const candidateNode = e;
+            if (candidateNode?.ownerDocument?.defaultView) {
+                return candidateNode.ownerDocument.defaultView.window;
+            }
+            const candidateEvent = e;
+            if (candidateEvent?.view) {
+                return candidateEvent.view.window;
+            }
+            return mainWindow;
+        },
+        getDocument(e) {
+            const candidateNode = e;
+            return getWindow(candidateNode).document;
+        }
+    };
+})());
+function clearNode(node) {
+    while (node.firstChild) {
+        node.firstChild.remove();
+    }
+}
+class DomListener {
+    constructor(node, type, handler, options) {
+        this._node = node;
+        this._type = type;
+        this._handler = handler;
+        this._options = (options || false);
+        this._node.addEventListener(this._type, this._handler, this._options);
+    }
+    dispose() {
+        if (!this._handler) {
+            return;
+        }
+        this._node.removeEventListener(this._type, this._handler, this._options);
+        this._node = null;
+        this._handler = null;
+    }
+}
+function addDisposableListener(node, type, handler, useCaptureOrOptions) {
+    return ( new DomListener(node, type, handler, useCaptureOrOptions));
+}
+function _wrapAsStandardMouseEvent(targetWindow, handler) {
+    return function (e) {
+        return handler(( new StandardMouseEvent(targetWindow, e)));
+    };
+}
+function _wrapAsStandardKeyboardEvent(handler) {
+    return function (e) {
+        return handler(( new StandardKeyboardEvent(e)));
+    };
+}
+const addStandardDisposableListener = function addStandardDisposableListener(node, type, handler, useCapture) {
+    let wrapHandler = handler;
+    if (type === 'click' || type === 'mousedown') {
+        wrapHandler = _wrapAsStandardMouseEvent(getWindow(node), handler);
+    }
+    else if (type === 'keydown' || type === 'keypress' || type === 'keyup') {
+        wrapHandler = _wrapAsStandardKeyboardEvent(handler);
+    }
+    return addDisposableListener(node, type, wrapHandler, useCapture);
+};
+const addStandardDisposableGenericMouseDownListener = function addStandardDisposableListener(node, handler, useCapture) {
+    const wrapHandler = _wrapAsStandardMouseEvent(getWindow(node), handler);
+    return addDisposableGenericMouseDownListener(node, wrapHandler, useCapture);
+};
+const addStandardDisposableGenericMouseUpListener = function addStandardDisposableListener(node, handler, useCapture) {
+    const wrapHandler = _wrapAsStandardMouseEvent(getWindow(node), handler);
+    return addDisposableGenericMouseUpListener(node, wrapHandler, useCapture);
+};
+function addDisposableGenericMouseDownListener(node, handler, useCapture) {
+    return addDisposableListener(node, isIOS && BrowserFeatures.pointerEvents ? EventType.POINTER_DOWN : EventType.MOUSE_DOWN, handler, useCapture);
+}
+function addDisposableGenericMouseUpListener(node, handler, useCapture) {
+    return addDisposableListener(node, isIOS && BrowserFeatures.pointerEvents ? EventType.POINTER_UP : EventType.MOUSE_UP, handler, useCapture);
+}
+function runWhenWindowIdle(targetWindow, callback, timeout) {
+    return _runWhenIdle(targetWindow, callback, timeout);
+}
+class WindowIdleValue extends AbstractIdleValue {
+    constructor(targetWindow, executor) {
+        super(targetWindow, executor);
+    }
+}
+let runAtThisOrScheduleAtNextAnimationFrame;
+let scheduleAtNextAnimationFrame;
+function disposableWindowInterval(targetWindow, handler, interval, iterations) {
+    let iteration = 0;
+    const timer = targetWindow.setInterval(() => {
+        iteration++;
+        if ((typeof iterations === 'number' && iteration >= iterations) || handler() === true) {
+            disposable.dispose();
+        }
+    }, interval);
+    const disposable = toDisposable(() => {
+        targetWindow.clearInterval(timer);
+    });
+    return disposable;
+}
+class WindowIntervalTimer extends IntervalTimer {
+    cancelAndSet(runner, interval, targetWindow) {
+        return super.cancelAndSet(runner, interval, targetWindow);
+    }
+}
+class AnimationFrameQueueItem {
+    constructor(runner, priority = 0) {
+        this._runner = runner;
+        this.priority = priority;
+        this._canceled = false;
+    }
+    dispose() {
+        this._canceled = true;
+    }
+    execute() {
+        if (this._canceled) {
+            return;
+        }
+        try {
+            this._runner();
+        }
+        catch (e) {
+            onUnexpectedError(e);
+        }
+    }
+    static sort(a, b) {
+        return b.priority - a.priority;
+    }
+}
+(function () {
+    const NEXT_QUEUE = ( new Map());
+    const CURRENT_QUEUE = ( new Map());
+    const animFrameRequested = ( new Map());
+    const inAnimationFrameRunner = ( new Map());
+    const animationFrameRunner = (targetWindowId) => {
+        animFrameRequested.set(targetWindowId, false);
+        const currentQueue = NEXT_QUEUE.get(targetWindowId) ?? [];
+        CURRENT_QUEUE.set(targetWindowId, currentQueue);
+        NEXT_QUEUE.set(targetWindowId, []);
+        inAnimationFrameRunner.set(targetWindowId, true);
+        while (currentQueue.length > 0) {
+            currentQueue.sort(AnimationFrameQueueItem.sort);
+            const top = currentQueue.shift();
+            top.execute();
+        }
+        inAnimationFrameRunner.set(targetWindowId, false);
+    };
+    scheduleAtNextAnimationFrame = (targetWindow, runner, priority = 0) => {
+        const targetWindowId = getWindowId(targetWindow);
+        const item = ( new AnimationFrameQueueItem(runner, priority));
+        let nextQueue = NEXT_QUEUE.get(targetWindowId);
+        if (!nextQueue) {
+            nextQueue = [];
+            NEXT_QUEUE.set(targetWindowId, nextQueue);
+        }
+        nextQueue.push(item);
+        if (!animFrameRequested.get(targetWindowId)) {
+            animFrameRequested.set(targetWindowId, true);
+            targetWindow.requestAnimationFrame(() => animationFrameRunner(targetWindowId));
+        }
+        return item;
+    };
+    runAtThisOrScheduleAtNextAnimationFrame = (targetWindow, runner, priority) => {
+        const targetWindowId = getWindowId(targetWindow);
+        if (inAnimationFrameRunner.get(targetWindowId)) {
+            const item = ( new AnimationFrameQueueItem(runner, priority));
+            let currentQueue = CURRENT_QUEUE.get(targetWindowId);
+            if (!currentQueue) {
+                currentQueue = [];
+                CURRENT_QUEUE.set(targetWindowId, currentQueue);
+            }
+            currentQueue.push(item);
+            return item;
+        }
+        else {
+            return scheduleAtNextAnimationFrame(targetWindow, runner, priority);
+        }
+    };
+})();
+function measure(targetWindow, callback) {
+    return scheduleAtNextAnimationFrame(targetWindow, callback, 10000 );
+}
+function modify(targetWindow, callback) {
+    return scheduleAtNextAnimationFrame(targetWindow, callback, -10000 );
+}
+function getComputedStyle(el) {
+    return getWindow(el).getComputedStyle(el, null);
+}
+function getClientArea(element, fallback) {
+    const elWindow = getWindow(element);
+    const elDocument = elWindow.document;
+    if (element !== elDocument.body) {
+        return ( new Dimension(element.clientWidth, element.clientHeight));
+    }
+    if (isIOS && elWindow?.visualViewport) {
+        return ( new Dimension(elWindow.visualViewport.width, elWindow.visualViewport.height));
+    }
+    if (elWindow?.innerWidth && elWindow.innerHeight) {
+        return ( new Dimension(elWindow.innerWidth, elWindow.innerHeight));
+    }
+    if (elDocument.body && elDocument.body.clientWidth && elDocument.body.clientHeight) {
+        return ( new Dimension(elDocument.body.clientWidth, elDocument.body.clientHeight));
+    }
+    if (elDocument.documentElement && elDocument.documentElement.clientWidth && elDocument.documentElement.clientHeight) {
+        return ( new Dimension(
+            elDocument.documentElement.clientWidth,
+            elDocument.documentElement.clientHeight
+        ));
+    }
+    if (fallback) {
+        return getClientArea(fallback);
+    }
+    throw new Error('Unable to figure out browser width and height');
+}
+class SizeUtils {
+    static convertToPixels(element, value) {
+        return parseFloat(value) || 0;
+    }
+    static getDimension(element, cssPropertyName, jsPropertyName) {
+        const computedStyle = getComputedStyle(element);
+        const value = computedStyle ? computedStyle.getPropertyValue(cssPropertyName) : '0';
+        return SizeUtils.convertToPixels(element, value);
+    }
+    static getBorderLeftWidth(element) {
+        return SizeUtils.getDimension(element, 'border-left-width', 'borderLeftWidth');
+    }
+    static getBorderRightWidth(element) {
+        return SizeUtils.getDimension(element, 'border-right-width', 'borderRightWidth');
+    }
+    static getBorderTopWidth(element) {
+        return SizeUtils.getDimension(element, 'border-top-width', 'borderTopWidth');
+    }
+    static getBorderBottomWidth(element) {
+        return SizeUtils.getDimension(element, 'border-bottom-width', 'borderBottomWidth');
+    }
+    static getPaddingLeft(element) {
+        return SizeUtils.getDimension(element, 'padding-left', 'paddingLeft');
+    }
+    static getPaddingRight(element) {
+        return SizeUtils.getDimension(element, 'padding-right', 'paddingRight');
+    }
+    static getPaddingTop(element) {
+        return SizeUtils.getDimension(element, 'padding-top', 'paddingTop');
+    }
+    static getPaddingBottom(element) {
+        return SizeUtils.getDimension(element, 'padding-bottom', 'paddingBottom');
+    }
+    static getMarginLeft(element) {
+        return SizeUtils.getDimension(element, 'margin-left', 'marginLeft');
+    }
+    static getMarginTop(element) {
+        return SizeUtils.getDimension(element, 'margin-top', 'marginTop');
+    }
+    static getMarginRight(element) {
+        return SizeUtils.getDimension(element, 'margin-right', 'marginRight');
+    }
+    static getMarginBottom(element) {
+        return SizeUtils.getDimension(element, 'margin-bottom', 'marginBottom');
+    }
+}
+class Dimension {
+    static { this.None = ( new Dimension(0, 0)); }
+    constructor(width, height) {
+        this.width = width;
+        this.height = height;
+    }
+    with(width = this.width, height = this.height) {
+        if (width !== this.width || height !== this.height) {
+            return ( new Dimension(width, height));
+        }
+        else {
+            return this;
+        }
+    }
+    static is(obj) {
+        return typeof obj === 'object' && typeof obj.height === 'number' && typeof obj.width === 'number';
+    }
+    static lift(obj) {
+        if (obj instanceof Dimension) {
+            return obj;
+        }
+        else {
+            return ( new Dimension(obj.width, obj.height));
+        }
+    }
+    static equals(a, b) {
+        if (a === b) {
+            return true;
+        }
+        if (!a || !b) {
+            return false;
+        }
+        return a.width === b.width && a.height === b.height;
+    }
+}
+function getTopLeftOffset(element) {
+    let offsetParent = element.offsetParent;
+    let top = element.offsetTop;
+    let left = element.offsetLeft;
+    while ((element = element.parentNode) !== null
+        && element !== element.ownerDocument.body
+        && element !== element.ownerDocument.documentElement) {
+        top -= element.scrollTop;
+        const c = isShadowRoot(element) ? null : getComputedStyle(element);
+        if (c) {
+            left -= c.direction !== 'rtl' ? element.scrollLeft : -element.scrollLeft;
+        }
+        if (element === offsetParent) {
+            left += SizeUtils.getBorderLeftWidth(element);
+            top += SizeUtils.getBorderTopWidth(element);
+            top += element.offsetTop;
+            left += element.offsetLeft;
+            offsetParent = element.offsetParent;
+        }
+    }
+    return {
+        left: left,
+        top: top
+    };
+}
+function size(element, width, height) {
+    if (typeof width === 'number') {
+        element.style.width = `${width}px`;
+    }
+    if (typeof height === 'number') {
+        element.style.height = `${height}px`;
+    }
+}
+function position(element, top, right, bottom, left, position = 'absolute') {
+    if (typeof top === 'number') {
+        element.style.top = `${top}px`;
+    }
+    if (typeof right === 'number') {
+        element.style.right = `${right}px`;
+    }
+    if (typeof bottom === 'number') {
+        element.style.bottom = `${bottom}px`;
+    }
+    if (typeof left === 'number') {
+        element.style.left = `${left}px`;
+    }
+    element.style.position = position;
+}
+function getDomNodePagePosition(domNode) {
+    const bb = domNode.getBoundingClientRect();
+    const window = getWindow(domNode);
+    return {
+        left: bb.left + window.scrollX,
+        top: bb.top + window.scrollY,
+        width: bb.width,
+        height: bb.height
+    };
+}
+function getDomNodeZoomLevel(domNode) {
+    let testElement = domNode;
+    let zoom = 1.0;
+    do {
+        const elementZoomLevel = getComputedStyle(testElement).zoom;
+        if (elementZoomLevel !== null && elementZoomLevel !== undefined && elementZoomLevel !== '1') {
+            zoom *= elementZoomLevel;
+        }
+        testElement = testElement.parentElement;
+    } while (testElement !== null && testElement !== testElement.ownerDocument.documentElement);
+    return zoom;
+}
+function getTotalWidth(element) {
+    const margin = SizeUtils.getMarginLeft(element) + SizeUtils.getMarginRight(element);
+    return element.offsetWidth + margin;
+}
+function getContentWidth(element) {
+    const border = SizeUtils.getBorderLeftWidth(element) + SizeUtils.getBorderRightWidth(element);
+    const padding = SizeUtils.getPaddingLeft(element) + SizeUtils.getPaddingRight(element);
+    return element.offsetWidth - border - padding;
+}
+function getTotalScrollWidth(element) {
+    const margin = SizeUtils.getMarginLeft(element) + SizeUtils.getMarginRight(element);
+    return element.scrollWidth + margin;
+}
+function getContentHeight(element) {
+    const border = SizeUtils.getBorderTopWidth(element) + SizeUtils.getBorderBottomWidth(element);
+    const padding = SizeUtils.getPaddingTop(element) + SizeUtils.getPaddingBottom(element);
+    return element.offsetHeight - border - padding;
+}
+function getTotalHeight(element) {
+    const margin = SizeUtils.getMarginTop(element) + SizeUtils.getMarginBottom(element);
+    return element.offsetHeight + margin;
+}
+function getRelativeLeft(element, parent) {
+    if (element === null) {
+        return 0;
+    }
+    const elementPosition = getTopLeftOffset(element);
+    const parentPosition = getTopLeftOffset(parent);
+    return elementPosition.left - parentPosition.left;
+}
+function getLargestChildWidth(parent, children) {
+    const childWidths = ( children.map((child) => {
+        return Math.max(getTotalScrollWidth(child), getTotalWidth(child)) + getRelativeLeft(child, parent) || 0;
+    }));
+    const maxWidth = Math.max(...childWidths);
+    return maxWidth;
+}
+function isAncestor(testChild, testAncestor) {
+    return Boolean(testAncestor?.contains(testChild));
+}
+const parentFlowToDataKey = 'parentFlowToElementId';
+function setParentFlowTo(fromChildElement, toParentElement) {
+    fromChildElement.dataset[parentFlowToDataKey] = toParentElement.id;
+}
+function getParentFlowToElement(node) {
+    const flowToParentId = node.dataset[parentFlowToDataKey];
+    if (typeof flowToParentId === 'string') {
+        return node.ownerDocument.getElementById(flowToParentId);
+    }
+    return null;
+}
+function isAncestorUsingFlowTo(testChild, testAncestor) {
+    let node = testChild;
+    while (node) {
+        if (node === testAncestor) {
+            return true;
+        }
+        if (node instanceof HTMLElement) {
+            const flowToParentElement = getParentFlowToElement(node);
+            if (flowToParentElement) {
+                node = flowToParentElement;
+                continue;
+            }
+        }
+        node = node.parentNode;
+    }
+    return false;
+}
+function findParentWithClass(node, clazz, stopAtClazzOrNode) {
+    while (node && node.nodeType === node.ELEMENT_NODE) {
+        if (node.classList.contains(clazz)) {
+            return node;
+        }
+        if (stopAtClazzOrNode) {
+            if (typeof stopAtClazzOrNode === 'string') {
+                if (node.classList.contains(stopAtClazzOrNode)) {
+                    return null;
+                }
+            }
+            else {
+                if (node === stopAtClazzOrNode) {
+                    return null;
+                }
+            }
+        }
+        node = node.parentNode;
+    }
+    return null;
+}
+function hasParentWithClass(node, clazz, stopAtClazzOrNode) {
+    return !!findParentWithClass(node, clazz, stopAtClazzOrNode);
+}
+function isShadowRoot(node) {
+    return (node && !!node.host && !!node.mode);
+}
+function isInShadowDOM(domNode) {
+    return !!getShadowRoot(domNode);
+}
+function getShadowRoot(domNode) {
+    while (domNode.parentNode) {
+        if (domNode === domNode.ownerDocument?.body) {
+            return null;
+        }
+        domNode = domNode.parentNode;
+    }
+    return isShadowRoot(domNode) ? domNode : null;
+}
+function getActiveElement() {
+    let result = getActiveDocument().activeElement;
+    while (result?.shadowRoot) {
+        result = result.shadowRoot.activeElement;
+    }
+    return result;
+}
+function isActiveElement(element) {
+    return element.ownerDocument.activeElement === element;
+}
+function isAncestorOfActiveElement(ancestor) {
+    return isAncestor(ancestor.ownerDocument.activeElement, ancestor);
+}
+function isActiveDocument(element) {
+    return element.ownerDocument === getActiveDocument();
+}
+function getActiveDocument() {
+    if (getWindowsCount() <= 1) {
+        return document;
+    }
+    const documents = ( Array.from(getWindows()).map(({ window }) => window.document));
+    return documents.find(doc => doc.hasFocus()) ?? document;
+}
+function getActiveWindow() {
+    const document = getActiveDocument();
+    return (document.defaultView?.window ?? mainWindow);
+}
+function focusWindow(element) {
+    const window = getWindow(element);
+    if (!window.document.hasFocus()) {
+        window.focus();
+    }
+}
+const globalStylesheets = ( new Map());
+function isGlobalStylesheet(node) {
+    return ( globalStylesheets.has(node));
+}
+function createStyleSheet(container = mainWindow.document.head, beforeAppend, disposableStore) {
+    const style = document.createElement('style');
+    style.type = 'text/css';
+    style.media = 'screen';
+    beforeAppend?.(style);
+    container.appendChild(style);
+    if (disposableStore) {
+        disposableStore.add(toDisposable(() => container.removeChild(style)));
+    }
+    if (container === mainWindow.document.head) {
+        const globalStylesheetClones = ( new Set());
+        globalStylesheets.set(style, globalStylesheetClones);
+        for (const { window: targetWindow, disposables } of getWindows()) {
+            if (targetWindow === mainWindow) {
+                continue;
+            }
+            const cloneDisposable = disposables.add(cloneGlobalStyleSheet(style, globalStylesheetClones, targetWindow));
+            disposableStore?.add(cloneDisposable);
+        }
+    }
+    return style;
+}
+function cloneGlobalStylesheets(targetWindow) {
+    const disposables = ( new DisposableStore());
+    for (const [globalStylesheet, clonedGlobalStylesheets] of globalStylesheets) {
+        disposables.add(cloneGlobalStyleSheet(globalStylesheet, clonedGlobalStylesheets, targetWindow));
+    }
+    return disposables;
+}
+function cloneGlobalStyleSheet(globalStylesheet, globalStylesheetClones, targetWindow) {
+    const disposables = ( new DisposableStore());
+    const clone = globalStylesheet.cloneNode(true);
+    targetWindow.document.head.appendChild(clone);
+    disposables.add(toDisposable(() => targetWindow.document.head.removeChild(clone)));
+    for (const rule of getDynamicStyleSheetRules(globalStylesheet)) {
+        clone.sheet?.insertRule(rule.cssText, clone.sheet?.cssRules.length);
+    }
+    disposables.add(sharedMutationObserver.observe(globalStylesheet, disposables, { childList: true })(() => {
+        clone.textContent = globalStylesheet.textContent;
+    }));
+    globalStylesheetClones.add(clone);
+    disposables.add(toDisposable(() => globalStylesheetClones.delete(clone)));
+    return disposables;
+}
+const sharedMutationObserver = new (class {
+    constructor() {
+        this.mutationObservers = ( new Map());
+    }
+    observe(target, disposables, options) {
+        let mutationObserversPerTarget = this.mutationObservers.get(target);
+        if (!mutationObserversPerTarget) {
+            mutationObserversPerTarget = ( new Map());
+            this.mutationObservers.set(target, mutationObserversPerTarget);
+        }
+        const optionsHash = hash(options);
+        let mutationObserverPerOptions = mutationObserversPerTarget.get(optionsHash);
+        if (!mutationObserverPerOptions) {
+            const onDidMutate = new Emitter();
+            const observer = ( new MutationObserver(mutations => onDidMutate.fire(mutations)));
+            observer.observe(target, options);
+            const resolvedMutationObserverPerOptions = mutationObserverPerOptions = {
+                users: 1,
+                observer,
+                onDidMutate: onDidMutate.event
+            };
+            disposables.add(toDisposable(() => {
+                resolvedMutationObserverPerOptions.users -= 1;
+                if (resolvedMutationObserverPerOptions.users === 0) {
+                    onDidMutate.dispose();
+                    observer.disconnect();
+                    mutationObserversPerTarget?.delete(optionsHash);
+                    if (mutationObserversPerTarget?.size === 0) {
+                        this.mutationObservers.delete(target);
+                    }
+                }
+            }));
+            mutationObserversPerTarget.set(optionsHash, mutationObserverPerOptions);
+        }
+        else {
+            mutationObserverPerOptions.users += 1;
+        }
+        return mutationObserverPerOptions.onDidMutate;
+    }
+});
+function createMetaElement(container = mainWindow.document.head) {
+    const meta = document.createElement('meta');
+    container.appendChild(meta);
+    return meta;
+}
+let _sharedStyleSheet = null;
+function getSharedStyleSheet() {
+    if (!_sharedStyleSheet) {
+        _sharedStyleSheet = createStyleSheet();
+    }
+    return _sharedStyleSheet;
+}
+function getDynamicStyleSheetRules(style) {
+    if (style?.sheet?.rules) {
+        return style.sheet.rules;
+    }
+    if (style?.sheet?.cssRules) {
+        return style.sheet.cssRules;
+    }
+    return [];
+}
+function createCSSRule(selector, cssText, style = getSharedStyleSheet()) {
+    if (!style || !cssText) {
+        return;
+    }
+    style.sheet?.insertRule(`${selector} {${cssText}}`, 0);
+    for (const clonedGlobalStylesheet of globalStylesheets.get(style) ?? []) {
+        createCSSRule(selector, cssText, clonedGlobalStylesheet);
+    }
+}
+function removeCSSRulesContainingSelector(ruleName, style = getSharedStyleSheet()) {
+    if (!style) {
+        return;
+    }
+    const rules = getDynamicStyleSheetRules(style);
+    const toDelete = [];
+    for (let i = 0; i < rules.length; i++) {
+        const rule = rules[i];
+        if (isCSSStyleRule(rule) && rule.selectorText.indexOf(ruleName) !== -1) {
+            toDelete.push(i);
+        }
+    }
+    for (let i = toDelete.length - 1; i >= 0; i--) {
+        style.sheet?.deleteRule(toDelete[i]);
+    }
+    for (const clonedGlobalStylesheet of globalStylesheets.get(style) ?? []) {
+        removeCSSRulesContainingSelector(ruleName, clonedGlobalStylesheet);
+    }
+}
+function isCSSStyleRule(rule) {
+    return typeof rule.selectorText === 'string';
+}
+function isMouseEvent(e) {
+    return e instanceof MouseEvent || e instanceof getWindow(e).MouseEvent;
+}
+function isKeyboardEvent(e) {
+    return e instanceof KeyboardEvent || e instanceof getWindow(e).KeyboardEvent;
+}
+function isPointerEvent(e) {
+    return e instanceof PointerEvent || e instanceof getWindow(e).PointerEvent;
+}
+function isDragEvent(e) {
+    return e instanceof DragEvent || e instanceof getWindow(e).DragEvent;
+}
+const EventType = {
+    CLICK: 'click',
+    AUXCLICK: 'auxclick',
+    DBLCLICK: 'dblclick',
+    MOUSE_UP: 'mouseup',
+    MOUSE_DOWN: 'mousedown',
+    MOUSE_OVER: 'mouseover',
+    MOUSE_MOVE: 'mousemove',
+    MOUSE_OUT: 'mouseout',
+    MOUSE_ENTER: 'mouseenter',
+    MOUSE_LEAVE: 'mouseleave',
+    MOUSE_WHEEL: 'wheel',
+    POINTER_UP: 'pointerup',
+    POINTER_DOWN: 'pointerdown',
+    POINTER_MOVE: 'pointermove',
+    POINTER_LEAVE: 'pointerleave',
+    CONTEXT_MENU: 'contextmenu',
+    WHEEL: 'wheel',
+    KEY_DOWN: 'keydown',
+    KEY_PRESS: 'keypress',
+    KEY_UP: 'keyup',
+    LOAD: 'load',
+    BEFORE_UNLOAD: 'beforeunload',
+    UNLOAD: 'unload',
+    PAGE_SHOW: 'pageshow',
+    PAGE_HIDE: 'pagehide',
+    PASTE: 'paste',
+    ABORT: 'abort',
+    ERROR: 'error',
+    RESIZE: 'resize',
+    SCROLL: 'scroll',
+    FULLSCREEN_CHANGE: 'fullscreenchange',
+    WK_FULLSCREEN_CHANGE: 'webkitfullscreenchange',
+    SELECT: 'select',
+    CHANGE: 'change',
+    SUBMIT: 'submit',
+    RESET: 'reset',
+    FOCUS: 'focus',
+    FOCUS_IN: 'focusin',
+    FOCUS_OUT: 'focusout',
+    BLUR: 'blur',
+    INPUT: 'input',
+    STORAGE: 'storage',
+    DRAG_START: 'dragstart',
+    DRAG: 'drag',
+    DRAG_ENTER: 'dragenter',
+    DRAG_LEAVE: 'dragleave',
+    DRAG_OVER: 'dragover',
+    DROP: 'drop',
+    DRAG_END: 'dragend',
+    ANIMATION_START: isWebKit ? 'webkitAnimationStart' : 'animationstart',
+    ANIMATION_END: isWebKit ? 'webkitAnimationEnd' : 'animationend',
+    ANIMATION_ITERATION: isWebKit ? 'webkitAnimationIteration' : 'animationiteration'
+};
+function isEventLike(obj) {
+    const candidate = obj;
+    return !!(candidate && typeof candidate.preventDefault === 'function' && typeof candidate.stopPropagation === 'function');
+}
+const EventHelper = {
+    stop: (e, cancelBubble) => {
+        e.preventDefault();
+        if (cancelBubble) {
+            e.stopPropagation();
+        }
+        return e;
+    }
+};
+function saveParentsScrollTop(node) {
+    const r = [];
+    for (let i = 0; node && node.nodeType === node.ELEMENT_NODE; i++) {
+        r[i] = node.scrollTop;
+        node = node.parentNode;
+    }
+    return r;
+}
+function restoreParentsScrollTop(node, state) {
+    for (let i = 0; node && node.nodeType === node.ELEMENT_NODE; i++) {
+        if (node.scrollTop !== state[i]) {
+            node.scrollTop = state[i];
+        }
+        node = node.parentNode;
+    }
+}
+class FocusTracker extends Disposable {
+    static hasFocusWithin(element) {
+        if (element instanceof HTMLElement) {
+            const shadowRoot = getShadowRoot(element);
+            const activeElement = (shadowRoot ? shadowRoot.activeElement : element.ownerDocument.activeElement);
+            return isAncestor(activeElement, element);
+        }
+        else {
+            const window = element;
+            return isAncestor(window.document.activeElement, window.document);
+        }
+    }
+    constructor(element) {
+        super();
+        this._onDidFocus = this._register(new Emitter());
+        this.onDidFocus = this._onDidFocus.event;
+        this._onDidBlur = this._register(new Emitter());
+        this.onDidBlur = this._onDidBlur.event;
+        let hasFocus = FocusTracker.hasFocusWithin(element);
+        let loosingFocus = false;
+        const onFocus = () => {
+            loosingFocus = false;
+            if (!hasFocus) {
+                hasFocus = true;
+                this._onDidFocus.fire();
+            }
+        };
+        const onBlur = () => {
+            if (hasFocus) {
+                loosingFocus = true;
+                (element instanceof HTMLElement ? getWindow(element) : element).setTimeout(() => {
+                    if (loosingFocus) {
+                        loosingFocus = false;
+                        hasFocus = false;
+                        this._onDidBlur.fire();
+                    }
+                }, 0);
+            }
+        };
+        this._refreshStateHandler = () => {
+            const currentNodeHasFocus = FocusTracker.hasFocusWithin(element);
+            if (currentNodeHasFocus !== hasFocus) {
+                if (hasFocus) {
+                    onBlur();
+                }
+                else {
+                    onFocus();
+                }
+            }
+        };
+        this._register(addDisposableListener(element, EventType.FOCUS, onFocus, true));
+        this._register(addDisposableListener(element, EventType.BLUR, onBlur, true));
+        if (element instanceof HTMLElement) {
+            this._register(addDisposableListener(element, EventType.FOCUS_IN, () => this._refreshStateHandler()));
+            this._register(addDisposableListener(element, EventType.FOCUS_OUT, () => this._refreshStateHandler()));
+        }
+    }
+    refreshState() {
+        this._refreshStateHandler();
+    }
+}
+function trackFocus(element) {
+    return ( new FocusTracker(element));
+}
+function after(sibling, child) {
+    sibling.after(child);
+    return child;
+}
+function append(parent, ...children) {
+    parent.append(...children);
+    if (children.length === 1 && typeof children[0] !== 'string') {
+        return children[0];
+    }
+}
+function prepend(parent, child) {
+    parent.insertBefore(child, parent.firstChild);
+    return child;
+}
+function reset(parent, ...children) {
+    parent.innerText = '';
+    append(parent, ...children);
+}
+const SELECTOR_REGEX = /([\w\-]+)?(#([\w\-]+))?((\.([\w\-]+))*)/;
+var Namespace;
+( (function(Namespace) {
+    Namespace["HTML"] = "http://www.w3.org/1999/xhtml";
+    Namespace["SVG"] = "http://www.w3.org/2000/svg";
+})(Namespace || (Namespace = {})));
+function _$(namespace, description, attrs, ...children) {
+    const match = SELECTOR_REGEX.exec(description);
+    if (!match) {
+        throw new Error('Bad use of emmet');
+    }
+    const tagName = match[1] || 'div';
+    let result;
+    if (namespace !== Namespace.HTML) {
+        result = document.createElementNS(namespace, tagName);
+    }
+    else {
+        result = document.createElement(tagName);
+    }
+    if (match[3]) {
+        result.id = match[3];
+    }
+    if (match[4]) {
+        result.className = match[4].replace(/\./g, ' ').trim();
+    }
+    if (attrs) {
+        Object.entries(attrs).forEach(([name, value]) => {
+            if (typeof value === 'undefined') {
+                return;
+            }
+            if (/^on\w+$/.test(name)) {
+                result[name] = value;
+            }
+            else if (name === 'selected') {
+                if (value) {
+                    result.setAttribute(name, 'true');
+                }
+            }
+            else {
+                result.setAttribute(name, value);
+            }
+        });
+    }
+    result.append(...children);
+    return result;
+}
+function $(description, attrs, ...children) {
+    return _$(Namespace.HTML, description, attrs, ...children);
+}
+$.SVG = function (description, attrs, ...children) {
+    return _$(Namespace.SVG, description, attrs, ...children);
+};
+function join(nodes, separator) {
+    const result = [];
+    nodes.forEach((node, index) => {
+        if (index > 0) {
+            if (separator instanceof Node) {
+                result.push(separator.cloneNode());
+            }
+            else {
+                result.push(document.createTextNode(separator));
+            }
+        }
+        result.push(node);
+    });
+    return result;
+}
+function setVisibility(visible, ...elements) {
+    if (visible) {
+        show(...elements);
+    }
+    else {
+        hide(...elements);
+    }
+}
+function show(...elements) {
+    for (const element of elements) {
+        element.style.display = '';
+        element.removeAttribute('aria-hidden');
+    }
+}
+function hide(...elements) {
+    for (const element of elements) {
+        element.style.display = 'none';
+        element.setAttribute('aria-hidden', 'true');
+    }
+}
+function finalHandler(fn) {
+    return e => {
+        e.preventDefault();
+        e.stopPropagation();
+        fn(e);
+    };
+}
+function computeScreenAwareSize(window, cssPx) {
+    const screenPx = window.devicePixelRatio * cssPx;
+    return Math.max(1, Math.floor(screenPx)) / window.devicePixelRatio;
+}
+function windowOpenNoOpener(url) {
+    mainWindow.open(url, '_blank', 'noopener');
+}
+function animate(targetWindow, fn) {
+    const step = () => {
+        fn();
+        stepDisposable = scheduleAtNextAnimationFrame(targetWindow, step);
+    };
+    let stepDisposable = scheduleAtNextAnimationFrame(targetWindow, step);
+    return toDisposable(() => stepDisposable.dispose());
+}
+RemoteAuthorities.setPreferredWebSchema(/^https:/.test(mainWindow.location.href) ? 'https' : 'http');
+function asCSSUrl(uri) {
+    if (!uri) {
+        return `url('')`;
+    }
+    return `url('${( FileAccess.uriToBrowserUri(uri).toString(true)).replace(/'/g, '%27')}')`;
+}
+function asCSSPropertyValue(value) {
+    return `'${value.replace(/'/g, '%27')}'`;
+}
+function asCssValueWithDefault(cssPropertyValue, dflt) {
+    if (cssPropertyValue !== undefined) {
+        const variableMatch = cssPropertyValue.match(/^\s*var\((.+)\)$/);
+        if (variableMatch) {
+            const varArguments = variableMatch[1].split(',', 2);
+            if (varArguments.length === 2) {
+                dflt = asCssValueWithDefault(varArguments[1].trim(), dflt);
+            }
+            return `var(${varArguments[0]}, ${dflt})`;
+        }
+        return cssPropertyValue;
+    }
+    return dflt;
+}
+function triggerDownload(dataOrUri, name) {
+    let url;
+    if (URI.isUri(dataOrUri)) {
+        url = ( dataOrUri.toString(true));
+    }
+    else {
+        const blob = ( new Blob([dataOrUri]));
+        url = URL.createObjectURL(blob);
+        setTimeout(() => URL.revokeObjectURL(url));
+    }
+    const activeWindow = getActiveWindow();
+    const anchor = document.createElement('a');
+    activeWindow.document.body.appendChild(anchor);
+    anchor.download = name;
+    anchor.href = url;
+    anchor.click();
+    setTimeout(() => activeWindow.document.body.removeChild(anchor));
+}
+function triggerUpload() {
+    return ( new Promise(resolve => {
+        const activeWindow = getActiveWindow();
+        const input = document.createElement('input');
+        activeWindow.document.body.appendChild(input);
+        input.type = 'file';
+        input.multiple = true;
+        Event.once(Event.fromDOMEventEmitter(input, 'input'))(() => {
+            resolve(input.files ?? undefined);
+        });
+        input.click();
+        setTimeout(() => activeWindow.document.body.removeChild(input));
+    }));
+}
+function hookDomPurifyHrefAndSrcSanitizer(allowedProtocols, allowDataImages = false) {
+    const anchor = document.createElement('a');
+    addHook('afterSanitizeAttributes', (node) => {
+        for (const attr of ['href', 'src']) {
+            if (node.hasAttribute(attr)) {
+                const attrValue = node.getAttribute(attr);
+                if (attr === 'href' && attrValue.startsWith('#')) {
+                    continue;
+                }
+                anchor.href = attrValue;
+                if (!allowedProtocols.includes(anchor.protocol.replace(/:$/, ''))) {
+                    if (allowDataImages && attr === 'src' && anchor.href.startsWith('data:')) {
+                        continue;
+                    }
+                    node.removeAttribute(attr);
+                }
+            }
+        }
+    });
+    return toDisposable(() => {
+        removeHook('afterSanitizeAttributes');
+    });
+}
+const defaultSafeProtocols = [
+    Schemas.http,
+    Schemas.https,
+    Schemas.command,
+];
+const basicMarkupHtmlTags = ( Object.freeze([
+    'a',
+    'abbr',
+    'b',
+    'bdo',
+    'blockquote',
+    'br',
+    'caption',
+    'cite',
+    'code',
+    'col',
+    'colgroup',
+    'dd',
+    'del',
+    'details',
+    'dfn',
+    'div',
+    'dl',
+    'dt',
+    'em',
+    'figcaption',
+    'figure',
+    'h1',
+    'h2',
+    'h3',
+    'h4',
+    'h5',
+    'h6',
+    'hr',
+    'i',
+    'img',
+    'ins',
+    'kbd',
+    'label',
+    'li',
+    'mark',
+    'ol',
+    'p',
+    'pre',
+    'q',
+    'rp',
+    'rt',
+    'ruby',
+    'samp',
+    'small',
+    'small',
+    'source',
+    'span',
+    'strike',
+    'strong',
+    'sub',
+    'summary',
+    'sup',
+    'table',
+    'tbody',
+    'td',
+    'tfoot',
+    'th',
+    'thead',
+    'time',
+    'tr',
+    'tt',
+    'u',
+    'ul',
+    'var',
+    'video',
+    'wbr',
+]));
+const defaultDomPurifyConfig = ( Object.freeze({
+    ALLOWED_TAGS: ['a', 'button', 'blockquote', 'code', 'div', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'input', 'label', 'li', 'p', 'pre', 'select', 'small', 'span', 'strong', 'textarea', 'ul', 'ol'],
+    ALLOWED_ATTR: ['href', 'data-href', 'data-command', 'target', 'title', 'name', 'src', 'alt', 'class', 'id', 'role', 'tabindex', 'style', 'data-code', 'width', 'height', 'align', 'x-dispatch', 'required', 'checked', 'placeholder', 'type', 'start'],
+    RETURN_DOM: false,
+    RETURN_DOM_FRAGMENT: false,
+    RETURN_TRUSTED_TYPE: true
+}));
+function safeInnerHtml(node, value) {
+    const hook = hookDomPurifyHrefAndSrcSanitizer(defaultSafeProtocols);
+    try {
+        const html = sanitize(value, defaultDomPurifyConfig);
+        node.innerHTML = html;
+    }
+    finally {
+        hook.dispose();
+    }
+}
+function toBinary(str) {
+    const codeUnits = ( new Uint16Array(str.length));
+    for (let i = 0; i < codeUnits.length; i++) {
+        codeUnits[i] = str.charCodeAt(i);
+    }
+    let binary = '';
+    const uint8array = ( new Uint8Array(codeUnits.buffer));
+    for (let i = 0; i < uint8array.length; i++) {
+        binary += String.fromCharCode(uint8array[i]);
+    }
+    return binary;
+}
+function multibyteAwareBtoa(str) {
+    return btoa(toBinary(str));
+}
+class ModifierKeyEmitter extends Emitter {
+    constructor() {
+        super();
+        this._subscriptions = ( new DisposableStore());
+        this._keyStatus = {
+            altKey: false,
+            shiftKey: false,
+            ctrlKey: false,
+            metaKey: false
+        };
+        this._subscriptions.add(Event.runAndSubscribe(onDidRegisterWindow, ({ window, disposables }) => this.registerListeners(window, disposables), { window: mainWindow, disposables: this._subscriptions }));
+    }
+    registerListeners(window, disposables) {
+        disposables.add(addDisposableListener(window, 'keydown', e => {
+            if (e.defaultPrevented) {
+                return;
+            }
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.keyCode === 6  && e.repeat) {
+                return;
+            }
+            if (e.altKey && !this._keyStatus.altKey) {
+                this._keyStatus.lastKeyPressed = 'alt';
+            }
+            else if (e.ctrlKey && !this._keyStatus.ctrlKey) {
+                this._keyStatus.lastKeyPressed = 'ctrl';
+            }
+            else if (e.metaKey && !this._keyStatus.metaKey) {
+                this._keyStatus.lastKeyPressed = 'meta';
+            }
+            else if (e.shiftKey && !this._keyStatus.shiftKey) {
+                this._keyStatus.lastKeyPressed = 'shift';
+            }
+            else if (event.keyCode !== 6 ) {
+                this._keyStatus.lastKeyPressed = undefined;
+            }
+            else {
+                return;
+            }
+            this._keyStatus.altKey = e.altKey;
+            this._keyStatus.ctrlKey = e.ctrlKey;
+            this._keyStatus.metaKey = e.metaKey;
+            this._keyStatus.shiftKey = e.shiftKey;
+            if (this._keyStatus.lastKeyPressed) {
+                this._keyStatus.event = e;
+                this.fire(this._keyStatus);
+            }
+        }, true));
+        disposables.add(addDisposableListener(window, 'keyup', e => {
+            if (e.defaultPrevented) {
+                return;
+            }
+            if (!e.altKey && this._keyStatus.altKey) {
+                this._keyStatus.lastKeyReleased = 'alt';
+            }
+            else if (!e.ctrlKey && this._keyStatus.ctrlKey) {
+                this._keyStatus.lastKeyReleased = 'ctrl';
+            }
+            else if (!e.metaKey && this._keyStatus.metaKey) {
+                this._keyStatus.lastKeyReleased = 'meta';
+            }
+            else if (!e.shiftKey && this._keyStatus.shiftKey) {
+                this._keyStatus.lastKeyReleased = 'shift';
+            }
+            else {
+                this._keyStatus.lastKeyReleased = undefined;
+            }
+            if (this._keyStatus.lastKeyPressed !== this._keyStatus.lastKeyReleased) {
+                this._keyStatus.lastKeyPressed = undefined;
+            }
+            this._keyStatus.altKey = e.altKey;
+            this._keyStatus.ctrlKey = e.ctrlKey;
+            this._keyStatus.metaKey = e.metaKey;
+            this._keyStatus.shiftKey = e.shiftKey;
+            if (this._keyStatus.lastKeyReleased) {
+                this._keyStatus.event = e;
+                this.fire(this._keyStatus);
+            }
+        }, true));
+        disposables.add(addDisposableListener(window.document.body, 'mousedown', () => {
+            this._keyStatus.lastKeyPressed = undefined;
+        }, true));
+        disposables.add(addDisposableListener(window.document.body, 'mouseup', () => {
+            this._keyStatus.lastKeyPressed = undefined;
+        }, true));
+        disposables.add(addDisposableListener(window.document.body, 'mousemove', e => {
+            if (e.buttons) {
+                this._keyStatus.lastKeyPressed = undefined;
+            }
+        }, true));
+        disposables.add(addDisposableListener(window, 'blur', () => {
+            this.resetKeyStatus();
+        }));
+    }
+    get keyStatus() {
+        return this._keyStatus;
+    }
+    get isModifierPressed() {
+        return this._keyStatus.altKey || this._keyStatus.ctrlKey || this._keyStatus.metaKey || this._keyStatus.shiftKey;
+    }
+    resetKeyStatus() {
+        this.doResetKeyStatus();
+        this.fire(this._keyStatus);
+    }
+    doResetKeyStatus() {
+        this._keyStatus = {
+            altKey: false,
+            shiftKey: false,
+            ctrlKey: false,
+            metaKey: false
+        };
+    }
+    static getInstance() {
+        if (!ModifierKeyEmitter.instance) {
+            ModifierKeyEmitter.instance = ( new ModifierKeyEmitter());
+        }
+        return ModifierKeyEmitter.instance;
+    }
+    dispose() {
+        super.dispose();
+        this._subscriptions.dispose();
+    }
+}
+class DragAndDropObserver extends Disposable {
+    constructor(element, callbacks) {
+        super();
+        this.element = element;
+        this.callbacks = callbacks;
+        this.counter = 0;
+        this.dragStartTime = 0;
+        this.registerListeners();
+    }
+    registerListeners() {
+        if (this.callbacks.onDragStart) {
+            this._register(addDisposableListener(this.element, EventType.DRAG_START, (e) => {
+                this.callbacks.onDragStart?.(e);
+            }));
+        }
+        if (this.callbacks.onDrag) {
+            this._register(addDisposableListener(this.element, EventType.DRAG, (e) => {
+                this.callbacks.onDrag?.(e);
+            }));
+        }
+        this._register(addDisposableListener(this.element, EventType.DRAG_ENTER, (e) => {
+            this.counter++;
+            this.dragStartTime = e.timeStamp;
+            this.callbacks.onDragEnter?.(e);
+        }));
+        this._register(addDisposableListener(this.element, EventType.DRAG_OVER, (e) => {
+            e.preventDefault();
+            this.callbacks.onDragOver?.(e, e.timeStamp - this.dragStartTime);
+        }));
+        this._register(addDisposableListener(this.element, EventType.DRAG_LEAVE, (e) => {
+            this.counter--;
+            if (this.counter === 0) {
+                this.dragStartTime = 0;
+                this.callbacks.onDragLeave?.(e);
+            }
+        }));
+        this._register(addDisposableListener(this.element, EventType.DRAG_END, (e) => {
+            this.counter = 0;
+            this.dragStartTime = 0;
+            this.callbacks.onDragEnd?.(e);
+        }));
+        this._register(addDisposableListener(this.element, EventType.DROP, (e) => {
+            this.counter = 0;
+            this.dragStartTime = 0;
+            this.callbacks.onDrop?.(e);
+        }));
+    }
+}
+const H_REGEX = /(?<tag>[\w\-]+)?(?:#(?<id>[\w\-]+))?(?<class>(?:\.(?:[\w\-]+))*)(?:@(?<name>(?:[\w\_])+))?/;
+function h(tag, ...args) {
+    let attributes;
+    let children;
+    if (Array.isArray(args[0])) {
+        attributes = {};
+        children = args[0];
+    }
+    else {
+        attributes = args[0] || {};
+        children = args[1];
+    }
+    const match = H_REGEX.exec(tag);
+    if (!match || !match.groups) {
+        throw new Error('Bad use of h');
+    }
+    const tagName = match.groups['tag'] || 'div';
+    const el = document.createElement(tagName);
+    if (match.groups['id']) {
+        el.id = match.groups['id'];
+    }
+    const classNames = [];
+    if (match.groups['class']) {
+        for (const className of match.groups['class'].split('.')) {
+            if (className !== '') {
+                classNames.push(className);
+            }
+        }
+    }
+    if (attributes.className !== undefined) {
+        for (const className of attributes.className.split('.')) {
+            if (className !== '') {
+                classNames.push(className);
+            }
+        }
+    }
+    if (classNames.length > 0) {
+        el.className = classNames.join(' ');
+    }
+    const result = {};
+    if (match.groups['name']) {
+        result[match.groups['name']] = el;
+    }
+    if (children) {
+        for (const c of children) {
+            if (c instanceof HTMLElement) {
+                el.appendChild(c);
+            }
+            else if (typeof c === 'string') {
+                el.append(c);
+            }
+            else if ('root' in c) {
+                Object.assign(result, c);
+                el.appendChild(c.root);
+            }
+        }
+    }
+    for (const [key, value] of Object.entries(attributes)) {
+        if (key === 'className') {
+            continue;
+        }
+        else if (key === 'style') {
+            for (const [cssKey, cssValue] of Object.entries(value)) {
+                el.style.setProperty(camelCaseToHyphenCase(cssKey), typeof cssValue === 'number' ? cssValue + 'px' : '' + cssValue);
+            }
+        }
+        else if (key === 'tabIndex') {
+            el.tabIndex = value;
+        }
+        else {
+            el.setAttribute(camelCaseToHyphenCase(key), ( value.toString()));
+        }
+    }
+    result['root'] = el;
+    return result;
+}
+function camelCaseToHyphenCase(str) {
+    return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+}
+function copyAttributes(from, to) {
+    for (const { name, value } of from.attributes) {
+        to.setAttribute(name, value);
+    }
+}
+function copyAttribute(from, to, name) {
+    const value = from.getAttribute(name);
+    if (value) {
+        to.setAttribute(name, value);
+    }
+    else {
+        to.removeAttribute(name);
+    }
+}
+function trackAttributes(from, to, filter) {
+    copyAttributes(from, to);
+    const disposables = ( new DisposableStore());
+    disposables.add(sharedMutationObserver.observe(from, disposables, { attributes: true, attributeFilter: filter })(mutations => {
+        for (const mutation of mutations) {
+            if (mutation.type === 'attributes' && mutation.attributeName) {
+                copyAttribute(from, to, mutation.attributeName);
+            }
+        }
+    }));
+    return disposables;
+}
+export { $, Dimension, DragAndDropObserver, EventHelper, EventType, ModifierKeyEmitter, Namespace, WindowIdleValue, WindowIntervalTimer, addDisposableGenericMouseDownListener, addDisposableGenericMouseUpListener, addDisposableListener, addStandardDisposableGenericMouseDownListener, addStandardDisposableGenericMouseUpListener, addStandardDisposableListener, after, animate, append, asCSSPropertyValue, asCSSUrl, asCssValueWithDefault, basicMarkupHtmlTags, clearNode, cloneGlobalStylesheets, computeScreenAwareSize, copyAttributes, createCSSRule, createMetaElement, createStyleSheet, disposableWindowInterval, finalHandler, findParentWithClass, focusWindow, getActiveDocument, getActiveElement, getActiveWindow, getClientArea, getComputedStyle, getContentHeight, getContentWidth, getDocument, getDomNodePagePosition, getDomNodeZoomLevel, getLargestChildWidth, getShadowRoot, getTopLeftOffset, getTotalHeight, getTotalScrollWidth, getTotalWidth, getWindow, getWindowById, getWindowId, getWindows, getWindowsCount, h, hasParentWithClass, hasWindow, hide, hookDomPurifyHrefAndSrcSanitizer, isActiveDocument, isActiveElement, isAncestor, isAncestorOfActiveElement, isAncestorUsingFlowTo, isDragEvent, isEventLike, isGlobalStylesheet, isInShadowDOM, isKeyboardEvent, isMouseEvent, isPointerEvent, isShadowRoot, join, measure, modify, multibyteAwareBtoa, onDidRegisterWindow, onDidUnregisterWindow, onWillUnregisterWindow, position, prepend, registerWindow, removeCSSRulesContainingSelector, reset, restoreParentsScrollTop, runAtThisOrScheduleAtNextAnimationFrame, runWhenWindowIdle, safeInnerHtml, saveParentsScrollTop, scheduleAtNextAnimationFrame, setParentFlowTo, setVisibility, sharedMutationObserver, show, size, trackAttributes, trackFocus, triggerDownload, triggerUpload, windowOpenNoOpener };