@lightning-out/lwc-shell 2.2.0-rc.0

package/dist/index.esm.js

@@ -0,0 +1,791 @@
+/*! @lightning-out/lwc-shell v2.2.0-rc.1 (2026-02-27) */
+/**
+ * EmbeddingResizer - Handles dynamic iframe/container resizing
+ * Uses ResizeObserver to monitor element size changes and notify the host
+ */
+/**
+ * Generates a pseudo-random alphanumeric identifier string for unique
+ * element IDs or temporary identifiers (not cryptographically secure).
+ *
+ * @returns Random alphanumeric string
+ *
+ * @example
+ * getUUID(); // 'k2j8f5l9m'
+ */
+function getUUID() {
+    return Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(36);
+}
+
+/**
+ * Symbols used as property / method keys for the dirty-state contract.
+ *
+ * These symbols are attached to the host LWC component by `<lwc-shell>`
+ * (via the `hostComponent` setter) so that Salesforce's tab-close flow can
+ * invoke `DoCloseConfirmation` and identify the component by `Guid`.
+ *
+ * See `InternalHostLwcShell.hostComponent` setter for wiring details,
+ * and the `SelfManagedDirtyComponent` object in `dirtyStateModal.ts` for
+ * the full contract description.
+ */
+const Guid = Symbol("Guid");
+const DoCloseConfirmation = Symbol("DoCloseConfirmation");
+
+/**
+ * Symbol-keyed contract for components that self-manage their dirty state.
+ *
+ * - `DoCloseConfirmation` — The component **must** define this as a function
+ *   that returns a `Promise` resolving to one of:
+ *     - `'SUCCESS'` – dirty state resolved, tab closure should continue.
+ *     - `'CANCEL'`  – the user cancelled the operation.
+ *     - `'ERROR'`   – a problem occurred resolving the dirty state.
+ *
+ *   If the promise resolves to `'SUCCESS'`, the component **must** have
+ *   already dispatched a `'privatelightningselfmanageddirtystatechanged'`
+ *   event with `isUnsaved: false` to clear its dirty state.
+ *
+ * - `Guid` — Optionally, the component can define this as a property
+ *   containing a globally unique string. If undefined, a GUID will be
+ *   generated automatically.
+ */
+const SelfManagedDirtyComponent = {
+    DoCloseConfirmation,
+    Guid,
+};
+
+/**
+ * InternalHostLwcShell
+ *
+ * A standard Web Component (custom element) that embeds an iframe-based widget
+ * with bridge communication, sandbox management, fullscreen support, and
+ * dirty-state tracking.
+ *
+ * Registered as `<lwc-shell>`.
+ *
+ * Ported from the LWC `widgetContainerLo` component (formerly known as
+ * WidgetContainer) — all Lightning Web Component framework dependencies have
+ * been removed so this can run as a plain custom element inside any LWC host.
+ *
+ * **How customers use this:**
+ * 1. The build produces `dist/index.esm.js` which bundles this class.
+ * 2. Customers copy that file into their SFDX project as an LWC entity
+ *    (e.g. `c/lwcShell`) and deploy it to their Salesforce org.
+ * 3. A wrapper LWC imports `'c/lwcShell'` and creates `<lwc-shell>`
+ *    imperatively via `document.createElement('lwc-shell')`.
+ *
+ * See the README and the `productRegistrationWidgetLo` demo for a full recipe.
+ */
+const BASE_TOKENS = ["allow-scripts", "allow-pointer-lock"];
+const OPTIONAL_TOKENS = ["allow-downloads", "allow-forms", "allow-modals"];
+const BLOCKED_TOKENS = ["allow-same-origin", "allow-top-navigation", "allow-popups"];
+const STATES = {
+    LOADING: "state-loading",
+    LOADED: "state-loaded",
+};
+const STYLES = /* css */ `
+:host {
+    display: block;
+    position: relative;
+    min-height: 100px;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    overflow: hidden;
+}
+
+.container {
+    width: 100%;
+    height: 100%;
+    position: relative;
+}
+
+.frame {
+    visibility: hidden;
+    display: block;
+    width: 100%;
+    height: 100%;
+    border: none;
+}
+
+.container[data-state='state-loaded'] .frame {
+    visibility: visible;
+}
+
+/* Fullscreen overlay */
+.overlayBackdrop {
+    position: fixed;
+    inset: 0;
+    width: 100vw;
+    height: 100vh;
+    z-index: 9998;
+    background: rgba(0, 0, 0, 0.8);
+    backdrop-filter: blur(4px);
+}
+
+.overlayClose {
+    position: fixed;
+    top: 24px;
+    right: 24px;
+    z-index: 9999;
+    width: 32px;
+    height: 32px;
+    background: rgba(0, 0, 0, 0.7);
+    color: #fff;
+    border-radius: 50%;
+    border: none;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 16px;
+    font-weight: bold;
+    cursor: pointer;
+}
+
+.frameFull {
+    position: fixed;
+    inset: 0;
+    width: 90vw;
+    height: 90vh !important;
+    margin: 5vh 5vw;
+    z-index: 10000;
+    background: #fff;
+    border-radius: 8px;
+    box-shadow: 0 20px 40px rgba(0, 0, 0, 0.3);
+}
+`;
+class InternalHostLwcShell extends HTMLElement {
+    _shadow;
+    _iframe = null;
+    _container = null;
+    _currentState = STATES.LOADING;
+    _hasExplicitResize = false;
+    _readinessTimeout = null;
+    _isFullscreen = false;
+    _lastThemeData = {};
+    _lastPayloadData = {};
+    _bridgeReady = false;
+    _hasSentTheme = false;
+    _hasSentData = false;
+    _src = null;
+    _srcdoc = null;
+    _sandbox = null;
+    _title = "Embedded widget";
+    _view = "compact";
+    _dirtyComponentGuid = getUUID();
+    _beforeUnloadHandler = null;
+    _dirtyStateModal = null;
+    _pendingDirtyActions = new Map();
+    _debugEnabled = true;
+    static get observedAttributes() {
+        return ["src", "srcdoc", "sandbox", "title", "view", "debug"];
+    }
+    constructor() {
+        super();
+        this._shadow = this.attachShadow({ mode: "closed" });
+    }
+    connectedCallback() {
+        this._renderInitial();
+        this._setupMessageListener();
+        this._log("connectedCallback");
+    }
+    disconnectedCallback() {
+        window.removeEventListener("message", this._handleMessage);
+        if (this._readinessTimeout) {
+            clearTimeout(this._readinessTimeout);
+            this._readinessTimeout = null;
+        }
+        this._log("disconnectedCallback");
+    }
+    attributeChangedCallback(name, oldVal, newVal) {
+        if (oldVal === newVal)
+            return;
+        switch (name) {
+            case "src":
+                this.src = newVal;
+                break;
+            case "srcdoc":
+                this.srcdoc = newVal;
+                break;
+            case "sandbox":
+                this.sandbox = newVal;
+                break;
+            case "title":
+                this.title = newVal;
+                break;
+            case "view":
+                this.view = newVal;
+                break;
+            case "debug":
+                this.debug = newVal !== null;
+                break;
+        }
+    }
+    get src() {
+        return this._src;
+    }
+    set src(v) {
+        const val = v || null;
+        if (this._src === val)
+            return;
+        this._src = val;
+        if (val !== null) {
+            this.setAttribute("src", val);
+        }
+        else {
+            this.removeAttribute("src");
+        }
+        this._updateIframeSrc();
+    }
+    get srcdoc() {
+        return this._srcdoc;
+    }
+    set srcdoc(v) {
+        const val = v || null;
+        if (this._srcdoc === val)
+            return;
+        this._srcdoc = val;
+        if (val !== null) {
+            this.setAttribute("srcdoc", val);
+        }
+        else {
+            this.removeAttribute("srcdoc");
+        }
+        this._updateIframeSrc();
+    }
+    get sandbox() {
+        return this._sandbox;
+    }
+    set sandbox(v) {
+        const val = v || null;
+        if (this._sandbox === val)
+            return;
+        this._sandbox = val;
+        if (val !== null) {
+            this.setAttribute("sandbox", val);
+        }
+        else {
+            this.removeAttribute("sandbox");
+        }
+        this._applySandbox();
+    }
+    get title() {
+        return this._title;
+    }
+    set title(v) {
+        const val = v || "Embedded widget";
+        if (this._title === val)
+            return;
+        this._title = val;
+        this.setAttribute("title", val);
+        this._updateTitle();
+    }
+    get view() {
+        return this._view;
+    }
+    set view(v) {
+        const val = v === "full" ? "full" : "compact";
+        if (this._view === val)
+            return;
+        this._view = val;
+        this.setAttribute("view", val);
+        this._updateViewDOM();
+    }
+    /**
+     * Controls debug logging. Toggle via:
+     * - HTML attribute: `<lwc-shell debug>`
+     * - Programmatically: `shell.debug = true`
+     */
+    get debug() {
+        return this._debugEnabled;
+    }
+    set debug(v) {
+        const val = !!v;
+        if (this._debugEnabled === val)
+            return;
+        this._debugEnabled = val;
+        if (val) {
+            this.setAttribute("debug", "");
+        }
+        else {
+            this.removeAttribute("debug");
+        }
+    }
+    get _SelfManagedDirtyComponent() {
+        return SelfManagedDirtyComponent;
+    }
+    /**
+     * The LightningModal class used to show the unsaved-changes confirmation.
+     * Wrapper LWC sets this via: `shell.dirtyStateModal = DirtyStateModal;`
+     * where `DirtyStateModal` is the class imported from `'c/dirtyStateModal'`.
+     */
+    get dirtyStateModal() {
+        return this._dirtyStateModal;
+    }
+    set dirtyStateModal(v) {
+        this._dirtyStateModal = v || null;
+        this._log("dirtyStateModal set", !!v);
+    }
+    updateData(newData) {
+        if (!newData || typeof newData !== "object")
+            return;
+        Object.entries(newData).forEach(([key, value]) => {
+            const dataAttr = `data-${String(key).replace(/[A-Z]/g, "-$&").toLowerCase()}`;
+            this.setAttribute(dataAttr, String(value));
+        });
+        const payload = this._collectDataAttributes();
+        this._lastPayloadData = payload;
+        if (this._bridgeReady) {
+            this._postToIframe("data", payload);
+            this._hasSentData = true;
+            this._log("send data", payload);
+        }
+        else {
+            this._log("queue data until bridge ready", payload);
+        }
+    }
+    refreshTheme() {
+        this._sendInitialTheme();
+    }
+    get _isFullView() {
+        return this._view === "full";
+    }
+    get _frameClass() {
+        return this._isFullView ? "frame frameFull" : "frame";
+    }
+    _log(...args) {
+        if (this._debugEnabled) {
+            // eslint-disable-next-line no-console
+            console.log("[InternalHostLwcShell]", JSON.stringify(args, null, 2));
+        }
+    }
+    _renderInitial() {
+        const shadow = this._shadow;
+        shadow.innerHTML = `
+            <style>${STYLES}</style>
+            <div class="container" data-state="${this._currentState}"
+                 tabindex="0" role="region" aria-label="${this._title}">
+                <iframe
+                    class="${this._frameClass}"
+                    title="${this._title}"
+                    aria-label="Interactive widget content"
+                ></iframe>
+            </div>
+        `;
+        this._container = shadow.querySelector(".container");
+        this._iframe = shadow.querySelector("iframe");
+        this._container.addEventListener("click", () => this._handleContainerClick());
+        this._applySandbox();
+        this._updateIframeSrc();
+        this._sendInitialTheme();
+        this._log("renderInitial: iframe ready");
+    }
+    _updateContainerState() {
+        if (this._container) {
+            this._container.setAttribute("data-state", this._currentState);
+        }
+    }
+    _updateTitle() {
+        if (this._iframe) {
+            this._iframe.setAttribute("title", this._title);
+        }
+        if (this._container) {
+            this._container.setAttribute("aria-label", this._title);
+        }
+        this._log("title", this._title);
+    }
+    _updateViewDOM() {
+        if (this._iframe) {
+            this._iframe.className = this._frameClass;
+        }
+        if (!this._container)
+            return;
+        const existingBackdrop = this._container.querySelector(".overlayBackdrop");
+        const existingClose = this._container.querySelector(".overlayClose");
+        if (existingBackdrop)
+            existingBackdrop.remove();
+        if (existingClose)
+            existingClose.remove();
+        if (this._isFullView) {
+            const backdrop = document.createElement("div");
+            backdrop.className = "overlayBackdrop";
+            backdrop.setAttribute("aria-hidden", "true");
+            const closeBtn = document.createElement("button");
+            closeBtn.className = "overlayClose";
+            closeBtn.type = "button";
+            closeBtn.setAttribute("aria-label", "Close fullscreen");
+            closeBtn.textContent = "\u2715";
+            closeBtn.addEventListener("click", this._exitFullscreen);
+            this._container.appendChild(backdrop);
+            this._container.appendChild(closeBtn);
+        }
+    }
+    _setState(newState) {
+        this._currentState = newState;
+        this._updateContainerState();
+        if (newState === STATES.LOADED) {
+            this._sendInitialData();
+        }
+    }
+    _setupMessageListener() {
+        window.addEventListener("message", this._handleMessage);
+    }
+    _handleMessage = (event) => {
+        const sourceWin = this._iframe?.contentWindow;
+        if (event.source !== sourceWin) {
+            return;
+        }
+        const payload = event.data || {};
+        const { type, data } = payload;
+        this._log("receive", type, data);
+        if (type === "bridge-event") {
+            const { eventType, detail } = data || {};
+            this._log("bridge-event", eventType, detail);
+            if (eventType === "resize") {
+                this._hasExplicitResize = true;
+                this._handleResize(detail);
+            }
+            else if (eventType === "widget-ready") {
+                this._handleWidgetReady();
+            }
+            else {
+                throw new RangeError(`Invalid bridge event ${eventType}`);
+            }
+        }
+        else if (type === "custom-event") {
+            const { eventType, detail } = data || {};
+            this._log("custom-event", eventType, detail);
+            if (eventType === "fullscreen-request") {
+                const shouldRunDefault = this.dispatchEvent(new CustomEvent(eventType, {
+                    detail,
+                    bubbles: true,
+                    cancelable: true,
+                }));
+                if (shouldRunDefault) {
+                    this._handleFullscreenRequest();
+                }
+            }
+            else if (eventType === "mfe:dirty-state-detected") {
+                this._handleDirtyStateDetected();
+            }
+            else if (eventType === "mfe:dirty-state-reset") {
+                this._handleDirtyStateReset();
+            }
+            else if (eventType === "mfe:dirty-state-modal-handle-status") {
+                this._handleDirtyStateModalStatus(detail);
+            }
+        }
+        else if (type === "bridge-ready") {
+            this._handleBridgeReady();
+        }
+        else if (type === "bridge-error") {
+            this._handleBridgeError(data);
+        }
+    };
+    _dispatchSelfManagedDirtyEvent(isUnsaved) {
+        const evt = new CustomEvent("privatelightningselfmanageddirtystatechanged", {
+            bubbles: true,
+            composed: true,
+            cancelable: true,
+            detail: {
+                isUnsaved,
+                unsavedComponent: this,
+            },
+        });
+        this.dispatchEvent(evt);
+    }
+    _toggleBeforeUnload(enable) {
+        if (enable) {
+            if (!this._beforeUnloadHandler) {
+                this._beforeUnloadHandler = (e) => {
+                    e.preventDefault();
+                    // Chrome requires returnValue to be set
+                    e.returnValue = "";
+                    return "";
+                };
+                window.addEventListener("beforeunload", this._beforeUnloadHandler);
+            }
+        }
+        else if (this._beforeUnloadHandler) {
+            window.removeEventListener("beforeunload", this._beforeUnloadHandler);
+            this._beforeUnloadHandler = null;
+        }
+    }
+    _handleDirtyStateDetected() {
+        this._toggleBeforeUnload(true);
+        this._dispatchSelfManagedDirtyEvent(true);
+    }
+    _handleDirtyStateReset() {
+        this._toggleBeforeUnload(false);
+        this._dispatchSelfManagedDirtyEvent(false);
+    }
+    _handleDirtyStateModalStatus(detail) {
+        const { correlationId, isSuccess } = detail || {};
+        const handlers = this._pendingDirtyActions.get(correlationId);
+        if (!handlers) {
+            this._log("No pending handler for correlationId", correlationId);
+            return;
+        }
+        this._pendingDirtyActions.delete(correlationId);
+        handlers.resolve(isSuccess);
+    }
+    _handleResize({ height }) {
+        const evt = new CustomEvent("resize", {
+            detail: { height },
+            cancelable: true,
+        });
+        this.dispatchEvent(evt);
+        if (!evt.defaultPrevented && !this._isFullscreen && typeof height === "number" && Number.isFinite(height)) {
+            if (this._iframe)
+                this._iframe.style.height = height + "px";
+            this._log("applied resize", height);
+        }
+    }
+    _handleWidgetReady() {
+        if (this._readinessTimeout) {
+            clearTimeout(this._readinessTimeout);
+            this._readinessTimeout = null;
+        }
+        this.dispatchEvent(new CustomEvent("widget-ready", { bubbles: true }));
+        this._log("widget-ready");
+    }
+    _handleFullscreenRequest() {
+        if (!this._isFullscreen) {
+            this._enterFullscreen();
+        }
+    }
+    _enterFullscreen() {
+        this._isFullscreen = true;
+        this._view = "full";
+        this._updateViewDOM();
+        if (this._iframe)
+            this._iframe.style.height = "100%";
+        this.updateData({ view: "full" });
+        this.dispatchEvent(new CustomEvent("fullscreen-entered", {
+            detail: { element: this },
+            bubbles: true,
+        }));
+        this._log("enter fullscreen");
+    }
+    _exitFullscreen = () => {
+        this._isFullscreen = false;
+        this._view = "compact";
+        this._updateViewDOM();
+        if (this._iframe)
+            this._iframe.style.height = "";
+        this.updateData({ view: "compact" });
+        this.dispatchEvent(new CustomEvent("fullscreen-exited", {
+            detail: { element: this },
+            bubbles: true,
+        }));
+        this._log("exit fullscreen");
+    };
+    _handleBridgeReady() {
+        this._bridgeReady = true;
+        this._setState(STATES.LOADED);
+        this._log("bridge-ready");
+    }
+    _handleBridgeError(errorData) {
+        this.dispatchEvent(new CustomEvent("widget-bridge-error", { detail: errorData }));
+        this._log("bridge-error", errorData);
+    }
+    _handleContainerClick() {
+        // placeholder
+    }
+    _applySandbox() {
+        const frame = this._iframe;
+        if (!frame)
+            return;
+        const tokens = this._computeSandboxTokens();
+        frame.setAttribute("sandbox", tokens);
+        this._log("sandbox", tokens);
+    }
+    _computeSandboxTokens() {
+        const tokens = [...BASE_TOKENS];
+        if (this._sandbox) {
+            const requested = String(this._sandbox).split(/\s+/).filter(Boolean);
+            requested.forEach((t) => {
+                if (OPTIONAL_TOKENS.includes(t) && !tokens.includes(t))
+                    tokens.push(t);
+                if (BLOCKED_TOKENS.includes(t)) {
+                    this.dispatchEvent(new CustomEvent("security-violation", {
+                        detail: {
+                            type: "blocked-sandbox-token",
+                            token: t,
+                            element: this,
+                        },
+                    }));
+                }
+            });
+        }
+        return tokens.join(" ");
+    }
+    _updateIframeSrc() {
+        const frame = this._iframe;
+        if (!frame)
+            return;
+        // reset tracking
+        this._hasExplicitResize = false;
+        this._currentState = STATES.LOADING;
+        this._updateContainerState();
+        // clear existing
+        frame.removeAttribute("src");
+        frame.removeAttribute("srcdoc");
+        if (this._src) {
+            frame.setAttribute("src", this._src);
+        }
+        else if (this._srcdoc) {
+            try {
+                frame.setAttribute("srcdoc", this._srcdoc);
+            }
+            catch {
+                frame.setAttribute("src", "about:blank");
+            }
+        }
+        // load events
+        frame.onload = this._handleIframeLoad;
+        frame.onerror = this._handleIframeError;
+        this._log("updateIframeSrc", this._src ? "src" : this._srcdoc ? "srcdoc" : "blank");
+    }
+    _handleIframeLoad = () => {
+        this.dispatchEvent(new CustomEvent("iframe-loaded", {
+            detail: { element: this },
+            bubbles: true,
+        }));
+        this._log("iframe-loaded");
+        this._readinessTimeout = setTimeout(() => {
+            if (this._currentState !== STATES.LOADED) {
+                this.dispatchEvent(new CustomEvent("widget-readiness-warning", {
+                    detail: {
+                        element: this,
+                        message: "Widget may not be using ChatBridge for readiness signaling",
+                    },
+                    bubbles: true,
+                }));
+                this._log("widget-readiness-warning");
+            }
+        }, 3000);
+    };
+    _handleIframeError = (error) => {
+        this.dispatchEvent(new CustomEvent("widget-error", {
+            detail: { error, element: this },
+        }));
+    };
+    _postToIframe(type, data) {
+        const frame = this._iframe;
+        const win = frame && frame.contentWindow;
+        if (!win)
+            return;
+        try {
+            const msgType = `salesforce-${type}`;
+            win.postMessage("BRIDGE-JSON:" + JSON.stringify({ type: msgType, data }), "*");
+            this._log("postMessage", msgType, data);
+        }
+        catch (e) {
+            this._log("postMessage error", e instanceof Error ? e.message : String(e));
+        }
+    }
+    _collectDataAttributes() {
+        const out = {};
+        for (let i = 0; i < this.attributes.length; i++) {
+            const a = this.attributes[i];
+            if (a.name.startsWith("data-")) {
+                const raw = a.name.replace(/^data-/, "");
+                // convert kebab-case to camelCase
+                const camel = raw.replace(/-([a-z])/g, (_m, c) => c.toUpperCase());
+                out[camel] = a.value;
+            }
+        }
+        return out;
+    }
+    _sendInitialTheme() {
+        const computed = getComputedStyle(this);
+        const theme = {};
+        for (let i = 0; i < computed.length; i++) {
+            const name = computed[i];
+            if (name.startsWith("--")) {
+                const val = computed.getPropertyValue(name).trim();
+                if (val)
+                    theme[name] = val;
+            }
+        }
+        this._lastThemeData = theme;
+        if (this._bridgeReady) {
+            this._postToIframe("theme", theme);
+            this._hasSentTheme = true;
+            this._log("send theme", theme);
+        }
+        else {
+            this._log("queue theme until bridge ready", theme);
+        }
+    }
+    _sendInitialData() {
+        if (this._lastThemeData && Object.keys(this._lastThemeData).length) {
+            this._postToIframe("theme", this._lastThemeData);
+            this._hasSentTheme = true;
+            this._log("send theme (initial)", this._lastThemeData);
+        }
+        const payload = this._collectDataAttributes();
+        this._lastPayloadData = { ...payload };
+        this._postToIframe("data", this._lastPayloadData);
+        this._hasSentData = true;
+        this._log("send data (initial)", this._lastPayloadData);
+        this._postToIframe("bridge-ready");
+    }
+    [Guid] = this._dirtyComponentGuid;
+    [DoCloseConfirmation]() {
+        if (!this._dirtyStateModal) {
+            this._log("DoCloseConfirmation: no modal configured, auto-resolving SUCCESS");
+            return Promise.resolve("SUCCESS");
+        }
+        if (typeof this._dirtyStateModal.open !== "function") {
+            this._log("DoCloseConfirmation: modal.open is not a function, auto-resolving SUCCESS");
+            return Promise.resolve("SUCCESS");
+        }
+        const dirtStateModalConfig = {
+            modalFields: {
+                label: `Unsaved Changes in ${this._title}`,
+                description: "You have unsaved changes. If you leave, your changes will be lost.",
+                buttons: [
+                    {
+                        buttonKey: "cancel",
+                        buttonLabel: "Cancel",
+                    },
+                    {
+                        buttonKey: "discard",
+                        buttonLabel: "Discard Changes",
+                        buttonVariant: "brand",
+                    },
+                ],
+            },
+            size: "small",
+        };
+        return this._dirtyStateModal
+            .open(dirtStateModalConfig)
+            .then((buttonKey) => {
+            if (!buttonKey) {
+                return "CANCEL";
+            }
+            if (buttonKey === "discard") {
+                this._dispatchSelfManagedDirtyEvent(false);
+                return "SUCCESS";
+            }
+            else if (buttonKey === "cancel") {
+                return "CANCEL";
+            }
+            else {
+                return "ERROR";
+            }
+        })
+            .catch((err) => {
+            this._log("DoCloseConfirmation: error", err);
+            return "ERROR";
+        });
+    }
+}
+// ---------------------------------------------------------------------------
+// Register the custom element
+// ---------------------------------------------------------------------------
+if (!window.customElements.get("lwc-shell")) {
+    window.customElements.define("lwc-shell", InternalHostLwcShell);
+}
+
+export { InternalHostLwcShell, InternalHostLwcShell as default };
+//# sourceMappingURL=index.esm.js.map