@kritzel/editor 0.4.31

package/dist/components/p-CmjXRLdr.js

@@ -0,0 +1,220 @@
+import { p as proxyCustomElement, H, c as createEvent, h, d as Host, t as transformTag } from './p-5qkOM1RJ.js';
+import { KritzelWorkspace } from '@kritzel/engine';
+import { d as defineCustomElement$5 } from './p-BGmTmdLe.js';
+import { d as defineCustomElement$4 } from './p-DqOC_Yck.js';
+import { d as defineCustomElement$3 } from './p-BN8VWPlq.js';
+import { d as defineCustomElement$2 } from './p-CS3YZVYE.js';
+import { d as defineCustomElement$1 } from './p-kOINnzaR.js';
+
+const kritzelWorkspaceManagerCss = () => `:host{display:flex;flex-direction:column;z-index:1}.manager{opacity:0;pointer-events:none;transition:opacity 0.2s ease-out}.manager.visible{opacity:1;pointer-events:auto}`;
+
+const KritzelWorkspaceManager = /*@__PURE__*/ proxyCustomElement(class KritzelWorkspaceManager extends H {
+    constructor(registerHost) {
+        super();
+        if (registerHost !== false) {
+            this.__registerHost();
+        }
+        this.__attachShadow();
+        this.isWorkspaceManagerReady = createEvent(this, "isWorkspaceManagerReady");
+        this.workspaceChange = createEvent(this, "workspaceChange");
+    }
+    get host() { return this; }
+    /**
+     * Whether the workspace manager is visible
+     */
+    visible = false;
+    activeWorkspace;
+    workspaces = [];
+    /** Resolved localized strings keyed by term key, supplied by the editor. */
+    terms = {};
+    isWorkspaceManagerReady;
+    workspaceChange;
+    childMenuAnchor = null;
+    openChildMenuItem = null;
+    newWorkspace = null;
+    editingItemId = null;
+    handleWheel(event) {
+        if (event.ctrlKey) {
+            event.preventDefault();
+        }
+    }
+    kritzelEngineRef = null;
+    splitButtonRef;
+    get sortedWorkspaces() {
+        return [this.newWorkspace, ...this.workspaces].filter(ws => ws != null).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    }
+    async componentWillLoad() {
+        await this.initializeEngine();
+        this.isWorkspaceManagerReady.emit();
+    }
+    async open() {
+        if (!this.visible) {
+            return;
+        }
+        await this.splitButtonRef?.open();
+    }
+    async close() {
+        await this.splitButtonRef?.close();
+    }
+    async initializeEngine() {
+        await customElements.whenDefined('kritzel-engine');
+        // Search for kritzel-engine in the closest kritzel-editor ancestor
+        const editor = this.host.closest('kritzel-editor');
+        this.kritzelEngineRef = editor?.querySelector('kritzel-engine') ?? null;
+        if (!this.kritzelEngineRef) {
+            console.warn('kritzel-engine not found in kritzel-editor.');
+        }
+    }
+    async select(item, parent) {
+        if (this.editingItemId) {
+            return;
+        }
+        if (item.action) {
+            item.action(item, parent);
+            return;
+        }
+        this.workspaceChange.emit(item.value);
+    }
+    async add() {
+        await this.splitButtonRef.open();
+        this.newWorkspace = new KritzelWorkspace({ name: 'New Workspace' });
+        this.editingItemId = this.newWorkspace.id;
+    }
+    edit(item) {
+        this.openChildMenuItem = null;
+        this.childMenuAnchor = null;
+        requestAnimationFrame(() => {
+            this.editingItemId = item.id;
+        });
+    }
+    async save(item) {
+        if (this.newWorkspace) {
+            this.newWorkspace.name = item.label;
+            await this.kritzelEngineRef?.createWorkspace(this.newWorkspace);
+            this.workspaceChange.emit(this.newWorkspace);
+        }
+        else {
+            const workspace = item.value;
+            workspace.name = item.label;
+            await this.kritzelEngineRef?.updateWorkspace(workspace);
+        }
+        this.editingItemId = null;
+        this.newWorkspace = null;
+    }
+    cancel() {
+        this.newWorkspace = null;
+        this.editingItemId = null;
+    }
+    async delete(item) {
+        this.openChildMenuItem = null;
+        this.childMenuAnchor = null;
+        await this.kritzelEngineRef?.deleteWorkspace(item.value);
+        if (item.value.id === this.activeWorkspace?.id) {
+            this.activeWorkspace = this.sortedWorkspaces.find(ws => ws.id !== item.value.id) || null;
+            this.workspaceChange.emit(this.activeWorkspace);
+        }
+        await this.splitButtonRef.focusMenu();
+    }
+    toggleChildMenu(item, anchor) {
+        this.openChildMenuItem = item;
+        this.childMenuAnchor = anchor;
+    }
+    closeChildMenu() {
+        this.openChildMenuItem = null;
+        this.childMenuAnchor = null;
+    }
+    handleMenuOpen() {
+        // Menu open - engine remains interactive
+    }
+    handleMenuClose() {
+        this.cancel();
+        this.closeChildMenu();
+    }
+    render() {
+        const menuItems = this.sortedWorkspaces
+            .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())
+            .filter(ws => ws !== null)
+            .map(ws => {
+            return {
+                id: ws.id,
+                label: ws.name,
+                icon: ws.isPublic ? 'users-round' : undefined,
+                iconTooltip: ws.isPublic ? (this.terms['workspace.sharedTooltip'] ?? 'Shared workspace') : undefined,
+                value: ws,
+                isEditing: this.editingItemId === ws.id,
+                isSelected: this.activeWorkspace?.id === ws.id,
+                isNewItem: this.newWorkspace?.id === ws.id,
+                isChildMenuOpen: this.openChildMenuItem?.id === ws.id,
+                childMenuAnchor: this.openChildMenuItem?.id === ws.id ? this.childMenuAnchor : null,
+                children: [
+                    {
+                        id: `${ws.id}-rename`,
+                        label: this.terms['workspace.rename'] ?? 'Rename',
+                        value: 'rename',
+                        action: (_item, parent) => this.edit(parent),
+                    },
+                    {
+                        id: `${ws.id}-delete`,
+                        label: this.terms['workspace.delete'] ?? 'Delete',
+                        value: 'delete',
+                        isDisabled: this.sortedWorkspaces.length <= 1,
+                        action: (_item, parent) => this.delete(parent),
+                    },
+                ],
+            };
+        });
+        return (h(Host, { style: { display: this.visible ? '' : 'none' } }, h("div", { class: { manager: true, visible: this.visible } }, h("kritzel-split-button", { ref: el => (this.splitButtonRef = el), items: menuItems, mainButtonDisabled: this.editingItemId != null, onMainButtonClick: () => this.add(), onItemSelect: event => this.select(event.detail.item, event.detail.parent), onItemToggleChildMenu: event => this.toggleChildMenu(event.detail.item, event.detail.childMenuAnchor), onItemSave: event => this.save(event.detail), onItemCancel: () => this.cancel(), onItemCloseChildMenu: () => this.closeChildMenu(), onMenuOpen: () => this.handleMenuOpen(), onMenuClose: () => this.handleMenuClose() }))));
+    }
+    static get style() { return kritzelWorkspaceManagerCss(); }
+}, [513, "kritzel-workspace-manager", {
+        "visible": [4],
+        "activeWorkspace": [1040],
+        "workspaces": [16],
+        "terms": [16],
+        "childMenuAnchor": [32],
+        "openChildMenuItem": [32],
+        "newWorkspace": [32],
+        "editingItemId": [32],
+        "open": [64],
+        "close": [64]
+    }, [[8, "wheel", "handleWheel"]]]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["kritzel-workspace-manager", "kritzel-icon", "kritzel-menu", "kritzel-menu-item", "kritzel-portal", "kritzel-split-button"];
+    components.forEach(tagName => { switch (tagName) {
+        case "kritzel-workspace-manager":
+            if (!customElements.get(transformTag(tagName))) {
+                customElements.define(transformTag(tagName), KritzelWorkspaceManager);
+            }
+            break;
+        case "kritzel-icon":
+            if (!customElements.get(transformTag(tagName))) {
+                defineCustomElement$5();
+            }
+            break;
+        case "kritzel-menu":
+            if (!customElements.get(transformTag(tagName))) {
+                defineCustomElement$4();
+            }
+            break;
+        case "kritzel-menu-item":
+            if (!customElements.get(transformTag(tagName))) {
+                defineCustomElement$3();
+            }
+            break;
+        case "kritzel-portal":
+            if (!customElements.get(transformTag(tagName))) {
+                defineCustomElement$2();
+            }
+            break;
+        case "kritzel-split-button":
+            if (!customElements.get(transformTag(tagName))) {
+                defineCustomElement$1();
+            }
+            break;
+    } });
+}
+
+export { KritzelWorkspaceManager as K, defineCustomElement as d };

package/dist/components/p-CoNexfpB.js

@@ -0,0 +1,106 @@
+import { p as proxyCustomElement, H, c as createEvent, h, d as Host, t as transformTag } from './p-5qkOM1RJ.js';
+
+const kritzelLineEndingsCss = () => `:host{display:flex;flex-direction:column;gap:12px;padding:0;box-sizing:border-box}.endings-section{display:flex;flex-direction:column;gap:6px}.section-label{font-size:12px;font-weight:500;color:var(--kritzel-line-endings-label-color, #666666);padding-left:4px}.endings-row{display:flex;align-items:center;gap:4px}.ending-option{display:flex;justify-content:center;align-items:center;width:48px;height:32px;border-radius:6px;cursor:var(--kritzel-global-pointer-cursor, pointer);border:2px solid transparent;box-sizing:border-box;background:var(--kritzel-line-endings-option-background, #ffffff);padding:4px;transition:background-color 0.15s ease, border-color 0.15s ease}.ending-option:hover{background-color:var(--kritzel-line-endings-hover-background-color, #ebebeb)}.ending-option.selected{border-color:var(--kritzel-selection-border-color, #007AFF);background-color:var(--kritzel-line-endings-selected-background-color, #ebebeb)}.ending-option:focus{outline:none;box-shadow:0 0 0 2px var(--kritzel-global-focus-ring-color, rgba(0, 122, 255, 0.3))}.ending-icon{width:100%;height:100%}`;
+
+const KritzelLineEndings = /*@__PURE__*/ proxyCustomElement(class KritzelLineEndings extends H {
+    constructor(registerHost) {
+        super();
+        if (registerHost !== false) {
+            this.__registerHost();
+        }
+        this.__attachShadow();
+        this.valueChange = createEvent(this, "valueChange");
+    }
+    /** Available ending styles */
+    styles = ['none', 'triangle'];
+    /** Current line arrow configuration */
+    value;
+    valueChange;
+    getStartEnding() {
+        if (!this.value?.start?.enabled)
+            return 'none';
+        return this.value.start.style ?? 'triangle';
+    }
+    getEndEnding() {
+        if (!this.value?.end?.enabled)
+            return 'none';
+        return this.value.end.style ?? 'triangle';
+    }
+    handleStartChange(type) {
+        const newValue = {
+            ...this.value,
+            start: type === 'none'
+                ? { enabled: false }
+                : { enabled: true, style: type },
+        };
+        this.value = newValue;
+        this.valueChange.emit(newValue);
+    }
+    handleEndChange(type) {
+        const newValue = {
+            ...this.value,
+            end: type === 'none'
+                ? { enabled: false }
+                : { enabled: true, style: type },
+        };
+        this.value = newValue;
+        this.valueChange.emit(newValue);
+    }
+    getEndingPath(type) {
+        switch (type) {
+            case 'triangle':
+                return 'M 0 0 L 10 5 L 0 10 Z';
+            case 'open':
+                return 'M 0 0 L 10 5 L 0 10';
+            case 'diamond':
+                return 'M 0 5 L 5 0 L 10 5 L 5 10 Z';
+            case 'circle':
+                return 'M 10 5 A 5 5 0 1 1 0 5 A 5 5 0 1 1 10 5 Z';
+            default:
+                return '';
+        }
+    }
+    renderEndingIcon(type, isStart) {
+        const color = 'var(--kritzel-global-text-primary)';
+        if (type === 'none') {
+            return (h("svg", { viewBox: "0 0 24 12", class: "ending-icon" }, h("line", { x1: isStart ? 4 : 2, y1: "6", x2: isStart ? 22 : 20, y2: "6", stroke: color, "stroke-width": "2", "stroke-linecap": "round" })));
+        }
+        const path = this.getEndingPath(type);
+        const isOpenStyle = type === 'open';
+        return (h("svg", { viewBox: "0 0 24 12", class: "ending-icon" }, isStart ? (
+        // Start arrow points left
+        h("g", null, h("line", { x1: "12", y1: "6", x2: "22", y2: "6", stroke: color, "stroke-width": "2", "stroke-linecap": "round" }), h("g", { transform: "translate(2, 1) scale(1, 1)" }, h("path", { d: path, fill: isOpenStyle ? 'none' : color, stroke: color, "stroke-width": isOpenStyle ? 2 : 0, "stroke-linecap": "round", "stroke-linejoin": "round", transform: "scale(-1, 1) translate(-10, 0)" })))) : (
+        // End arrow points right
+        h("g", null, h("line", { x1: "2", y1: "6", x2: "12", y2: "6", stroke: color, "stroke-width": "2", "stroke-linecap": "round" }), h("g", { transform: "translate(12, 1)" }, h("path", { d: path, fill: isOpenStyle ? 'none' : color, stroke: color, "stroke-width": isOpenStyle ? 2 : 0, "stroke-linecap": "round", "stroke-linejoin": "round" }))))));
+    }
+    render() {
+        const startEnding = this.getStartEnding();
+        const endEnding = this.getEndEnding();
+        return (h(Host, { key: '580845b2a1bea69bb5c7854ccd1dbb09056f959c' }, h("div", { key: '7cf27d1e567f5c5320b6a78e06acf59b59a05a9c', class: "endings-section" }, h("div", { key: '0b3ef9a2fe9d4eecc7641bd197191143a7fd1fee', class: "endings-row" }, this.styles.map(type => (h("button", { class: {
+                'ending-option': true,
+                'selected': startEnding === type,
+            }, onClick: () => this.handleStartChange(type), title: type === 'none' ? 'No start arrow' : `${type} start arrow` }, this.renderEndingIcon(type, true)))))), h("div", { key: '536f00524bddb99c06407df4616f1a63a82d4fb9', class: "endings-section" }, h("div", { key: 'd1ac8f88a9bee0432def20e0182aeeacd739de83', class: "endings-row" }, this.styles.map(type => (h("button", { class: {
+                'ending-option': true,
+                'selected': endEnding === type,
+            }, onClick: () => this.handleEndChange(type), title: type === 'none' ? 'No end arrow' : `${type} end arrow` }, this.renderEndingIcon(type, false))))))));
+    }
+    static get style() { return kritzelLineEndingsCss(); }
+}, [513, "kritzel-line-endings", {
+        "styles": [16],
+        "value": [1040]
+    }]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["kritzel-line-endings"];
+    components.forEach(tagName => { switch (tagName) {
+        case "kritzel-line-endings":
+            if (!customElements.get(transformTag(tagName))) {
+                customElements.define(transformTag(tagName), KritzelLineEndings);
+            }
+            break;
+    } });
+}
+
+export { KritzelLineEndings as K, defineCustomElement as d };

package/dist/components/p-Cp4e4oTE.js

@@ -0,0 +1,122 @@
+import { p as proxyCustomElement, H, h, d as Host, t as transformTag } from './p-5qkOM1RJ.js';
+
+var KritzelMouseButton;
+(function (KritzelMouseButton) {
+    KritzelMouseButton[KritzelMouseButton["Left"] = 0] = "Left";
+    KritzelMouseButton[KritzelMouseButton["Middle"] = 1] = "Middle";
+    KritzelMouseButton[KritzelMouseButton["Right"] = 2] = "Right";
+})(KritzelMouseButton || (KritzelMouseButton = {}));
+
+const kritzelCursorTrailCss = () => `:host{display:block;position:fixed;top:0;left:0;width:100vw;height:100vh;pointer-events:none;z-index:9000}`;
+
+const KritzelCursorTrail = /*@__PURE__*/ proxyCustomElement(class KritzelCursorTrail extends H {
+    constructor(registerHost) {
+        super();
+        if (registerHost !== false) {
+            this.__registerHost();
+        }
+        this.__attachShadow();
+    }
+    core;
+    cursorTrailPoints = [];
+    isLeftButtonDown = false;
+    handleMouseDown(ev) {
+        if (ev.pointerType === 'mouse') {
+            if (ev.button === KritzelMouseButton.Left) {
+                this.isLeftButtonDown = true;
+                this.cursorTrailPoints = [];
+            }
+        }
+        if (ev.pointerType === 'touch') {
+            if (this.core.store.state.pointers.size === 1) {
+                this.isLeftButtonDown = true;
+                this.cursorTrailPoints = [];
+            }
+        }
+    }
+    handlePointerMove(ev) {
+        if (!this.isLeftButtonDown) {
+            return;
+        }
+        const newPoint = { x: ev.clientX, y: ev.clientY, timestamp: Date.now() };
+        const updatedTrail = [newPoint, ...this.cursorTrailPoints];
+        if (updatedTrail.length > this.MAX_TRAIL_POINTS) {
+            this.cursorTrailPoints = updatedTrail.slice(0, this.MAX_TRAIL_POINTS);
+        }
+        else {
+            this.cursorTrailPoints = updatedTrail;
+        }
+    }
+    handlePointerUp(ev) {
+        if (ev.pointerType === 'mouse') {
+            if (ev.button === KritzelMouseButton.Left) {
+                this.isLeftButtonDown = false;
+                this.cursorTrailPoints = [];
+            }
+        }
+        if (ev.pointerType === 'touch') {
+            if (this.core.store.state.pointers.size === 0) {
+                this.isLeftButtonDown = false;
+                this.cursorTrailPoints = [];
+            }
+        }
+    }
+    trailCleanupIntervalId;
+    TRAIL_DURATION_MS = 100;
+    MAX_TRAIL_POINTS = 50;
+    componentDidLoad() {
+        this.trailCleanupIntervalId = window.setInterval(() => {
+            const now = Date.now();
+            const newTrailPoints = this.cursorTrailPoints.filter(p => now - p.timestamp < this.TRAIL_DURATION_MS);
+            if (newTrailPoints.length !== this.cursorTrailPoints.length) {
+                this.cursorTrailPoints = newTrailPoints;
+            }
+        }, 50);
+    }
+    disconnectedCallback() {
+        if (this.trailCleanupIntervalId) {
+            window.clearInterval(this.trailCleanupIntervalId);
+        }
+    }
+    render() {
+        return (h(Host, { key: '707e81b135931233131a830d6fc63e721e381287' }, this.cursorTrailPoints.length > 1 && (h("svg", { key: 'b262b0e3a0cf3b1887ee6acedb2f00d72e95db7e', class: "cursor-trail-svg", xmlns: "http://www.w3.org/2000/svg", style: {
+                position: 'absolute',
+                left: '0',
+                top: '0',
+                width: '100%',
+                height: '100%',
+                pointerEvents: 'none',
+                opacity: 'var(--kritzel-cursor-trail-opacity, 0.6)',
+                zIndex: '9000',
+            } }, this.cursorTrailPoints.slice(1).map((point, index) => {
+            const prevPoint = this.cursorTrailPoints[index];
+            const now = Date.now();
+            const age = now - point.timestamp;
+            const progress = Math.max(0, Math.min(1, age / this.TRAIL_DURATION_MS));
+            if (progress >= 1)
+                return null;
+            const baseStrokeWidth = Math.max(2, 15 * (1 - progress));
+            return (h("line", { key: `trail-segment-${point.timestamp}`, x1: prevPoint.x.toString(), y1: prevPoint.y.toString(), x2: point.x.toString(), y2: point.y.toString(), stroke: "var(--kritzel-cursor-trail-color, rgb(228, 228, 228))", "stroke-width": baseStrokeWidth.toString(), "stroke-linecap": "round" }));
+        })))));
+    }
+    static get style() { return kritzelCursorTrailCss(); }
+}, [513, "kritzel-cursor-trail", {
+        "core": [16],
+        "cursorTrailPoints": [32],
+        "isLeftButtonDown": [32]
+    }, [[9, "pointerdown", "handleMouseDown"], [9, "pointermove", "handlePointerMove"], [9, "pointerup", "handlePointerUp"]]]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["kritzel-cursor-trail"];
+    components.forEach(tagName => { switch (tagName) {
+        case "kritzel-cursor-trail":
+            if (!customElements.get(transformTag(tagName))) {
+                customElements.define(transformTag(tagName), KritzelCursorTrail);
+            }
+            break;
+    } });
+}
+
+export { KritzelCursorTrail as K, KritzelMouseButton as a, defineCustomElement as d };

package/dist/components/p-CrIEmItB.js

@@ -0,0 +1,85 @@
+import { p as proxyCustomElement, H, c as createEvent, h, d as Host, t as transformTag } from './p-5qkOM1RJ.js';
+import { d as defineCustomElement$3 } from './p-4-qLegHb.js';
+import { d as defineCustomElement$2 } from './p-DOJCDPVD.js';
+import { d as defineCustomElement$1 } from './p-peZjvnkK.js';
+
+const kritzelCurrentUserDialogCss = () => `:host{display:contents}kritzel-dialog{--kritzel-dialog-width-small:380px}.user-info{display:flex;flex-direction:column;align-items:center;gap:8px;padding:8px 0}.user-name{font-size:18px;font-weight:600;color:var(--kritzel-current-user-dialog-name-color, #333333);text-align:center;margin-top:8px}.user-email{font-size:14px;color:var(--kritzel-current-user-dialog-email-color, #666666);text-align:center}.logout-button{margin-top:16px;width:100%;--kritzel-button-width:100%;--kritzel-button-primary-background-color:var(--kritzel-current-user-dialog-logout-button-background-color, #007AFF);--kritzel-button-primary-hover-background-color:var(--kritzel-current-user-dialog-logout-button-hover-background-color, #006ae6);--kritzel-button-primary-active-background-color:var(--kritzel-current-user-dialog-logout-button-active-background-color, #005bbf);--kritzel-button-primary-color:var(--kritzel-current-user-dialog-logout-button-color, #ffffff)}`;
+
+const KritzelCurrentUserDialog = /*@__PURE__*/ proxyCustomElement(class KritzelCurrentUserDialog extends H {
+    constructor(registerHost) {
+        super();
+        if (registerHost !== false) {
+            this.__registerHost();
+        }
+        this.__attachShadow();
+        this.logoutRequest = createEvent(this, "logoutRequest");
+    }
+    get host() { return this; }
+    user;
+    /** Resolved localized strings keyed by term key, supplied by the editor. */
+    terms = {};
+    isDialogOpen = false;
+    /** Emitted when the user clicks the logout action. */
+    logoutRequest;
+    async open() {
+        this.isDialogOpen = true;
+    }
+    async close() {
+        this.isDialogOpen = false;
+    }
+    closeDialog = () => {
+        this.isDialogOpen = false;
+    };
+    handleLogout = () => {
+        this.logoutRequest.emit();
+        this.closeDialog();
+    };
+    getDisplayName() {
+        if (!this.user)
+            return undefined;
+        return (this.user.displayName ??
+            ([this.user.firstName, this.user.lastName].filter(Boolean).join(' ') ||
+                undefined));
+    }
+    render() {
+        const displayName = this.getDisplayName();
+        return (h(Host, { key: '68c0653cbd5d5dfccd5689223c08d82f36e2bc8e' }, h("kritzel-dialog", { key: '0e7b35e3bb4239ef7a992e5716c05117d14ac1df', dialogTitle: this.terms['currentUser.dialogTitle'] ?? 'Account', isOpen: this.isDialogOpen, onDialogClose: this.closeDialog, size: "small", contained: true }, h("div", { key: '236c41eaf4c570b91a0cfe0e5a35d8b00140b6ee', class: "user-info" }, h("kritzel-avatar", { key: 'edbaa83513e2c8838c29e32149fae44aefdbb122', user: this.user, size: 80 }), displayName && h("div", { key: '275560cca9980dd8664e6c4e9718cb7085c1031b', class: "user-name" }, displayName), this.user?.email && h("div", { key: '3f9483938a271d620ee3109fa3ce1e37001683ce', class: "user-email" }, this.user.email), h("kritzel-button", { key: 'd92f0613f9ee7f2d44a30f444d30e59294022809', class: "logout-button", variant: "primary", onButtonClick: this.handleLogout }, this.terms['menu.logout'] ?? 'Logout')))));
+    }
+    static get style() { return kritzelCurrentUserDialogCss(); }
+}, [513, "kritzel-current-user-dialog", {
+        "user": [16],
+        "terms": [16],
+        "isDialogOpen": [32],
+        "open": [64],
+        "close": [64]
+    }]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["kritzel-current-user-dialog", "kritzel-avatar", "kritzel-button", "kritzel-dialog"];
+    components.forEach(tagName => { switch (tagName) {
+        case "kritzel-current-user-dialog":
+            if (!customElements.get(transformTag(tagName))) {
+                customElements.define(transformTag(tagName), KritzelCurrentUserDialog);
+            }
+            break;
+        case "kritzel-avatar":
+            if (!customElements.get(transformTag(tagName))) {
+                defineCustomElement$3();
+            }
+            break;
+        case "kritzel-button":
+            if (!customElements.get(transformTag(tagName))) {
+                defineCustomElement$2();
+            }
+            break;
+        case "kritzel-dialog":
+            if (!customElements.get(transformTag(tagName))) {
+                defineCustomElement$1();
+            }
+            break;
+    } });
+}
+
+export { KritzelCurrentUserDialog as K, defineCustomElement as d };