@dl2app/react-native 0.0.0-stage → 0.1.0

package/build/src/core.js

@@ -0,0 +1,833 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_VERSION = void 0;
+exports.parseUrl = parseUrl;
+exports.extractClipboardToken = extractClipboardToken;
+exports.createDL2 = createDL2;
+exports.SDK_VERSION = "0.1.0";
+const K_ID = "install_id";
+const K_DONE = "first_launch_done";
+const K_ATTEMPTS = "open_attempts";
+const K_QUEUE = "event_queue";
+const K_REFERRER = "install_referrer";
+const RESOLVE_TIMEOUT_MS = 3000;
+const EVENT_TIMEOUT_MS = 5000;
+const REFERRER_TIMEOUT_MS = 1500;
+const DEDUPE_MS = 2000;
+const MAX_QUEUED_EVENTS = 100;
+const MAX_PENDING_LINKS = 20;
+const MAX_OPEN_ATTEMPTS = 3;
+const RETRY_BASE_MS = 2000;
+const RETRY_MAX_MS = 300000;
+function mkErr(code, message, cause, status) {
+    const e = { code, message };
+    if (cause !== undefined)
+        e.cause = cause;
+    if (status !== undefined)
+        e.status = status;
+    return e;
+}
+function isErr(e) {
+    return !!e && typeof e === "object" && typeof e.code === "string" && typeof e.message === "string";
+}
+function toErr(e, message) {
+    return isErr(e) ? e : mkErr("unknown", message, e);
+}
+function decode(s) {
+    try {
+        return decodeURIComponent(s.replace(/\+/g, " "));
+    }
+    catch {
+        return s;
+    }
+}
+/** Small URL parser: React Native's built-in `URL` is incomplete on some versions. */
+function parseUrl(url) {
+    if (typeof url !== "string")
+        return null;
+    const m = /^([a-z][a-z0-9+.-]*):(?:\/\/([^/?#]*))?([^?#]*)(?:\?([^#]*))?/i.exec(url.trim());
+    if (!m)
+        return null;
+    const scheme = m[1].toLowerCase();
+    const web = scheme === "http" || scheme === "https";
+    const authority = (m[2] || "").replace(/^[^@]*@/, "");
+    const host = authority.replace(/:\d+$/, "").toLowerCase();
+    // myapp://product/42 means the path /product/42: a custom scheme has no real host.
+    let path = web ? m[3] : (authority ? "/" + authority : "") + m[3];
+    if (path.charAt(0) !== "/")
+        path = "/" + path;
+    const params = {};
+    for (const pair of (m[4] || "").split("&")) {
+        if (!pair)
+            continue;
+        const i = pair.indexOf("=");
+        params[decode(i < 0 ? pair : pair.slice(0, i))] = i < 0 ? "" : decode(pair.slice(i + 1));
+    }
+    return { scheme, host: web ? host : "", path, params };
+}
+/** Finds a DL2 clipboard token (`dl2:{clickId}:{signature}`) in pasted text. */
+function extractClipboardToken(text) {
+    if (typeof text !== "string")
+        return null;
+    const m = /dl2:[A-Za-z0-9_-]{6,64}:[A-Za-z0-9_-]{6,128}/.exec(text);
+    return m ? m[0] : null;
+}
+function fallbackUuid(random) {
+    const c = globalThis.crypto;
+    if (c && typeof c.randomUUID === "function")
+        return c.randomUUID();
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (ch) => {
+        const r = (random() * 16) | 0;
+        return (ch === "x" ? r : (r & 3) | 8).toString(16);
+    });
+}
+function createDL2(deps) {
+    const now = deps.now || (() => Date.now());
+    const random = deps.random || Math.random;
+    const sleep = deps.sleep || ((ms) => new Promise((r) => setTimeout(r, ms)));
+    let cfg = null;
+    let gen = 0;
+    let installId = null;
+    let firstLaunch = false;
+    let storageOk = true;
+    let matched = false;
+    let info = null;
+    let ready = null;
+    let initial = null;
+    let sub = null;
+    const listeners = new Set();
+    let pending = [];
+    let lastUrl = "";
+    let lastAt = 0;
+    let lastHandled = null;
+    let queue = [];
+    let flushing = null;
+    let retries = 0;
+    let retryTimer = null;
+    let lastOpenResponse = null;
+    let lastResolveResponse = null;
+    let lastError = null;
+    // Kept across reset() so a handler passed once keeps receiving errors.
+    let onError;
+    let debug = false;
+    function log(...args) {
+        if (!debug)
+            return;
+        try {
+            console.log("[DL2]", ...args);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    function report(e, context) {
+        const err = toErr(e, context);
+        lastError = err;
+        log("error:", context, err.code, err.message);
+        try {
+            if (onError)
+                onError(err);
+        }
+        catch {
+            /* the app's handler threw: nothing more to do */
+        }
+    }
+    /** Runs a public method body. Nothing thrown inside ever reaches the host app. */
+    function guard(context, fallback, fn) {
+        try {
+            return fn();
+        }
+        catch (e) {
+            report(e, context);
+            return fallback;
+        }
+    }
+    async function guardAsync(context, fallback, fn) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            report(e, context);
+            return fallback;
+        }
+    }
+    // ---- storage -----------------------------------------------------------------------------
+    const memory = {};
+    async function getItem(key) {
+        if (!deps.native)
+            return key in memory ? memory[key] : null;
+        try {
+            const v = await deps.native.getItem(key);
+            return typeof v === "string" ? v : null;
+        }
+        catch (e) {
+            storageOk = false;
+            report(mkErr("unknown", "Could not read from native storage", e), "storage");
+            return key in memory ? memory[key] : null;
+        }
+    }
+    async function setItem(key, value) {
+        memory[key] = value;
+        if (!deps.native)
+            return;
+        try {
+            await deps.native.setItem(key, value);
+        }
+        catch (e) {
+            storageOk = false;
+            report(mkErr("unknown", "Could not write to native storage", e), "storage");
+        }
+    }
+    async function removeItem(key) {
+        delete memory[key];
+        if (!deps.native)
+            return;
+        try {
+            await deps.native.removeItem(key);
+        }
+        catch (e) {
+            report(mkErr("unknown", "Could not remove from native storage", e), "storage");
+        }
+    }
+    // ---- network -----------------------------------------------------------------------------
+    function httpError(status, body) {
+        const raw = body?.error;
+        const serverCode = raw && typeof raw.code === "string" ? raw.code : "";
+        const known = {
+            invalid_key: "invalid_key",
+            unauthorized: "invalid_key",
+            app_mismatch: "app_mismatch",
+            link_not_found: "link_not_found",
+            not_found: "link_not_found",
+            rate_limited: "rate_limited",
+        };
+        const byStatus = {
+            401: "invalid_key",
+            404: "link_not_found",
+            422: "app_mismatch",
+            429: "rate_limited",
+        };
+        const code = known[serverCode] || byStatus[status] || "unknown";
+        const message = (raw && typeof raw.message === "string" && raw.message) || `Request failed with status ${status}`;
+        return mkErr(code, message, serverCode || undefined, status);
+    }
+    /**
+     * POSTs JSON to the SDK API. `timeoutMs` is the budget for the whole call including the one
+     * retry, which happens only when the request never reached the server (network error).
+     */
+    function call(path, body, timeoutMs) {
+        const c = cfg;
+        if (!c)
+            return Promise.reject(mkErr("not_configured", "Call DL2.configure() first"));
+        return new Promise((resolve, reject) => {
+            const ctrl = typeof AbortController === "function" ? new AbortController() : null;
+            let done = false;
+            const timer = setTimeout(() => {
+                done = true;
+                reject(mkErr("timeout", `No response from ${path} within ${timeoutMs} ms`));
+                try {
+                    if (ctrl)
+                        ctrl.abort();
+                }
+                catch {
+                    /* ignore */
+                }
+            }, timeoutMs);
+            const attempt = async (n) => {
+                let res;
+                try {
+                    res = await deps.fetch(c.base + path, {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json", "X-DL2-Key": c.key },
+                        body: JSON.stringify(body),
+                        signal: ctrl ? ctrl.signal : undefined,
+                    });
+                }
+                catch (e) {
+                    if (done || n >= 1)
+                        throw mkErr("network", "Network request failed", e);
+                    await sleep(200 + random() * 400);
+                    if (done)
+                        throw mkErr("network", "Network request failed", e);
+                    return attempt(n + 1);
+                }
+                let json = null;
+                try {
+                    json = await res.json();
+                }
+                catch {
+                    /* empty or non-JSON body */
+                }
+                if (!res.ok)
+                    throw httpError(res.status, json);
+                return json;
+            };
+            attempt(0).then((v) => {
+                clearTimeout(timer);
+                if (!done)
+                    resolve(v);
+            }, (e) => {
+                clearTimeout(timer);
+                if (!done)
+                    reject(e);
+            });
+        });
+    }
+    // ---- link events -------------------------------------------------------------------------
+    function emit(event) {
+        log("link event", event);
+        if (listeners.size === 0) {
+            pending.push(event);
+            if (pending.length > MAX_PENDING_LINKS)
+                pending.shift();
+            return;
+        }
+        for (const l of Array.from(listeners)) {
+            try {
+                l(event);
+            }
+            catch (e) {
+                report(mkErr("unknown", "An onLink listener threw", e), "onLink");
+            }
+        }
+    }
+    function sourceOf(p) {
+        if (p.scheme !== "http" && p.scheme !== "https")
+            return "uri_scheme";
+        return deps.platform === "android" ? "app_link" : "universal_link";
+    }
+    function isOurs(p) {
+        if (!cfg)
+            return false;
+        if (p.scheme === "http" || p.scheme === "https")
+            return cfg.domains.indexOf(p.host) >= 0;
+        return !!cfg.scheme && p.scheme === cfg.scheme;
+    }
+    function toEvent(payload, url, source, isFirstOpen) {
+        const local = url ? parseUrl(url) : null;
+        const remote = payload && payload.url ? parseUrl(payload.url) : null;
+        const event = {
+            url: url || (payload && payload.url) || null,
+            path: (payload && payload.path) || (local ? local.path : "/"),
+            params: { ...(remote ? remote.params : {}), ...(local ? local.params : {}) },
+            data: (payload && payload.data && typeof payload.data === "object" ? payload.data : {}),
+            source,
+            isFirstOpen,
+        };
+        if (payload) {
+            if (payload.match_method)
+                event.matchMethod = payload.match_method;
+            if (typeof payload.confidence === "number")
+                event.confidence = payload.confidence;
+            if (payload.link_id)
+                event.linkId = payload.link_id;
+            if (payload.utm)
+                event.utm = payload.utm;
+        }
+        return event;
+    }
+    async function deviceInfo() {
+        if (info)
+            return info;
+        let native = {};
+        try {
+            if (deps.native)
+                native = (await deps.native.getDeviceInfo()) || {};
+        }
+        catch (e) {
+            report(mkErr("unknown", "Could not read device info", e), "deviceInfo");
+        }
+        let lang = native.lang;
+        let tz = native.tz;
+        try {
+            const o = Intl.DateTimeFormat().resolvedOptions();
+            lang = lang || o.locale;
+            tz = tz || o.timeZone;
+        }
+        catch {
+            /* Intl missing on this engine */
+        }
+        info = { osVersion: native.osVersion || "", appId: native.appId || "", appVersion: native.appVersion || "", lang: lang || "", tz: tz || "" };
+        return info;
+    }
+    /** Request body of POST /v1/sdk/open. Every field is always present. */
+    async function openBody(extra) {
+        const d = await deviceInfo();
+        let screen = { w: 0, h: 0, dpr: 1 };
+        try {
+            screen = deps.screen();
+        }
+        catch {
+            /* keep defaults */
+        }
+        return {
+            install_id: installId,
+            is_first_launch: firstLaunch,
+            platform: deps.platform,
+            os_version: d.osVersion,
+            app_id_hint: d.appId,
+            app_version: d.appVersion,
+            sdk_version: exports.SDK_VERSION,
+            screen,
+            lang: d.lang,
+            tz: d.tz,
+            install_referrer: extra.install_referrer || null,
+            clipboard_token: extra.clipboard_token || null,
+            launch_url: extra.launch_url || null,
+        };
+    }
+    /** True when the server answered, so there is no point asking again on the next launch. */
+    function answered(e) {
+        return !(isErr(e) && (e.code === "network" || e.code === "timeout"));
+    }
+    async function finishFirstLaunch(serverAnswered) {
+        if (!firstLaunch || !storageOk)
+            return;
+        const attempts = (parseInt((await getItem(K_ATTEMPTS)) || "0", 10) || 0) + 1;
+        if (serverAnswered || attempts >= MAX_OPEN_ATTEMPTS) {
+            await setItem(K_DONE, "1");
+            await removeItem(K_ATTEMPTS);
+        }
+        else {
+            // Offline on first launch: ask again next launch, a few times at most.
+            await setItem(K_ATTEMPTS, String(attempts));
+        }
+    }
+    /**
+     * Handles a URL that opened the app. Returns undefined when the URL is not a DL2 link, the
+     * event otherwise (the same event for a duplicate delivery within 2 seconds).
+     */
+    function handleUrl(url, isInitial) {
+        const p = parseUrl(url);
+        if (!p || !isOurs(p))
+            return undefined;
+        const t = now();
+        if (url === lastUrl && t - lastAt < DEDUPE_MS && lastHandled)
+            return lastHandled;
+        lastUrl = url;
+        lastAt = t;
+        const g = gen;
+        const source = sourceOf(p);
+        lastHandled = (async () => {
+            if (ready)
+                await ready;
+            const first = isInitial && firstLaunch;
+            let payload = null;
+            let ok = false;
+            try {
+                if (first) {
+                    const r = await call("/v1/sdk/open", await openBody({ launch_url: url }), RESOLVE_TIMEOUT_MS);
+                    lastOpenResponse = r;
+                    payload = (r && r.match) || null;
+                    ok = true;
+                }
+                else {
+                    payload = await call("/v1/sdk/resolve", { url, source }, RESOLVE_TIMEOUT_MS);
+                    lastResolveResponse = payload;
+                }
+            }
+            catch (e) {
+                ok = answered(e);
+                report(e, "resolve");
+            }
+            if (g !== gen)
+                return null;
+            if (first)
+                await finishFirstLaunch(ok);
+            // On any failure the event is built from the URL itself so the app still navigates.
+            const event = toEvent(payload, url, source, first);
+            emit(event);
+            return event;
+        })().catch((e) => {
+            report(e, "handleUrl");
+            return null;
+        });
+        return lastHandled;
+    }
+    async function init(g) {
+        let id = await getItem(K_ID);
+        if (!id) {
+            try {
+                id = deps.native && deps.native.uuid ? await deps.native.uuid() : null;
+            }
+            catch {
+                id = null;
+            }
+            id = id || fallbackUuid(random);
+            await setItem(K_ID, id);
+        }
+        const done = await getItem(K_DONE);
+        let stored = null;
+        try {
+            stored = JSON.parse((await getItem(K_QUEUE)) || "[]");
+        }
+        catch {
+            /* corrupt queue: start empty */
+        }
+        if (g !== gen)
+            return;
+        installId = id;
+        // Without working storage every launch would look like the first one and could claim
+        // someone else's link, so deferred matching is skipped.
+        firstLaunch = storageOk && !!deps.native && done !== "1";
+        if (Array.isArray(stored))
+            queue = stored.concat(queue).slice(-MAX_QUEUED_EVENTS);
+        if (!deps.native) {
+            report(mkErr("unknown", "DL2 native module not found. Rebuild the app (Expo Go is not supported); deferred links are off."), "configure");
+        }
+    }
+    async function runInitial(g) {
+        await ready;
+        if (g !== gen || !cfg)
+            return null;
+        let url = null;
+        try {
+            url = await deps.linking.getInitialURL();
+        }
+        catch (e) {
+            report(mkErr("unknown", "Linking.getInitialURL failed", e), "configure");
+        }
+        if (g !== gen || !cfg)
+            return null;
+        const handled = url ? handleUrl(url, true) : undefined;
+        if (handled)
+            return handled;
+        if (!firstLaunch)
+            return null;
+        if (!cfg.deferred) {
+            await finishFirstLaunch(true);
+            return null;
+        }
+        let referrer = null;
+        if (deps.platform === "android" && deps.native) {
+            try {
+                referrer = await Promise.race([
+                    deps.native.getInstallReferrer(),
+                    sleep(REFERRER_TIMEOUT_MS).then(() => null),
+                ]);
+            }
+            catch (e) {
+                report(mkErr("unknown", "Could not read the install referrer", e), "installReferrer");
+            }
+        }
+        let event = null;
+        let ok = false;
+        try {
+            const r = await call("/v1/sdk/open", await openBody({ install_referrer: referrer }), cfg.timeoutMs);
+            lastOpenResponse = r;
+            ok = true;
+            if (g === gen && r && r.match) {
+                matched = true;
+                event = toEvent(r.match, null, "deferred", true);
+            }
+        }
+        catch (e) {
+            ok = answered(e);
+            report(e, "deferred");
+        }
+        if (g !== gen)
+            return null;
+        await finishFirstLaunch(ok);
+        if (event)
+            emit(event);
+        return event;
+    }
+    // ---- events ------------------------------------------------------------------------------
+    function persistQueue() {
+        const g = gen;
+        // After init has merged the stored queue, or an early write would be read back and doubled.
+        (ready || Promise.resolve())
+            .then(() => (g === gen ? setItem(K_QUEUE, JSON.stringify(queue)) : undefined))
+            .catch(() => undefined);
+    }
+    function retryable(e) {
+        if (!isErr(e))
+            return false;
+        return e.code === "network" || e.code === "timeout" || e.code === "rate_limited" || (e.status || 0) >= 500;
+    }
+    function flush() {
+        if (flushing)
+            return flushing;
+        if (!cfg)
+            return Promise.resolve();
+        if (retryTimer) {
+            clearTimeout(retryTimer);
+            retryTimer = null;
+        }
+        const g = gen;
+        flushing = (async () => {
+            // Wait for the launch check so the server knows this install before its first event.
+            if (initial)
+                await initial;
+            while (queue.length && g === gen && cfg) {
+                const e = queue[0];
+                try {
+                    await call("/v1/sdk/event", { install_id: installId, ...e }, EVENT_TIMEOUT_MS);
+                }
+                catch (err) {
+                    if (g !== gen)
+                        return;
+                    if (retryable(err)) {
+                        // Keep the event and try again later: 2 s, 4 s, 8 s ... capped at 5 minutes.
+                        const delay = Math.min(RETRY_BASE_MS * Math.pow(2, retries), RETRY_MAX_MS) * (0.5 + random() / 2);
+                        retries++;
+                        log("event delivery failed, retrying in", Math.round(delay), "ms");
+                        retryTimer = setTimeout(() => {
+                            retryTimer = null;
+                            flush().catch(() => undefined);
+                        }, delay);
+                        return;
+                    }
+                    report(err, "track"); // rejected by the server: drop it
+                }
+                if (g !== gen)
+                    return;
+                const i = queue.indexOf(e);
+                if (i >= 0)
+                    queue.splice(i, 1);
+                persistQueue();
+            }
+            retries = 0;
+        })()
+            .catch((e) => report(e, "flush"))
+            .then(() => {
+            flushing = null;
+        });
+        return flushing;
+    }
+    // ---- public API --------------------------------------------------------------------------
+    function configure(config) {
+        guard("configure", undefined, () => {
+            if (config && typeof config.onError === "function")
+                onError = config.onError;
+            if (config && typeof config.debug === "boolean")
+                debug = config.debug;
+            if (cfg) {
+                cfg.onError = onError;
+                cfg.debug = debug;
+                log("configure() called again: ignored");
+                return;
+            }
+            if (!config || typeof config.publishableKey !== "string" || !config.publishableKey.trim()) {
+                throw mkErr("not_configured", "configure() needs a publishableKey (pk_live_...)");
+            }
+            if (!Array.isArray(config.linkDomains) || !config.linkDomains.length) {
+                throw mkErr("not_configured", "configure() needs linkDomains, for example ['myapp.dl2.app', 'myapp-alt.dl2.app']");
+            }
+            const d = config.deferred || {};
+            cfg = {
+                key: config.publishableKey.trim(),
+                domains: config.linkDomains
+                    .filter((h) => typeof h === "string")
+                    .map((h) => h.trim().toLowerCase().replace(/^https?:\/\//, "").replace(/[/:].*$/, "")),
+                scheme: (config.uriScheme || "").toLowerCase().replace(/:\/\/.*$/, ""),
+                base: (config.apiBaseUrl || "https://api.dl2.app").replace(/\/+$/, ""),
+                deferred: d.enabled !== false,
+                timeoutMs: typeof d.timeoutMs === "number" && d.timeoutMs > 0 ? d.timeoutMs : 4000,
+                clipboard: d.useClipboard === true,
+                debug,
+                onError,
+            };
+            const g = ++gen;
+            // Subscribe before anything asynchronous so a warm link cannot slip past.
+            try {
+                const s = deps.linking.addEventListener("url", (e) => {
+                    guard("url event", undefined, () => {
+                        if (e && typeof e.url === "string")
+                            handleUrl(e.url, false);
+                    });
+                });
+                sub = s && typeof s.remove === "function" ? s : null;
+            }
+            catch (e) {
+                report(mkErr("unknown", "Linking.addEventListener failed", e), "configure");
+            }
+            ready = init(g).catch((e) => report(e, "configure"));
+            initial = runInitial(g).catch((e) => {
+                report(e, "configure");
+                return null;
+            });
+            initial.then(() => flush()).catch(() => undefined);
+        });
+    }
+    function onLink(listener) {
+        return guard("onLink", () => undefined, () => {
+            if (typeof listener !== "function")
+                throw mkErr("unknown", "onLink() needs a function");
+            listeners.add(listener);
+            if (pending.length) {
+                // Links that arrived before anyone listened go to the first listener.
+                const queued = pending;
+                pending = [];
+                Promise.resolve().then(() => {
+                    for (const event of queued) {
+                        if (!listeners.has(listener)) {
+                            pending.push(event);
+                            continue;
+                        }
+                        try {
+                            listener(event);
+                        }
+                        catch (e) {
+                            report(mkErr("unknown", "An onLink listener threw", e), "onLink");
+                        }
+                    }
+                });
+            }
+            return () => {
+                listeners.delete(listener);
+            };
+        });
+    }
+    function getInitialLink() {
+        return guardAsync("getInitialLink", null, async () => {
+            if (!cfg || !initial)
+                throw mkErr("not_configured", "Call DL2.configure() before getInitialLink()");
+            return initial;
+        });
+    }
+    function resolve(url) {
+        return guardAsync("resolve", null, async () => {
+            if (!cfg)
+                throw mkErr("not_configured", "Call DL2.configure() before resolve()");
+            const p = parseUrl(url);
+            if (!p)
+                throw mkErr("link_not_found", "resolve() needs a full URL such as https://myapp.dl2.app/abc");
+            const source = sourceOf(p);
+            const payload = await call("/v1/sdk/resolve", { url, source }, RESOLVE_TIMEOUT_MS);
+            lastResolveResponse = payload;
+            return toEvent(payload, url, source, false);
+        });
+    }
+    function track(name, options) {
+        guard("track", undefined, () => {
+            if (!cfg)
+                throw mkErr("not_configured", "Call DL2.configure() before track()");
+            if (typeof name !== "string" || !name.trim())
+                throw mkErr("unknown", "track() needs an event name");
+            const o = options || {};
+            const e = { name: name.trim() };
+            if (typeof o.value === "number" && isFinite(o.value))
+                e.value = o.value;
+            if (typeof o.currency === "string" && o.currency)
+                e.currency = o.currency.toUpperCase();
+            if (o.props && typeof o.props === "object")
+                e.props = JSON.parse(JSON.stringify(o.props));
+            queue.push(e);
+            if (queue.length > MAX_QUEUED_EVENTS)
+                queue.shift(); // bounded: the oldest event goes first
+            persistQueue();
+            flush().catch(() => undefined);
+        });
+    }
+    function createLink(input) {
+        return guardAsync("createLink", null, async () => {
+            if (!cfg)
+                throw mkErr("not_configured", "Call DL2.configure() before createLink()");
+            if (!input || typeof input.path !== "string")
+                throw mkErr("unknown", "createLink() needs a path");
+            const r = await call("/v1/sdk/links", input, EVENT_TIMEOUT_MS);
+            if (!r || typeof r.url !== "string")
+                throw mkErr("unknown", "The server did not return a link URL");
+            return { url: r.url };
+        });
+    }
+    /**
+     * iOS clipboard matching. Call with text the user pasted through the system paste button
+     * (`DL2PasteButton` does this for you). The SDK never reads the clipboard by itself.
+     */
+    function matchClipboard(text) {
+        return guardAsync("matchClipboard", null, async () => {
+            if (!cfg)
+                throw mkErr("not_configured", "Call DL2.configure() before matchClipboard()");
+            if (!cfg.clipboard) {
+                log("matchClipboard ignored: deferred.useClipboard is off");
+                return null;
+            }
+            if (ready)
+                await ready;
+            if (initial)
+                await initial;
+            const token = extractClipboardToken(text);
+            if (!token || !firstLaunch || matched)
+                return null;
+            const r = await call("/v1/sdk/open", await openBody({ clipboard_token: token }), cfg.timeoutMs);
+            lastOpenResponse = r;
+            if (!r || !r.match)
+                return null;
+            matched = true;
+            const event = toEvent(r.match, null, "deferred", true);
+            emit(event);
+            return event;
+        });
+    }
+    /** Development and tests: forget this install. Call configure() again afterwards. */
+    function reset() {
+        return guardAsync("reset", undefined, async () => {
+            gen++;
+            try {
+                if (sub)
+                    sub.remove();
+            }
+            catch {
+                /* ignore */
+            }
+            if (retryTimer)
+                clearTimeout(retryTimer);
+            sub = null;
+            retryTimer = null;
+            cfg = null;
+            ready = null;
+            initial = null;
+            installId = null;
+            firstLaunch = false;
+            storageOk = true;
+            matched = false;
+            info = null;
+            pending = [];
+            queue = [];
+            retries = 0;
+            lastUrl = "";
+            lastHandled = null;
+            lastOpenResponse = null;
+            lastResolveResponse = null;
+            for (const k of [K_ID, K_DONE, K_ATTEMPTS, K_QUEUE, K_REFERRER])
+                await removeItem(k);
+        });
+    }
+    function getInstallId() {
+        return guardAsync("getInstallId", null, async () => {
+            if (ready)
+                await ready;
+            return installId;
+        });
+    }
+    function getDebugInfo() {
+        return {
+            sdkVersion: exports.SDK_VERSION,
+            configured: !!cfg,
+            nativeModule: !!deps.native,
+            installId,
+            isFirstLaunch: firstLaunch,
+            queuedEvents: queue.length,
+            lastOpenResponse,
+            lastResolveResponse,
+            lastError,
+        };
+    }
+    return {
+        configure,
+        onLink,
+        getInitialLink,
+        resolve,
+        track,
+        /** Sends queued events now. Resolves when the attempt is over; never rejects. */
+        flush: () => guardAsync("flush", undefined, () => flush()),
+        createLink,
+        matchClipboard,
+        reset,
+        getInstallId,
+        getDebugInfo,
+        version: exports.SDK_VERSION,
+    };
+}