@peekling/runtime 0.1.0

package/dist/visibility.js

@@ -0,0 +1,333 @@
+import { connectRuntimeHost, ShadowStyleSheet, } from "./styles.js";
+import { runtimeMessage } from "./runtime-diagnostics.js";
+const PREFERENCE_KEY = "peekling:site-preference";
+const SESSION_KEY = "peekling:hidden-session";
+const CORNER_SIZE = 64;
+const HOLD_MS = 1_000;
+const HIDE_OPTIONS = [
+    ["10 minutes", "10-minutes"],
+    ["1 hour", "1-hour"],
+    ["Until tomorrow", "until-tomorrow"],
+    ["Until I return", "session"],
+    ["Forever on this site", "forever"],
+];
+const controllers = new WeakMap();
+function readVisibility(window, now = Date.now()) {
+    try {
+        if (window.sessionStorage.getItem(SESSION_KEY) === "1")
+            return [true];
+        const value = JSON.parse(window.localStorage.getItem(PREFERENCE_KEY) ?? "null");
+        if (value?.visibility !== "hidden")
+            return [false];
+        if (value.until === null)
+            return [true];
+        if (Number.isFinite(value.until) && value.until > now)
+            return [true, value.until];
+        window.localStorage.removeItem(PREFERENCE_KEY);
+    }
+    catch {
+        // Storage is optional. Fail open so a broken preference never traps a host.
+    }
+    return [false];
+}
+function readHidden(window, now = Date.now()) {
+    return readVisibility(window, now)[0];
+}
+function writeHidden(window, duration) {
+    const option = HIDE_OPTIONS.findIndex((item) => item[1] === duration);
+    if (option < 0)
+        throw new TypeError(runtimeMessage("visibility.duration", "Invalid Peekling hide duration"));
+    const now = new Date();
+    const until = option > 2
+        ? undefined
+        : option < 2
+            ? now.getTime() + (option ? 60 : 10) * 60_000
+            : new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1).getTime();
+    try {
+        window.sessionStorage.removeItem(SESSION_KEY);
+        if (option === 3) {
+            window.localStorage.removeItem(PREFERENCE_KEY);
+            window.sessionStorage.setItem(SESSION_KEY, "1");
+            return until;
+        }
+        window.localStorage.setItem(PREFERENCE_KEY, JSON.stringify({
+            visibility: "hidden",
+            until: option === 4 ? null : until,
+        }));
+    }
+    catch {
+        // The current page still hides even when storage is unavailable.
+    }
+    return until;
+}
+function clearHidden(window) {
+    try {
+        window.localStorage.removeItem(PREFERENCE_KEY);
+        window.sessionStorage.removeItem(SESSION_KEY);
+    }
+    catch {
+        // The current page still restores even when storage is unavailable.
+    }
+}
+class SiteVisibilityController {
+    ready;
+    #document;
+    #window;
+    #listeners = new Set();
+    #persistentRemovers = [];
+    #interactionRemovers = [];
+    #host;
+    #root;
+    #panel;
+    #keyboardTrigger;
+    #styles;
+    #styleKey;
+    #styleIntegrity;
+    #hidden;
+    #holdTimer = 0;
+    #expiryTimer = 0;
+    #open = false;
+    #destroyed = false;
+    constructor(document, window, styles) {
+        this.#document = document;
+        this.#window = window;
+        const initial = readVisibility(window);
+        this.#hidden = initial[0];
+        this.#host = document.createElement("div");
+        this.#host.dataset.peeklingControls = "";
+        this.#root = this.#host.attachShadow({ mode: "closed" });
+        this.#styleKey = `${styles.url}\n${styles.integrity ?? ""}`;
+        this.#styleIntegrity = styles.integrity;
+        this.#styles = new ShadowStyleSheet(document, this.#root, styles);
+        this.ready = this.#styles.ready;
+        void this.ready.catch(() => { });
+        this.#keyboardTrigger = document.createElement("button");
+        this.#keyboardTrigger.className = "peekling-visibility-trigger";
+        this.#keyboardTrigger.type = "button";
+        this.#keyboardTrigger.setAttribute("aria-label", "Open Peekling visibility controls");
+        this.#keyboardTrigger.textContent = "🐾";
+        this.#panel = document.createElement("section");
+        this.#panel.className = "peekling-visibility-panel";
+        this.#panel.hidden = true;
+        this.#panel.setAttribute("role", "dialog");
+        this.#panel.setAttribute("aria-label", "Let Peekling rest");
+        const heading = document.createElement("h2");
+        heading.textContent = "Let Peekling rest?";
+        this.#panel.append(heading);
+        for (const [label, duration] of HIDE_OPTIONS) {
+            const button = document.createElement("button");
+            button.className = "peekling-visibility-option";
+            button.type = "button";
+            button.textContent = label;
+            button.addEventListener("click", () => this.hide(duration));
+            this.#panel.append(button);
+        }
+        this.#root.append(this.#keyboardTrigger, this.#panel);
+        this.#repair();
+        this.#listen(window, "storage", () => this.refresh(), this.#persistentRemovers);
+        this.#applyHidden(initial[0], false);
+        this.#scheduleExpiry(initial[1]);
+    }
+    #attachInteractions() {
+        if (this.#interactionRemovers.length)
+            return;
+        this.#listen(this.#document, "pointermove", (event) => {
+            const pointer = event;
+            if (pointer.pointerType === "touch" || pointer.pointerType === "pen")
+                return;
+            this.#updateCorner(pointer.clientX, pointer.clientY);
+        }, this.#interactionRemovers);
+        this.#listen(this.#document, "pointerdown", (event) => {
+            const pointer = event;
+            if (this.#open && !this.#host.contains(event.target))
+                this.close();
+            if (pointer.pointerType === "touch" || pointer.pointerType === "pen")
+                this.#updateCorner(pointer.clientX, pointer.clientY);
+        }, this.#interactionRemovers);
+        for (const type of ["pointerup", "pointercancel", "pointerout"])
+            this.#listen(this.#document, type, (event) => {
+                if (type !== "pointerout" ||
+                    event.relatedTarget === null)
+                    this.#cancelHold();
+            }, this.#interactionRemovers);
+        this.#listen(this.#document, "keydown", (event) => {
+            if (event.key === "Escape")
+                this.close(true);
+        }, this.#interactionRemovers);
+        const open = () => this.open(true);
+        this.#listen(this.#keyboardTrigger, "click", open, this.#interactionRemovers);
+    }
+    #detachInteractions() {
+        this.#cancelHold();
+        this.#remove(this.#interactionRemovers);
+    }
+    register(listener) {
+        this.#listeners.add(listener);
+        listener(this.#hidden);
+        return () => {
+            this.#listeners.delete(listener);
+            if (!this.#listeners.size)
+                this.destroy();
+        };
+    }
+    assertStyles(styles) {
+        if (`${styles.url}\n${styles.integrity ?? ""}` === this.#styleKey)
+            return;
+        if (styles.integrity && styles.integrity === this.#styleIntegrity)
+            return;
+        throw new TypeError(runtimeMessage("visibility.styles-conflict", "Shared visibility stylesheet conflicts with the existing document controller"));
+    }
+    isHidden() {
+        return this.#hidden;
+    }
+    hide(duration) {
+        const until = writeHidden(this.#window, duration);
+        this.#setHidden(true);
+        this.#scheduleExpiry(until);
+        this.close();
+    }
+    show() {
+        clearHidden(this.#window);
+        this.refresh();
+    }
+    refresh() {
+        try {
+            this.#repair();
+        }
+        catch {
+            const listeners = [...this.#listeners];
+            this.destroy();
+            for (const listener of listeners)
+                listener(null);
+            return;
+        }
+        const state = readVisibility(this.#window);
+        this.#setHidden(state[0]);
+        this.#scheduleExpiry(state[1]);
+    }
+    open(focus = false) {
+        if (this.#hidden)
+            return;
+        this.#cancelHold();
+        this.#open = true;
+        this.#host.setAttribute("data-open", "");
+        this.#panel.hidden = false;
+        if (focus)
+            this.#panel.querySelector("button")?.focus();
+    }
+    close(returnFocus = false) {
+        if (!this.#open)
+            return;
+        this.#open = false;
+        this.#host.removeAttribute("data-open");
+        this.#panel.hidden = true;
+        if (returnFocus)
+            this.#keyboardTrigger.focus();
+    }
+    destroy() {
+        if (this.#destroyed)
+            return;
+        this.#destroyed = true;
+        this.#detachInteractions();
+        this.#scheduleExpiry();
+        this.#remove(this.#persistentRemovers);
+        this.#styles.destroy();
+        this.#host.remove();
+        this.#listeners.clear();
+        controllers.delete(this.#document);
+    }
+    #updateCorner(x, y) {
+        if (this.#hidden ||
+            this.#open ||
+            x < this.#window.innerWidth - CORNER_SIZE ||
+            y < this.#window.innerHeight - CORNER_SIZE) {
+            this.#cancelHold();
+            return;
+        }
+        if (!this.#holdTimer)
+            this.#holdTimer = this.#window.setTimeout(() => this.open(), HOLD_MS);
+    }
+    #cancelHold() {
+        if (this.#holdTimer)
+            this.#window.clearTimeout(this.#holdTimer);
+        this.#holdTimer = 0;
+    }
+    #scheduleExpiry(until) {
+        if (this.#expiryTimer)
+            this.#window.clearTimeout(this.#expiryTimer);
+        this.#expiryTimer = 0;
+        if (until === undefined || this.#destroyed)
+            return;
+        const delay = Math.max(0, Math.min(until - Date.now(), 2_147_000_000));
+        this.#expiryTimer = this.#window.setTimeout(() => {
+            this.#expiryTimer = 0;
+            this.refresh();
+        }, delay);
+    }
+    #setHidden(hidden) {
+        if (hidden === this.#hidden)
+            return;
+        this.#applyHidden(hidden, true);
+    }
+    #applyHidden(hidden, notify) {
+        this.#hidden = hidden;
+        this.#host.toggleAttribute("data-hidden", hidden);
+        this.#keyboardTrigger.hidden = hidden;
+        if (hidden)
+            this.#detachInteractions();
+        else
+            this.#attachInteractions();
+        if (notify) {
+            for (const listener of this.#listeners)
+                listener(hidden);
+        }
+    }
+    #listen(target, type, listener, removers) {
+        target.addEventListener(type, listener, { passive: true });
+        removers.push([target, type, listener]);
+    }
+    #remove(bindings) {
+        for (const [target, type, listener] of bindings.splice(0))
+            target.removeEventListener(type, listener);
+    }
+    #repair() {
+        connectRuntimeHost(this.#host, this.#document, "data-peekling-controls");
+        if (this.#root.host !== this.#host ||
+            this.#keyboardTrigger.getRootNode() !== this.#root ||
+            this.#panel.getRootNode() !== this.#root)
+            throw new Error(runtimeMessage("visibility.root", "Peekling visibility root structure was changed"));
+    }
+}
+export function registerSiteVisibility(document, window, listener, styles) {
+    let controller = controllers.get(document);
+    if (!controller) {
+        controller = new SiteVisibilityController(document, window, styles);
+        controllers.set(document, controller);
+    }
+    else
+        controller.assertStyles(styles);
+    return { unregister: controller.register(listener), ready: controller.ready };
+}
+export function hidePeekling(duration, document = globalThis.document, window = globalThis.window) {
+    if (!document || !window)
+        throw new Error(runtimeMessage("browser.context", "Browser document/window required"));
+    const controller = controllers.get(document);
+    if (controller)
+        controller.hide(duration);
+    else
+        writeHidden(window, duration);
+}
+export function showPeekling(document = globalThis.document, window = globalThis.window) {
+    if (!document || !window)
+        throw new Error(runtimeMessage("browser.context", "Browser document/window required"));
+    const controller = controllers.get(document);
+    if (controller)
+        controller.show();
+    else
+        clearHidden(window);
+}
+export function isPeeklingHidden(window = globalThis.window) {
+    if (!window)
+        throw new Error(runtimeMessage("browser.window", "Browser window required"));
+    return controllers.get(window.document)?.isHidden() ?? readHidden(window);
+}

package/dist/web-component.d.ts

@@ -0,0 +1,31 @@
+import { type PeeklingInstance, type PeeklingOptions } from "./runtime.js";
+import type { Plan, DiagnosticRecord, EmitResult, HostBindings, HostContent, OverrideInput, OverrideHandle, SurfaceTheme } from "./types.js";
+export declare const PEEKLING_ELEMENT_TAG = "peekling-character";
+export declare function reportBrowserCollision(name: string): void;
+export interface PeeklingElement extends HTMLElement {
+    options: PeeklingOptions;
+    plan?: Plan;
+    content?: HostContent;
+    bindings?: HostBindings;
+    theme?: SurfaceTheme;
+    styles?: PeeklingOptions["styles"];
+    accessibility?: PeeklingOptions["accessibility"];
+    diagnostics?: PeeklingOptions["diagnostics"];
+    logger?: (record: Readonly<DiagnosticRecord>) => void;
+    readonly instance?: PeeklingInstance;
+    readonly ready: Promise<PeeklingInstance>;
+    emit(name: string, payload?: unknown): EmitResult;
+    override(value: OverrideInput): OverrideHandle;
+    pause(): void;
+    resume(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "peekling-character": PeeklingElement;
+    }
+    interface WindowEventMap {
+        "peekling:collision": CustomEvent<"Peekling" | typeof PEEKLING_ELEMENT_TAG>;
+    }
+}
+export declare function definePeeklingElement(): void;
+//# sourceMappingURL=web-component.d.ts.map

package/dist/web-component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-component.d.ts","sourceRoot":"","sources":["../src/web-component.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACrB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EACV,IAAI,EACJ,gBAAgB,EAChB,UAAU,EACV,YAAY,EACZ,WAAW,EACX,aAAa,EACb,cAAc,EACd,YAAY,EACb,MAAM,YAAY,CAAC;AAIpB,eAAO,MAAM,oBAAoB,uBAAuB,CAAC;AAIzD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAQzD;AAED,MAAM,WAAW,eAAgB,SAAQ,WAAW;IAClD,OAAO,EAAE,eAAe,CAAC;IACzB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,MAAM,CAAC,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAC;IACnC,aAAa,CAAC,EAAE,eAAe,CAAC,eAAe,CAAC,CAAC;IACjD,WAAW,CAAC,EAAE,eAAe,CAAC,aAAa,CAAC,CAAC;IAC7C,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,KAAK,IAAI,CAAC;IACtD,QAAQ,CAAC,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC1C,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,UAAU,CAAC;IAClD,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,cAAc,CAAC;IAC/C,KAAK,IAAI,IAAI,CAAC;IACd,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,oBAAoB,EAAE,eAAe,CAAC;KACvC;IACD,UAAU,cAAc;QACtB,oBAAoB,EAAE,WAAW,CAAC,UAAU,GAAG,OAAO,oBAAoB,CAAC,CAAC;KAC7E;CACF;AAmBD,wBAAgB,qBAAqB,IAAI,IAAI,CA6O5C"}

package/dist/web-component.js

@@ -0,0 +1,236 @@
+import { PeeklingRuntime, } from "./runtime.js";
+import { runtimeMessage } from "./runtime-diagnostics.js";
+import { OwnDataError, snapshotConfiguration } from "./own-data.js";
+export const PEEKLING_ELEMENT_TAG = "peekling-character";
+let disconnectedRequestId = 0;
+let supportedElement;
+export function reportBrowserCollision(name) {
+    try {
+        globalThis.dispatchEvent(new CustomEvent("peekling:collision", {
+            detail: name,
+        }));
+    }
+    catch { }
+}
+function readyState() {
+    let resolve;
+    let reject;
+    const promise = new Promise((accept, decline) => {
+        resolve = accept;
+        reject = decline;
+    });
+    void promise.catch(() => { });
+    return [promise, resolve, reject];
+}
+export function definePeeklingElement() {
+    try {
+        const registry = globalThis.customElements;
+        const Base = globalThis.HTMLElement;
+        if (!registry || !Base)
+            return;
+        const existing = registry.get(PEEKLING_ELEMENT_TAG);
+        if (existing) {
+            if (existing !== supportedElement) {
+                reportBrowserCollision(PEEKLING_ELEMENT_TAG);
+            }
+            return;
+        }
+        class PeeklingElement extends Base {
+            static observedAttributes = [
+                "character",
+                "pack-url",
+                "name",
+                "styles-url",
+                "styles-integrity",
+            ];
+            static {
+                for (const key of [
+                    "plan",
+                    "content",
+                    "bindings",
+                    "theme",
+                    "styles",
+                    "accessibility",
+                    "diagnostics",
+                    "logger",
+                ]) {
+                    Object.defineProperty(this.prototype, key, {
+                        configurable: true,
+                        get() {
+                            return this.#overrides[key];
+                        },
+                        set(value) {
+                            this.#set(key, value);
+                        },
+                    });
+                }
+            }
+            #instance;
+            #options = Object.create(null);
+            #optionsError;
+            #overrides = Object.create(null);
+            #scheduled = false;
+            #mountedOnce = false;
+            #generation = 0;
+            #ready = readyState();
+            #pageShow = (event) => {
+                if (event.persisted)
+                    this.#remount();
+            };
+            /** Full JavaScript API configuration. Scalar attributes override matching fields. */
+            get options() {
+                return this.#options;
+            }
+            set options(value) {
+                try {
+                    this.#options = snapshotConfiguration(value);
+                    this.#optionsError = undefined;
+                }
+                catch (error) {
+                    this.#options = Object.create(null);
+                    this.#optionsError = error;
+                }
+                this.#remount();
+            }
+            get instance() {
+                return this.#instance;
+            }
+            /** Resolves when the current connected mount is fully initialized. */
+            get ready() {
+                return this.#ready[0];
+            }
+            emit(name, payload) {
+                return (this.#instance?.emit(name, payload) ?? {
+                    accepted: false,
+                    reason: "not-ready",
+                });
+            }
+            override(value) {
+                if (!this.#instance) {
+                    const id = `override:disconnected:${++disconnectedRequestId}`;
+                    return {
+                        id,
+                        status: "rejected",
+                        finished: Promise.resolve({ id, reason: "rejected" }),
+                        cancel: () => { },
+                    };
+                }
+                return this.#instance.override(value);
+            }
+            pause() {
+                this.#instance?.pause();
+            }
+            resume() {
+                this.#instance?.resume();
+            }
+            connectedCallback() {
+                globalThis.addEventListener?.("pageshow", this.#pageShow);
+                this.#remount();
+            }
+            attributeChangedCallback(name) {
+                const attribute = this.getAttribute("name");
+                if (name === "name" &&
+                    this.#instance &&
+                    this.#instance.updateComponentName(attribute === null
+                        ? this.#options.name
+                        : attribute || true)) {
+                    return;
+                }
+                this.#remount();
+            }
+            disconnectedCallback() {
+                globalThis.removeEventListener?.("pageshow", this.#pageShow);
+                this.#generation += 1;
+                this.#scheduled = false;
+                this.#ready[2](new DOMException(runtimeMessage("element.disconnected", "Element disconnected"), "AbortError"));
+                this.#instance?.destroy();
+                this.#instance = undefined;
+            }
+            #set(key, value) {
+                if (value === undefined)
+                    delete this.#overrides[key];
+                else
+                    this.#overrides[key] = value;
+                this.#remount();
+            }
+            #remount() {
+                if (!this.isConnected || this.#scheduled)
+                    return;
+                this.#scheduled = true;
+                const generation = ++this.#generation;
+                if (this.#mountedOnce) {
+                    this.#ready[2](new DOMException(runtimeMessage("element.remounted", "Element remounted"), "AbortError"));
+                    this.#ready = readyState();
+                }
+                else
+                    this.#mountedOnce = true;
+                queueMicrotask(() => {
+                    if (generation !== this.#generation)
+                        return;
+                    this.#scheduled = false;
+                    if (!this.isConnected)
+                        return;
+                    this.#instance?.destroy();
+                    this.#instance = undefined;
+                    void this.#mount(generation);
+                });
+            }
+            async #mount(generation) {
+                try {
+                    if (this.#optionsError)
+                        throw this.#optionsError;
+                    if (!this.#options ||
+                        typeof this.#options !== "object" ||
+                        Array.isArray(this.#options)) {
+                        throw new OwnDataError("$", runtimeMessage("data.plain", "must use this realm's Object prototype or a null prototype"));
+                    }
+                    const configured = Object.create(null);
+                    for (const source of [
+                        this.#options,
+                        this.#overrides,
+                    ]) {
+                        for (const key in source) {
+                            configured[key] = source[key];
+                        }
+                    }
+                    const character = this.getAttribute("character");
+                    if (character !== null)
+                        configured.character = character;
+                    const packUrl = this.getAttribute("pack-url");
+                    if (packUrl !== null)
+                        configured.packUrl = packUrl;
+                    const name = this.getAttribute("name");
+                    if (name !== null)
+                        configured.name = name || true;
+                    const stylesUrl = this.getAttribute("styles-url");
+                    if (stylesUrl !== null) {
+                        const stylesIntegrity = this.getAttribute("styles-integrity");
+                        configured.styles = stylesIntegrity
+                            ? { url: stylesUrl, integrity: stylesIntegrity }
+                            : { url: stylesUrl };
+                    }
+                    const instance = PeeklingRuntime.hatch(configured);
+                    this.#instance = instance;
+                    await instance.ready;
+                    if (generation !== this.#generation || !this.isConnected) {
+                        instance.destroy();
+                        return;
+                    }
+                    this.#ready[1](instance);
+                }
+                catch (error) {
+                    if (generation !== this.#generation)
+                        return;
+                    this.#instance?.destroy();
+                    this.#instance = undefined;
+                    this.#ready[2](error);
+                }
+            }
+        }
+        registry.define(PEEKLING_ELEMENT_TAG, PeeklingElement);
+        supportedElement = PeeklingElement;
+    }
+    catch {
+        reportBrowserCollision(PEEKLING_ELEMENT_TAG);
+    }
+}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@peekling/runtime",
+  "version": "0.1.0",
+  "description": "Dependency-free browser runtime for interactive Peekling characters",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Prajwal S. Venkateshmurthy",
+    "url": "https://prajwal.me"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/peekling/peekling-engine.git"
+  },
+  "homepage": "https://github.com/peekling/peekling-engine#readme",
+  "bugs": {
+    "url": "https://github.com/peekling/peekling-engine/issues"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=22.14.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "sideEffects": [
+    "./dist/peekling.min.js"
+  ],
+  "files": [
+    "dist/**/*.js",
+    "dist/*.css",
+    "dist/*.sri",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.ts.map",
+    "!dist/arbiter.*",
+    "!dist/browser.*",
+    "!dist/requests.*",
+    "README.md",
+    "LICENSE",
+    "NOTICE",
+    "AUTHORS",
+    "LICENSING.md"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "jsdelivr": "./dist/peekling.min.js",
+  "unpkg": "./dist/peekling.min.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./pack": {
+      "types": "./dist/pack-api.d.ts",
+      "import": "./dist/pack-api.js"
+    },
+    "./preflight": {
+      "types": "./dist/preflight-api.d.ts",
+      "import": "./dist/preflight-api.js"
+    },
+    "./browser": "./dist/peekling.min.js",
+    "./peekling.css": "./dist/peekling.css"
+  },
+  "dependencies": {},
+  "scripts": {
+    "build": "tsc -b",
+    "prepack": "npm --prefix ../.. run build",
+    "test": "npm run build && node --test --experimental-strip-types test/*.test.ts",
+    "typecheck": "tsc -b --pretty false"
+  },
+  "devDependencies": {
+    "typescript": "^7.0.2"
+  }
+}