@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/js/runtime.js

@@ -0,0 +1,109 @@
+
+var __webpack_modules__ = {};
+// The module cache
+var __webpack_module_cache__ = {};
+// The require function
+function __webpack_require__(moduleId) {
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+id: moduleId,
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+}
+// expose the modules object (__webpack_modules__)
+__webpack_require__.m = __webpack_modules__;
+
+// webpack/runtime/compat_get_default_export
+(() => {
+// getDefaultExport function for compatibility with non-ESM modules
+__webpack_require__.n = (module) => {
+	var getter = module && module.__esModule ?
+		() => (module['default']) :
+		() => (module);
+	__webpack_require__.d(getter, { a: getter });
+	return getter;
+};
+
+})();
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
+};
+})();
+// webpack/runtime/esm_register_module
+(() => {
+__webpack_require__.add = function registerModules(modules) { Object.assign(__webpack_require__.m, modules) }
+
+})();
+// webpack/runtime/global
+(() => {
+__webpack_require__.g = (() => {
+	if (typeof globalThis === 'object') return globalThis;
+	try {
+		return this || new Function('return this')();
+	} catch (e) {
+		if (typeof window === 'object') return window;
+	}
+})();
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/node_module_decorator
+(() => {
+__webpack_require__.nmd = (module) => {
+  module.paths = [];
+  if (!module.children) module.children = [];
+  return module;
+};
+})();
+// webpack/runtime/auto_public_path
+(() => {
+var scriptUrl;
+
+if (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + "";
+var document = __webpack_require__.g.document;
+if (!scriptUrl && document) {
+  // Technically we could use `document.currentScript instanceof window.HTMLScriptElement`,
+  // but an attacker could try to inject `<script>HTMLScriptElement = HTMLImageElement</script>`
+  // and use `<img name="currentScript" src="https://attacker.controlled.server/"></img>`
+  if (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT') scriptUrl = document.currentScript.src;
+  if (!scriptUrl) {
+    var scripts = document.getElementsByTagName("script");
+    if (scripts.length) {
+      var i = scripts.length - 1;
+      while (i > -1 && (!scriptUrl || !/^http(s?):/.test(scriptUrl))) scriptUrl = scripts[i--].src;
+    }
+  }
+}
+
+// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration",
+// or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.',
+if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");
+scriptUrl = scriptUrl.replace(/^blob:/, "").replace(/#.*$/, "").replace(/\?.*$/, "").replace(/\/[^\/]+$/, "/");
+
+__webpack_require__.p = scriptUrl + '../';
+
+})();
+
+export { __webpack_require__ };

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@qualified-salesforce/web",
+  "version": "0.0.1-oidc-bootstrap",
+  "description": "Embeddable Qualified messenger widget for self-hosted deployments.",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "type": "module",
+  "exports": {
+    ".": "./packs/widget/esm/index.js",
+    "./qualified.css": "./packs/widget/esm/qualified.css"
+  },
+  "sideEffects": [
+    "**/*.css",
+    "./js/4101.js",
+    "./js/multimodal_v2.js",
+    "./widget/multimodal_v2/host.string.js",
+    "./widget/multimodal_v2/index.panda.js",
+    "./widget/utils/native_globals.js",
+    "./packs/widget/esm/index.js"
+  ]
+}

package/packs/widget/api/docking/docking_host.js

@@ -0,0 +1,97 @@
+import { Q_DOCKING_TAG_NAME } from "./shared.js";
+import { defineSingletonHost } from "../../../../src/singleton_host.js";
+import { getQualifiedRoot } from "../../../../src/qualified_root.js";
+
+/* eslint-disable rulesdir/css-units */ 
+
+
+/**
+ * Single child of `<q-root>` holding every node the docking system injects. Base
+ * styles, skeleton and matchMedia iframe in the light DOM; in-flight
+ * cross-origin clones in the shadow root.
+ *
+ * Shadow tree from the constructor, so it exists whether or not the host is
+ * mounted. The style waits for connection, which a constructor cannot do and
+ * which re-dresses an adopted host anyway.
+ */ class QDockingElement extends HTMLElement {
+    connectedCallback() {
+        this.style.cssText = "display:contents";
+    }
+    constructor(){
+        super();
+        installShadow(this);
+    }
+}
+/**
+ * Attaches the slotted shadow tree unless the host has one already. The `<slot>`
+ * is what lets the light-DOM children render at all.
+ *
+ * Outside the constructor because a third party can claim the tag, leaving us an
+ * element none of our hooks run on.
+ */ function installShadow(host) {
+    const existing = host.shadowRoot;
+    if (existing) return existing;
+    const shadow = host.attachShadow({
+        mode: "open"
+    });
+    shadow.appendChild(document.createElement("slot"));
+    return shadow;
+}
+const findDockingHost = defineSingletonHost(Q_DOCKING_TAG_NAME, QDockingElement);
+/**
+ * Returns the singleton `<q-docking>` host, creating it under `<q-root>` on
+ * first call. Both are boxless, so the skeleton's `position: fixed` still
+ * resolves against `<html>` as if it were a direct child.
+ */ function getDockingHost() {
+    const host = findDockingHost();
+    const root = getQualifiedRoot();
+    // Corrective for an adopted host parked elsewhere; the move restores its style.
+    if (host.parentNode !== root) root.appendChild(host);
+    // Corrective for a foreign registration's host; no-ops on our own.
+    installShadow(host);
+    if (host.style.display !== "contents") host.style.cssText = "display:contents";
+    return host;
+}
+/** Open shadow root attached to the singleton `<q-docking>` host. */ function getDockingShadowRoot() {
+    return installShadow(getDockingHost());
+}
+/**
+ * Module scope, not a field: a host from a foreign registration is a plain
+ * `HTMLElement`, where a prototype getter would read `undefined` and quietly
+ * unproxy `matchMedia`. A singleton either way.
+ */ let probeIframe = null;
+/**
+ * The invisible iframe inside `<q-docking>` mirroring the constrained viewport,
+ * created on first use. Its `contentWindow` is the single source every viewport
+ * proxy reads: a native `matchMedia` evaluating against the docked width, plus
+ * dimensions that agree with it exactly.
+ *
+ * Sized from `--qdvw` because percentages resolve against the slot's box and end
+ * up `0x0` in Chromium under `display: contents`.
+ *
+ * No `srcdoc`/`src` on purpose: either swaps the document off the initial
+ * about:blank, and MediaQueryLists made before the swap stop firing `change`.
+ */ function getProbeIframe() {
+    const host = getDockingHost();
+    // Recreated when the host was replaced under us (hot reload, or the page moved it).
+    if ((probeIframe == null ? void 0 : probeIframe.parentNode) === host) return probeIframe;
+    const iframe = document.createElement("iframe");
+    iframe.style.cssText = [
+        "position:fixed",
+        "top:0",
+        "left:0",
+        "width:var(" + (/* inlined export .DOCKED_VIEWPORT_WIDTH_CSS_VARIABLE */"--qdvw") + ", 100%)",
+        "height:100dvh",
+        "visibility:hidden",
+        "pointer-events:none",
+        "border:none",
+        "opacity:0",
+        // Below every layout so the invisible probe never wins a stacking-context contest.
+        "z-index:-1"
+    ].join(";");
+    host.appendChild(iframe);
+    probeIframe = iframe;
+    return iframe;
+}
+
+export { getDockingHost, getDockingShadowRoot, getProbeIframe };

package/packs/widget/api/docking/index.js

@@ -0,0 +1,294 @@
+import { __webpack_require__ } from "../../../../js/runtime.js";
+import { getDockingHost } from "./docking_host.js";
+import { withTransitionsDisabled, DOCKED_MODE, DOCKED_TOP_OFFSET_CSS_VARIABLE, dispatchResizeEvent, DOCKED_DOCUMENT_ATTRIBUTE, MOBILE_BREAKPOINT } from "./shared.js";
+import { createViewportLock } from "./viewport_lock.js";
+import { DOCKED_RIGHT_OFFSET_CSS_VARIABLE, createViewportResize } from "./viewport_resize.js";
+import "../../../../widget/utils/native_globals.js";
+import { _extends } from "../../../../js/4101.js";
+import { originalOf } from "../../../../src/proxy.js";
+
+/* provided dependency */ var docking_setTimeout = __webpack_require__(68034).pS;
+/* provided dependency */ var requestAnimationFrame = __webpack_require__(68034).gj;
+/* provided dependency */ var docking_clearTimeout = __webpack_require__(68034).Kj;
+
+/* eslint-disable rulesdir/css-units */ 
+
+
+
+
+// ============================================================================
+// Constants
+// ============================================================================
+const Q_STATE_COOKIE_PREFIX = "__q_state_";
+const BASE_STYLES_ID = "q-docked-base-styles";
+const SKELETON_ID = "q-docked-skeleton";
+const SKELETON_Z_INDEX = 2147483639; // Below widget (2147483640) but above page content
+// Absolute ceiling on how long the page may sit docked without an initState. Deliberately
+// below the 50s worst case of the stage budgets below, so a load that exhausts its full
+// allowance in every stage still gets cut off here rather than stalling the visitor.
+const DOCKING_HARD_ABORT_TIMEOUT_MS = 45000;
+const DOCKING_LOADING_STAGE_TIMEOUTS = {
+    init_qualified: 10000,
+    socket_connection: 15000,
+    init_multimodal: 10000,
+    init_state: 15000
+};
+// ============================================================================
+// Public API Registration
+// ============================================================================
+/**
+ * Registers the docking API on window.qualified.docking.
+ * Returns early if the API is already registered or if window.qualified doesn't exist.
+ * Call this function to expose the docked layout manager as a global API.
+ */ function registerDockingAPI() {
+    if (!window.qualified || window.qualified.docking) return;
+    window.qualified.docking = createDockingAPI();
+}
+/**
+ * Creates the docking API with all state encapsulated in closures.
+ * This is a factory function that returns the public API.
+ */ function createDockingAPI() {
+    /**
+   * Set by the first `init`, whether or not {@link start} ran with it. Docking
+   * below the mobile breakpoint waits for the viewport to grow, and a second
+   * `init` in the meantime must not queue a second wait — `state` is still null
+   * then, so it cannot carry the guard itself.
+   */ let initialized = false;
+    let state = null;
+    let pendingState = null;
+    const init = (config)=>{
+        if (config === void 0) config = {};
+        if (initialized) return;
+        initialized = true;
+        whenAboveMobileBreakpoint(()=>start(config));
+    };
+    /**
+   * Everything `init` does to the host page, held back until the viewport
+   * clears the mobile breakpoint. Creating `state` here is what keeps the page
+   * untouched in the meantime: every other method either returns early on a
+   * null `state` or records into {@link pendingState}, which is folded back in
+   * at the end of this.
+   */ const start = (config)=>{
+        state = {
+            c: config,
+            bs: null,
+            concerns: getConcerns(config),
+            ft: null
+        };
+        withTransitionsDisabled(document.documentElement, ()=>{
+            var _readDockedStateFromCookie;
+            const shouldDock = (_readDockedStateFromCookie = readDockedStateFromCookie()) != null ? _readDockedStateFromCookie : state.c.defaultDocked;
+            if (shouldDock) {
+                enable();
+                state.ft = {
+                    hard: docking_setTimeout(abort, DOCKING_HARD_ABORT_TIMEOUT_MS),
+                    soft: docking_setTimeout(abort, DOCKING_LOADING_STAGE_TIMEOUTS.init_qualified)
+                };
+                // Inform previous scripts that the window resized
+                requestAnimationFrame(()=>dispatchResizeEvent());
+            }
+            // Each concern self-contains its setup. viewport_lock internally captures
+            // the host page's pre-docking scroll position before installing its scroll
+            // proxy, then restores it onto body during reEvaluate (after base styles
+            // make body the scroll container) — no orchestration needed here.
+            for (const concern of state.concerns)concern.init();
+            reEvaluate();
+            if (state.c.showSkeleton) {
+                createSkeleton();
+            }
+            // Inside the transition guard: a pending `disable` undocking the page it
+            // was just docked into should animate no more than the docking did.
+            applyPendingState();
+        });
+    };
+    const enable = ()=>{
+        if (recordedAsPending({
+            docked: true
+        })) return;
+        if (!state) return;
+        // The attribute's value doubles as the layout flag: presence => docked, value
+        // => which mode. Existing `[q-docked]` presence selectors are unaffected.
+        document.documentElement.setAttribute(DOCKED_DOCUMENT_ATTRIBUTE, state.c.dockUnderHeader ? DOCKED_MODE.underHeader : DOCKED_MODE.regular);
+    };
+    const disable = ()=>{
+        if (recordedAsPending({
+            docked: false
+        })) return;
+        if (!state) return;
+        document.documentElement.removeAttribute(DOCKED_DOCUMENT_ATTRIBUTE);
+    };
+    const reEvaluate = ()=>{
+        if (!state) return;
+        createBaseStyles(state);
+        for (const concern of state.concerns)concern.reEvaluate();
+    };
+    const cancelAbort = ()=>{
+        if (recordedAsPending({
+            abortCancelled: true
+        })) return;
+        if (!(state == null ? void 0 : state.ft)) return;
+        docking_clearTimeout(state.ft.hard);
+        docking_clearTimeout(state.ft.soft);
+        state.ft = null;
+    };
+    const setAbortStage = (abortState)=>{
+        if (recordedAsPending({
+            abortStage: abortState
+        })) return;
+        if (!(state == null ? void 0 : state.ft)) return;
+        docking_clearTimeout(state.ft.soft);
+        state.ft.soft = docking_setTimeout(abort, DOCKING_LOADING_STAGE_TIMEOUTS[abortState]);
+    };
+    const isDocked = ()=>{
+        return document.documentElement.hasAttribute(DOCKED_DOCUMENT_ATTRIBUTE);
+    };
+    const abort = ()=>{
+        cancelAbort();
+        disable();
+    };
+    /** Initialized, but still waiting on the breakpoint — nothing to act on yet. */ const isPending = ()=>{
+        return initialized && !state;
+    };
+    /**
+   * Folds `patch` into {@link pendingState} if docking has not started, and
+   * reports whether it did — so a public method can hand off and return in one
+   * line rather than repeating the check and the merge.
+   *
+   * `false` covers both live docking and a page where `init` was never called;
+   * the caller's own `state` guard sorts those out.
+   */ const recordedAsPending = (patch)=>{
+        if (!isPending()) return false;
+        pendingState = _extends({}, pendingState, patch);
+        return true;
+    };
+    /**
+   * Replays {@link pendingState} onto the state `start` just built, through the
+   * same public methods a live caller would have reached.
+   *
+   * Collapsing the calls loses their interleaving, so the fields are applied in
+   * a fixed order and cancellation goes last. That matches the real lifecycle,
+   * where `cancelAbort` is terminal (`initState`, `delay_connect` and
+   * `unauthorized` all end the sequence, and a live `setAbortStage` after one
+   * is already a no-op) and is the safer way to lose the tie: at worst the page
+   * keeps a dock it could have dropped, rather than dropping one out from under
+   * a widget that had reported in.
+   */ const applyPendingState = ()=>{
+        const pending = pendingState;
+        pendingState = null;
+        if (!pending) return;
+        if (pending.docked !== undefined) {
+            if (pending.docked) enable();
+            else disable();
+        }
+        if (pending.abortStage) setAbortStage(pending.abortStage);
+        if (pending.abortCancelled) cancelAbort();
+    };
+    return {
+        init,
+        enable,
+        disable,
+        reEvaluate,
+        isDocked,
+        cancelAbort,
+        setAbortStage
+    };
+}
+/**
+ * Invokes `fn` while the viewport is wider than {@link MOBILE_BREAKPOINT} —
+ * synchronously if it already is, otherwise on the first change that crosses
+ * the breakpoint upwards.
+ *
+ * At or below the breakpoint the docked layout collapses to full width: the
+ * base stylesheet zeroes every docked-width variable inside the same media
+ * query, and the skeleton is hidden outright. Setting docking up anyway would
+ * rewrite the host page's stylesheets, proxy its viewport accessors and move
+ * its scroll container onto `<body>` — all invisible, all risk. Gating on the
+ * breakpoint leaves phones on a page we never touched while still picking
+ * docking up if the window later grows past it.
+ *
+ * The query is read through the pre-patch `matchMedia` because docking's own
+ * proxy repoints `window.matchMedia` at the shrunk content area once it starts,
+ * and the gate is a question about the real viewport.
+ */ function whenAboveMobileBreakpoint(fn) {
+    const { matchMedia } = originalOf(window);
+    const mql = matchMedia.call(window, "(" + MOBILE_BREAKPOINT + ")");
+    if (!mql.matches) {
+        fn();
+        return;
+    }
+    const onChange = ()=>{
+        if (mql.matches) return;
+        mql.removeEventListener("change", onChange);
+        fn();
+    };
+    mql.addEventListener("change", onChange);
+}
+function getConcerns(config) {
+    var _config_skipCrossOriginStylesheets, _config_dockUnderHeader;
+    const concerns = [
+        createViewportResize({
+            skipCrossOriginStylesheets: (_config_skipCrossOriginStylesheets = config.skipCrossOriginStylesheets) != null ? _config_skipCrossOriginStylesheets : false,
+            dockUnderHeader: (_config_dockUnderHeader = config.dockUnderHeader) != null ? _config_dockUnderHeader : false
+        })
+    ];
+    if (!config.dockUnderHeader && !config.disableViewportLock) {
+        concerns.push(createViewportLock());
+    }
+    return concerns;
+}
+// ============================================================================
+// Base Styles
+// ============================================================================
+/**
+ * Creates the combined base stylesheet for docked mode by concatenating CSS
+ * from every registered concern (in `state.concerns` order) into a single
+ * `<style>` element. Kept as a single element (rather than one per concern)
+ * so the host page only sees one injected stylesheet and selector
+ * specificity is predictable across all concerns.
+ */ function createBaseStyles(state) {
+    var _state_bs;
+    if (state.bs && state.bs.isConnected) return;
+    (_state_bs = state.bs) == null ? void 0 : _state_bs.remove();
+    state.bs = document.createElement("style");
+    state.bs.id = BASE_STYLES_ID;
+    state.bs.textContent = state.concerns.map((c)=>c.getStyles()).join("");
+    getDockingHost().appendChild(state.bs);
+}
+// ============================================================================
+// Skeleton
+// ============================================================================
+/**
+ * Creates a loading skeleton element in the docked area.
+ * The skeleton is shown while the widget content is loading.
+ */ function createSkeleton() {
+    const el = document.createElement("div");
+    el.id = SKELETON_ID;
+    el.innerHTML = /* html */ "\n    <style>\n      @keyframes q-shimmer{0%{background-position:-200% 0}to{background-position:200% 0}}\n      /* Skeleton container - hidden by default, shown when docked on desktop */\n      #" + SKELETON_ID + "{display:none;position:fixed;top:var(" + DOCKED_TOP_OFFSET_CSS_VARIABLE + ", 0px);right:var(" + DOCKED_RIGHT_OFFSET_CSS_VARIABLE + ", 0px);width:" + (/* inlined export .DOCKED_WIDTH_PX */400) + "px;height:calc(100% - var(" + DOCKED_TOP_OFFSET_CSS_VARIABLE + ", 0px));background:#fff;box-shadow:-2px 0 8px rgba(0,0,0,.08);z-index:" + SKELETON_Z_INDEX + ";box-sizing:border-box;font-family:system-ui,sans-serif}\n      html[" + DOCKED_DOCUMENT_ATTRIBUTE + "]:not([q-widget-visible]) #" + SKELETON_ID + "{display:flex;flex-direction:column;padding:16px}\n      /* Under-header docking parks the skeleton flush under the host header: swap the drop shadow for a hairline left border (no top border), matching the docked card. */\n      html[" + DOCKED_DOCUMENT_ATTRIBUTE + '="' + DOCKED_MODE.underHeader + '"] #' + SKELETON_ID + "{box-shadow:none;border-left:1px solid #E6E9EC}\n      @media(" + MOBILE_BREAKPOINT + "){html[" + DOCKED_DOCUMENT_ATTRIBUTE + "] #" + SKELETON_ID + '{display:none !important}}\n      .q-sk{background:linear-gradient(90deg,#f0f0f0 25%,#e8e8e8 50%,#f0f0f0 75%);background-size:200% 100%;animation:q-shimmer 1.5s infinite;border-radius:4px}\n      .q-sk-h{display:flex;align-items:center;gap:8px;margin-bottom:16px}\n      .q-sk-av{width:32px;height:32px;border-radius:50%;flex-shrink:0}\n      .q-sk-t{width:100px;height:16px}\n      .q-sk-x{width:24px;height:24px;border-radius:50%;margin-left:auto;flex-shrink:0}\n      .q-sk-v{width:100%;height:200px;border-radius:8px;margin-bottom:16px}\n      .q-sk-p{height:14px;margin-bottom:8px}\n      .q-sk-p:nth-child(2){width:90%}.q-sk-p:nth-child(3){width:75%}\n      .q-sk-sp{flex:1}\n      .q-sk-sg{margin-bottom:16px}\n      .q-sk-l{width:120px;height:12px;margin-bottom:8px}\n      .q-sk-ch{display:flex;flex-direction:column;gap:6px}\n      .q-sk-c{height:20px;border-radius:10px}\n      .q-sk-c:nth-child(1){width:80px}.q-sk-c:nth-child(2){width:100px}.q-sk-c:nth-child(3){width:120px}\n      .q-sk-cp{border:1px solid #e0e0e0;border-radius:8px;padding:12px}\n      .q-sk-in{width:60%;height:16px;margin-bottom:12px}\n      .q-sk-ac{display:flex;align-items:center;gap:8px}\n      .q-sk-bt{width:100px;height:32px;border-radius:16px}\n      .q-sk-ic{width:32px;height:32px;border-radius:50%;margin-left:auto;flex-shrink:0}\n      .q-sk-pr{width:200px;height:10px;margin:12px auto 0}\n    </style>\n    <div class="q-sk-h"><div class="q-sk q-sk-av"></div><div class="q-sk q-sk-t"></div><div class="q-sk q-sk-x"></div></div>\n    <div class="q-sk q-sk-v"></div>\n    <div class="q-sk q-sk-p"></div><div class="q-sk q-sk-p"></div><div class="q-sk q-sk-p"></div>\n    <div class="q-sk-sp"></div>\n    <div class="q-sk-sg"><div class="q-sk q-sk-l"></div><div class="q-sk-ch"><div class="q-sk q-sk-c"></div><div class="q-sk q-sk-c"></div><div class="q-sk q-sk-c"></div></div></div>\n    <div class="q-sk-cp"><div class="q-sk q-sk-in"></div><div class="q-sk-ac"><div class="q-sk q-sk-bt"></div><div class="q-sk q-sk-ic"></div><div class="q-sk q-sk-ic"></div></div></div>\n    <div class="q-sk q-sk-pr"></div>\n  ';
+    getDockingHost().append(el);
+}
+// ============================================================================
+// Cookie Helpers (standalone — no external dependencies)
+// ============================================================================
+/**
+ * Reads the docked flag (`d`) from the first `__q_state_*` cookie.
+ * Finds the cookie by prefix, decodes the base64 JSON value, and extracts `d`.
+ * Returns `true`, `false`, or `null` if the cookie does not exist / cannot be read.
+ */ function readDockedStateFromCookie() {
+    const cookies = document.cookie.split(";");
+    for (const cookie of cookies){
+        const [rawName, ...rest] = cookie.split("=");
+        const name = rawName == null ? void 0 : rawName.trim();
+        if (name && name.startsWith(Q_STATE_COOKIE_PREFIX)) {
+            try {
+                const attrs = JSON.parse(decodeURIComponent(escape(atob(rest.join("=")))));
+                if (typeof attrs !== "object" || attrs === null) return null;
+                return attrs.d === 1 ? true : attrs.d === 0 ? false : null;
+            } catch (unused) {
+                return null;
+            }
+        }
+    }
+    return null;
+}
+
+export { registerDockingAPI };