@kritzel/editor 0.4.31

package/dist/components/p-B3Tqoyl9.js

@@ -0,0 +1,43 @@
+import { p as proxyCustomElement, H, h, d as Host, t as transformTag } from './p-5qkOM1RJ.js';
+
+const kritzelLoadingOverlayCss = () => `:host{position:absolute;inset:0;z-index:var(--kritzel-editor-loading-overlay-z-index, 1);display:block;pointer-events:none}.loading-overlay{position:absolute;inset:0;z-index:0;display:flex;align-items:center;justify-content:center;gap:10px;background-color:var(--kritzel-editor-loading-overlay-background, rgba(255, 255, 255, 0.6));color:var(--kritzel-editor-loading-overlay-color, #333);font-family:var(--kritzel-font-family, sans-serif);font-size:1.25rem;opacity:0;pointer-events:none;visibility:hidden;transition:opacity 300ms ease,      visibility 0s linear 300ms}.loading-overlay.visible{opacity:1;pointer-events:all;visibility:visible;transition:opacity 300ms ease,      visibility 0s linear 0s}.loading-spinner{width:20px;height:20px;box-sizing:border-box;display:block;flex-shrink:0;border:2px solid var(--kritzel-editor-loading-overlay-spinner-color, #cccccc);border-top-color:var(--kritzel-editor-loading-overlay-spinner-active-color, #333333);border-radius:50%;animation:kritzel-loading-spin 0.6s linear infinite}@keyframes kritzel-loading-spin{to{transform:rotate(360deg)}}`;
+
+const KritzelLoadingOverlay = /*@__PURE__*/ proxyCustomElement(class KritzelLoadingOverlay extends H {
+    constructor(registerHost) {
+        super();
+        if (registerHost !== false) {
+            this.__registerHost();
+        }
+        this.__attachShadow();
+    }
+    /**
+     * Whether the overlay is visible
+     */
+    visible = false;
+    /**
+     * The text to display next to the spinner
+     */
+    text = 'Loading...';
+    render() {
+        return (h(Host, { key: '9db6a5b128b4ba9e4e196e0bf9fff6b7853ef7c9' }, h("div", { key: 'e113ed032c0c7349b6e452d5c12d9ffb42d2dbb7', class: { 'loading-overlay': true, visible: this.visible }, "aria-hidden": this.visible ? 'false' : 'true' }, h("span", { key: '55a601348ab9269125cb2043fb6e568ce8fe6b44', class: "loading-spinner" }), this.text)));
+    }
+    static get style() { return kritzelLoadingOverlayCss(); }
+}, [513, "kritzel-loading-overlay", {
+        "visible": [4],
+        "text": [1]
+    }]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["kritzel-loading-overlay"];
+    components.forEach(tagName => { switch (tagName) {
+        case "kritzel-loading-overlay":
+            if (!customElements.get(transformTag(tagName))) {
+                customElements.define(transformTag(tagName), KritzelLoadingOverlay);
+            }
+            break;
+    } });
+}
+
+export { KritzelLoadingOverlay as K, defineCustomElement as d };

package/dist/components/p-B5xYV1o3.js

@@ -0,0 +1,77 @@
+import { p as proxyCustomElement, H, c as createEvent, h, d as Host, t as transformTag } from './p-5qkOM1RJ.js';
+
+const kritzelInputCss = () => `:host{display:block}.input-container{display:flex;flex-direction:column;gap:6px}.input-label{font-size:14px;font-weight:500;color:var(--kritzel-text-input-label-color, #333333)}.input-wrapper{display:flex;align-items:center;border:1px solid var(--kritzel-text-input-border-color, #ebebeb);border-radius:var(--kritzel-text-input-border-radius, 6px);overflow:hidden;background:var(--kritzel-text-input-background, #ffffff);transition:border-color 150ms ease}.input-wrapper:hover:not(:focus-within){border-color:var(--kritzel-text-input-hover-border-color, #cccccc)}.input-wrapper:focus-within{border-color:var(--kritzel-text-input-focus-border-color, #007AFF);border-width:2px}.text-input{flex:1;padding:10px 12px;border:none;outline:none;font-size:14px;font-family:inherit;background:transparent;color:var(--kritzel-text-input-text-color, #333333);box-sizing:border-box}.text-input::placeholder{color:var(--kritzel-text-input-placeholder-color, #999999)}.text-input::selection{background-color:var(--kritzel-text-input-selection-background, #007AFF);color:var(--kritzel-text-input-selection-color, #ffffff)}.text-input:disabled{cursor:not-allowed;opacity:0.6}.input-suffix{padding:10px 12px;background:var(--kritzel-text-input-suffix-background, #f5f5f5);color:var(--kritzel-text-input-suffix-color, #666666);font-size:14px;border-left:1px solid var(--kritzel-text-input-border-color, #ebebeb);flex-shrink:0}`;
+
+const KritzelInput = /*@__PURE__*/ proxyCustomElement(class KritzelInput extends H {
+    constructor(registerHost) {
+        super();
+        if (registerHost !== false) {
+            this.__registerHost();
+        }
+        this.__attachShadow();
+        this.valueChange = createEvent(this, "valueChange");
+    }
+    /** Current text value */
+    value = '';
+    /** Label text displayed above the input */
+    label = '';
+    /** Placeholder text shown when input is empty */
+    placeholder = '';
+    /** Suffix text displayed after the input (e.g., file extension) */
+    suffix = '';
+    /** Input type */
+    type = 'text';
+    /** Whether the input is disabled */
+    disabled = false;
+    /** Emitted when the value changes */
+    valueChange;
+    inputValue = '';
+    onValueChange(newValue) {
+        this.inputValue = newValue ?? '';
+    }
+    componentWillLoad() {
+        this.inputValue = this.value ?? '';
+    }
+    handleInput = (event) => {
+        const input = event.target;
+        this.inputValue = input.value;
+        this.value = input.value;
+        this.valueChange.emit(input.value);
+    };
+    render() {
+        return (h(Host, { key: '27ea9df44ddfe332bfda4f8b70308ffbfbf3e63c' }, h("div", { key: '8970766380273b32d0c8ffc32310e95d34b5ed35', class: "input-container" }, this.label && h("label", { key: '7b05115cd7eac552d8b420a10c0039b48b100f55', class: "input-label" }, this.label), h("div", { key: '5c764a97dada35dd74cce61a43dd39edcca07c5d', class: { 'input-wrapper': true, 'has-suffix': !!this.suffix } }, h("input", { key: '4613cba3f6ba722c641c9f2d355fe4b9c9f795f2', type: this.type, class: "text-input", value: this.inputValue, placeholder: this.placeholder, disabled: this.disabled, onInput: this.handleInput }), this.suffix && h("span", { key: '3b4942c5cd0298d97b0c3e8e86c82297f1134718', class: "input-suffix" }, this.suffix)))));
+    }
+    static get watchers() { return {
+        "value": [{
+                "onValueChange": 0
+            }]
+    }; }
+    static get style() { return kritzelInputCss(); }
+}, [513, "kritzel-input", {
+        "value": [1025],
+        "label": [1],
+        "placeholder": [1],
+        "suffix": [1],
+        "type": [1],
+        "disabled": [4],
+        "inputValue": [32]
+    }, undefined, {
+        "value": [{
+                "onValueChange": 0
+            }]
+    }]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["kritzel-input"];
+    components.forEach(tagName => { switch (tagName) {
+        case "kritzel-input":
+            if (!customElements.get(transformTag(tagName))) {
+                customElements.define(transformTag(tagName), KritzelInput);
+            }
+            break;
+    } });
+}
+
+export { KritzelInput as K, defineCustomElement as d };

package/dist/components/p-B6UJztrf.js

@@ -0,0 +1,290 @@
+import { p as proxyCustomElement, H, c as createEvent, h, d as Host, t as transformTag } from './p-5qkOM1RJ.js';
+import { d as defineCustomElement$1 } from './p-BGmTmdLe.js';
+
+const kritzelContextMenuCss = () => `:host{display:block}.menu-container{position:relative;z-index:1;display:flex;flex-direction:column;gap:var(--kritzel-context-menu-item-spacing, 2px);background-color:var(--kritzel-context-menu-background-color, #ffffff);border-radius:var(--kritzel-context-menu-border-radius, 12px);box-shadow:var(--kritzel-context-menu-box-shadow, 0 1px 6px rgba(0, 0, 0, 0.12));border:var(--kritzel-context-menu-border, 1px solid #ebebeb);padding:var(--kritzel-context-menu-padding, 4px);min-width:var(--kritzel-context-menu-min-width, 140px)}.menu-item-wrapper{position:relative}.menu-item{display:flex;align-items:center;gap:var(--kritzel-context-menu-item-gap, 8px);background:none;border:none;text-align:left;padding:var(--kritzel-context-menu-item-padding, 8px);border-radius:var(--kritzel-context-menu-item-border-radius, 12px);cursor:var(--kritzel-global-pointer-cursor, pointer);font-size:var(--kritzel-context-menu-item-font-size, 14px);color:var(--kritzel-context-menu-item-color, #333333);white-space:nowrap;-webkit-tap-highlight-color:transparent;width:100%;min-width:0}.menu-item:not(.disabled):hover,.menu-item.submenu-open{background-color:var(--kritzel-context-menu-item-hover-background-color, hsl(0, 0%, 0%, 4.3%))}.menu-item:not(.disabled):active{background-color:var(--kritzel-context-menu-item-active-background-color, hsl(0, 0%, 0%, 8.6%))}.menu-item.disabled{color:var(--kritzel-context-menu-item-disabled-color, #aaaaaa)}.menu-item.has-children.disabled{cursor:var(--kritzel-global-pointer-cursor, pointer);color:var(--kritzel-context-menu-item-color, #333333)}.menu-item kritzel-icon{opacity:0.8;flex-shrink:0}.menu-item.disabled kritzel-icon{opacity:0.4}.menu-item.has-children.disabled kritzel-icon{opacity:0.8}.label{flex-grow:1;min-width:0;overflow:hidden;text-overflow:ellipsis}.submenu-arrow{margin-left:auto;opacity:0.5}.menu-divider{height:1px;background-color:var(--kritzel-context-menu-divider-color, rgba(0, 0, 0, 0.1));margin:var(--kritzel-context-menu-divider-margin, 4px 8px)}.submenu-container{position:absolute;top:0;left:100%;z-index:2;margin-left:4px;display:flex;flex-direction:column;gap:var(--kritzel-context-menu-item-spacing, 2px);background-color:var(--kritzel-context-menu-background-color, #ffffff);border-radius:var(--kritzel-context-menu-border-radius, 12px);box-shadow:var(--kritzel-context-menu-box-shadow, 0 1px 6px rgba(0, 0, 0, 0.12));border:var(--kritzel-context-menu-border, 1px solid #ebebeb);padding:var(--kritzel-context-menu-padding, 4px);min-width:120px}.submenu-container.position-left{left:auto;right:100%;margin-left:0;margin-right:4px}`;
+
+const VIEWPORT_PADDING = 8;
+const SUBMENU_DELAY = 150;
+const ESTIMATED_SUBMENU_WIDTH = 160; // Estimated width for pre-calculation
+const KritzelContextMenu = /*@__PURE__*/ proxyCustomElement(class KritzelContextMenu extends H {
+    constructor(registerHost) {
+        super();
+        if (registerHost !== false) {
+            this.__registerHost();
+        }
+        this.__attachShadow();
+        this.actionSelected = createEvent(this, "actionSelected");
+        this.close = createEvent(this, "close");
+    }
+    get host() { return this; }
+    items;
+    onItemsChanged() {
+        this.updateMenuItems();
+    }
+    objects;
+    actionSelected;
+    close;
+    processedItems = [];
+    /** Current open submenu path (e.g. '0.2.1'). Empty if none. */
+    openSubmenuPath = '';
+    submenuPositions = {};
+    submenuTimer = null;
+    submenuRefs = new Map();
+    menuItemWrapperRefs = new Map();
+    handleOutsideClick(event) {
+        const path = event.composedPath();
+        if (!path.includes(this.host)) {
+            this.close.emit();
+        }
+    }
+    componentWillLoad() {
+        this.updateMenuItems();
+    }
+    componentDidLoad() {
+        this.adjustPositionToViewport();
+    }
+    componentDidUpdate() {
+        this.adjustPositionToViewport();
+        this.adjustSubmenuPositions();
+        this.pruneStaleRefs();
+    }
+    disconnectedCallback() {
+        if (this.submenuTimer) {
+            clearTimeout(this.submenuTimer);
+        }
+    }
+    adjustPositionToViewport() {
+        const rect = this.host.getBoundingClientRect();
+        const viewportWidth = window.innerWidth;
+        const viewportHeight = window.innerHeight;
+        const currentLeft = parseFloat(this.host.style.left) || 0;
+        const currentTop = parseFloat(this.host.style.top) || 0;
+        let newLeft = currentLeft;
+        let newTop = currentTop;
+        // Check if menu extends beyond right edge
+        if (rect.right > viewportWidth - VIEWPORT_PADDING) {
+            newLeft = viewportWidth - rect.width - VIEWPORT_PADDING;
+        }
+        // Check if menu extends beyond bottom edge
+        if (rect.bottom > viewportHeight - VIEWPORT_PADDING) {
+            newTop = viewportHeight - rect.height - VIEWPORT_PADDING;
+        }
+        // Ensure menu doesn't go beyond left edge
+        if (newLeft < VIEWPORT_PADDING) {
+            newLeft = VIEWPORT_PADDING;
+        }
+        // Ensure menu doesn't go beyond top edge
+        if (newTop < VIEWPORT_PADDING) {
+            newTop = VIEWPORT_PADDING;
+        }
+        // Only update if position changed to avoid infinite loops
+        if (newLeft !== currentLeft || newTop !== currentTop) {
+            this.host.style.left = `${newLeft}px`;
+            this.host.style.top = `${newTop}px`;
+        }
+    }
+    adjustSubmenuPositions() {
+        if (!this.openSubmenuPath)
+            return;
+        const viewportHeight = window.innerHeight;
+        // Adjust every open submenu in the chain (every prefix of openSubmenuPath).
+        for (const path of this.getOpenSubmenuPaths()) {
+            const submenuEl = this.submenuRefs.get(path);
+            const wrapperEl = this.menuItemWrapperRefs.get(path);
+            if (!submenuEl || !wrapperEl)
+                continue;
+            const wrapperRect = wrapperEl.getBoundingClientRect();
+            const submenuHeight = submenuEl.offsetHeight; // Constant regardless of current top shift
+            const naturalBottom = wrapperRect.top + submenuHeight;
+            if (naturalBottom > viewportHeight - VIEWPORT_PADDING) {
+                let overflow = naturalBottom - (viewportHeight - VIEWPORT_PADDING);
+                // Don't shift up so far that the top goes above the viewport
+                if (wrapperRect.top - overflow < VIEWPORT_PADDING) {
+                    overflow = wrapperRect.top - VIEWPORT_PADDING;
+                }
+                submenuEl.style.top = `${-overflow}px`;
+            }
+            else {
+                submenuEl.style.top = '0px';
+            }
+        }
+    }
+    getOpenSubmenuPaths() {
+        if (!this.openSubmenuPath)
+            return [];
+        const parts = this.openSubmenuPath.split('.');
+        const paths = [];
+        for (let i = 1; i <= parts.length; i++) {
+            paths.push(parts.slice(0, i).join('.'));
+        }
+        return paths;
+    }
+    isSubmenuOpen(path) {
+        return this.openSubmenuPath === path || this.openSubmenuPath.startsWith(path + '.');
+    }
+    getParentPath(path) {
+        const idx = path.lastIndexOf('.');
+        return idx === -1 ? '' : path.substring(0, idx);
+    }
+    getMenuDepth(path) {
+        if (!path)
+            return 0;
+        return path.split('.').length;
+    }
+    pruneStaleRefs() {
+        const openPaths = new Set(this.getOpenSubmenuPaths());
+        for (const key of Array.from(this.submenuRefs.keys())) {
+            if (!openPaths.has(key)) {
+                this.submenuRefs.delete(key);
+            }
+        }
+        // Keep root-level wrapper refs (single-segment paths) always rendered; prune deeper
+        // wrappers whose parent submenu is no longer open.
+        for (const key of Array.from(this.menuItemWrapperRefs.keys())) {
+            const parent = this.getParentPath(key);
+            if (parent !== '' && !openPaths.has(parent)) {
+                this.menuItemWrapperRefs.delete(key);
+            }
+        }
+    }
+    handleItemClick(item, isDisabled, hasChildren) {
+        if (isDisabled)
+            return;
+        if (hasChildren) {
+            // Hover handles open/close; click on a parent is a no-op.
+            return;
+        }
+        if (item.action) {
+            this.actionSelected.emit(item);
+        }
+    }
+    handleItemMouseEnter(path, hasChildren) {
+        if (this.submenuTimer) {
+            clearTimeout(this.submenuTimer);
+            this.submenuTimer = null;
+        }
+        const parentPath = this.getParentPath(path);
+        if (hasChildren) {
+            this.submenuTimer = setTimeout(() => {
+                // Pre-calculate horizontal position before opening to avoid flicker.
+                const wrapperEl = this.menuItemWrapperRefs.get(path);
+                let position = 'right';
+                if (wrapperEl) {
+                    const rect = wrapperEl.getBoundingClientRect();
+                    const viewportWidth = window.innerWidth;
+                    const wouldOverflowRight = rect.right + ESTIMATED_SUBMENU_WIDTH > viewportWidth - VIEWPORT_PADDING;
+                    position = wouldOverflowRight ? 'left' : 'right';
+                }
+                this.submenuPositions = { ...this.submenuPositions, [path]: position };
+                this.openSubmenuPath = path;
+            }, SUBMENU_DELAY);
+        }
+        else {
+            // Hovering a sibling without children: collapse to the parent chain so any
+            // sibling-rooted submenu closes, but the ancestor chain stays open.
+            this.submenuTimer = setTimeout(() => {
+                this.openSubmenuPath = parentPath;
+            }, SUBMENU_DELAY);
+        }
+    }
+    handleSubmenuMouseEnter() {
+        if (this.submenuTimer) {
+            clearTimeout(this.submenuTimer);
+            this.submenuTimer = null;
+        }
+    }
+    handleSubmenuMouseLeave(path) {
+        // Close this submenu (and any deeper levels) but keep the ancestor chain open.
+        const parentPath = this.getParentPath(path);
+        this.submenuTimer = setTimeout(() => {
+            this.openSubmenuPath = parentPath;
+        }, SUBMENU_DELAY);
+    }
+    async updateMenuItems() {
+        this.processedItems = await this.processItems(this.items);
+    }
+    async processItems(items) {
+        const processed = [];
+        for (const item of items) {
+            const isVisible = await this.evaluateProperty(item.isVisible, true);
+            if (isVisible) {
+                const isDisabled = await this.evaluateProperty(item.isDisabled, false);
+                let processedChildren;
+                if (item.children && item.children.length > 0) {
+                    processedChildren = await this.processItems(item.children);
+                }
+                processed.push({ item, isDisabled, processedChildren });
+            }
+        }
+        return processed;
+    }
+    async evaluateProperty(value, defaultValue) {
+        if (typeof value === 'boolean') {
+            return value;
+        }
+        if (typeof value === 'function') {
+            return await Promise.resolve(value(null, this.objects));
+        }
+        return defaultValue;
+    }
+    renderItems(items, parentPath) {
+        return items.map(({ item, isDisabled, processedChildren }, index) => {
+            const path = parentPath === '' ? String(index) : `${parentPath}.${index}`;
+            const prevItem = index > 0 ? items[index - 1].item : null;
+            const showDivider = prevItem && prevItem.group !== item.group;
+            const hasChildren = !!processedChildren && processedChildren.length > 0;
+            const submenuOpen = hasChildren && this.isSubmenuOpen(path);
+            return [
+                showDivider && h("div", { class: "menu-divider", key: `divider-${path}` }),
+                h("div", { class: "menu-item-wrapper", key: `wrapper-${path}`, ref: el => el && this.menuItemWrapperRefs.set(path, el), onMouseEnter: () => this.handleItemMouseEnter(path, hasChildren) }, h("button", { key: `${item.label}-${path}`, class: { 'menu-item': true, 'disabled': isDisabled, 'has-children': hasChildren, 'submenu-open': submenuOpen }, onClick: () => this.handleItemClick(item, isDisabled, hasChildren), disabled: isDisabled && !hasChildren }, item.icon && h("kritzel-icon", { name: item.icon, size: 16 }), h("span", { class: "label" }, item.label), hasChildren && h("kritzel-icon", { name: "chevron-right", size: 12, class: "submenu-arrow" })), hasChildren && submenuOpen && this.renderSubmenu(processedChildren, path)),
+            ];
+        });
+    }
+    renderSubmenu(processedChildren, path) {
+        const position = this.submenuPositions[path] === 'left' ? 'left' : 'right';
+        const zIndex = this.getMenuDepth(path) + 1;
+        return (h("div", { class: { 'submenu-container': true, 'position-left': position === 'left' }, key: `submenu-${path}`, style: { zIndex: String(zIndex) }, ref: el => el && this.submenuRefs.set(path, el), onMouseEnter: () => this.handleSubmenuMouseEnter(), onMouseLeave: () => this.handleSubmenuMouseLeave(path) }, this.renderItems(processedChildren, path)));
+    }
+    render() {
+        if (!this.processedItems || this.processedItems.length === 0) {
+            return null;
+        }
+        return (h(Host, null, h("div", { class: "menu-container" }, this.renderItems(this.processedItems, ''))));
+    }
+    static get watchers() { return {
+        "items": [{
+                "onItemsChanged": 0
+            }]
+    }; }
+    static get style() { return kritzelContextMenuCss(); }
+}, [513, "kritzel-context-menu", {
+        "items": [16],
+        "objects": [16],
+        "processedItems": [32],
+        "openSubmenuPath": [32],
+        "submenuPositions": [32]
+    }, [[9, "pointerdown", "handleOutsideClick"]], {
+        "items": [{
+                "onItemsChanged": 0
+            }]
+    }]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["kritzel-context-menu", "kritzel-icon"];
+    components.forEach(tagName => { switch (tagName) {
+        case "kritzel-context-menu":
+            if (!customElements.get(transformTag(tagName))) {
+                customElements.define(transformTag(tagName), KritzelContextMenu);
+            }
+            break;
+        case "kritzel-icon":
+            if (!customElements.get(transformTag(tagName))) {
+                defineCustomElement$1();
+            }
+            break;
+    } });
+}
+
+export { KritzelContextMenu as K, defineCustomElement as d };

package/dist/components/p-BDjRSoAc.js

@@ -0,0 +1,43 @@
+import { p as proxyCustomElement, H, h, d as Host, t as transformTag } from './p-5qkOM1RJ.js';
+
+const kritzelFontCss = () => `:host{display:block}.font-preview{color:var(--kritzel-font-size-text-color, #333333);line-height:1;text-align:center;font-weight:bold}`;
+
+const KritzelFont = /*@__PURE__*/ proxyCustomElement(class KritzelFont extends H {
+    constructor(registerHost) {
+        super();
+        if (registerHost !== false) {
+            this.__registerHost();
+        }
+        this.__attachShadow();
+    }
+    fontFamily = 'Arial, sans-serif';
+    size = 24;
+    color = '#000000';
+    render() {
+        return (h(Host, { key: 'b594153b199a9ed859b0b74dccaa8f242f6e388d' }, h("div", { key: 'f1888af3f0342a38c3d5a887ef66adef63b35a87', class: "font-preview", style: {
+                fontFamily: this.fontFamily,
+                fontSize: `${this.size}px`,
+                color: this.color
+            } }, "A")));
+    }
+    static get style() { return kritzelFontCss(); }
+}, [513, "kritzel-font", {
+        "fontFamily": [1, "font-family"],
+        "size": [2],
+        "color": [1]
+    }]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["kritzel-font"];
+    components.forEach(tagName => { switch (tagName) {
+        case "kritzel-font":
+            if (!customElements.get(transformTag(tagName))) {
+                customElements.define(transformTag(tagName), KritzelFont);
+            }
+            break;
+    } });
+}
+
+export { KritzelFont as K, defineCustomElement as d };

package/dist/components/p-BFTU3MAI.js

@@ -0,0 +1,7 @@
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+export { commonjsGlobal as c, getDefaultExportFromCjs as g };