@pagepocket/lib 0.13.0 → 0.14.5

package/dist/hackers/replay-worker.js

@@ -0,0 +1,242 @@
+/**
+ * Intercept `new Worker(url|blob)` during replay so that worker-internal
+ * `fetch` / `XHR` requests are served from the saved api.json snapshot.
+ *
+ * Strategy: create a **real** Worker (preserving the full Worker global scope)
+ * but prepend the replay fetch/XHR patches and the api.json records to the
+ * worker script source.  This avoids the impossible task of perfectly
+ * emulating the Worker global on the main thread.
+ *
+ * The injected preamble inside the worker:
+ *   1. Defines a minimal `matchAPI` + `findRecord` using the serialised records.
+ *   2. Monkey-patches `self.fetch` and `self.XMLHttpRequest.prototype` so
+ *      network requests hit the saved records instead of the (offline) network.
+ *   3. Hands off to the original worker script, which now runs in a genuine
+ *      Worker thread with all native APIs intact.
+ */
+export const replayWorkerStub = {
+    id: "replay-worker-stub",
+    stage: "replay",
+    build: () => `
+  if (typeof Worker !== "undefined") {
+    var OriginalWorker = Worker;
+
+    /**
+     * Build the JS preamble that will be prepended to every worker script.
+     * It serialises the current api snapshot records and injects a self-
+     * contained fetch/XHR replay layer.
+     */
+    function __pagepocketBuildWorkerPreamble() {
+      var snapshot = window.__pagepocketApiSnapshot;
+      var records = (snapshot && snapshot.records) ? snapshot.records : [];
+      var baseUrl = (snapshot && snapshot.url) ? snapshot.url : location.href;
+
+      // Serialise records once.  This is evaluated inside the Worker as a
+      // string literal, so we JSON-encode then embed.
+      var recordsJSON = JSON.stringify(records);
+
+      return '(function(){' +
+        'var __records = ' + recordsJSON + ';' +
+        'var __baseUrl = ' + JSON.stringify(baseUrl) + ';' +
+
+        // ---------- matchAPI (inlined, self-contained) ----------
+        'var matchAPI = ' + (typeof matchAPI === 'function' ? matchAPI.toString() : 'function(){return undefined}') + ';' +
+
+        // ---------- findRecord ----------
+        'var __byKey = new Map();' +
+        'var makeVariantKeys = function(m, u, b) {' +
+        '  var makeKey = function(km, ku, kb) { return km.toUpperCase() + " " + ku + " " + kb; };' +
+        '  var keys = [makeKey(m, u, b)];' +
+        '  try { keys.push(makeKey(m, new URL(u, __baseUrl).toString(), b)); } catch(e){}' +
+        '  if (b) { keys.push(makeKey(m, u, "")); try { keys.push(makeKey(m, new URL(u, __baseUrl).toString(), "")); } catch(e){} }' +
+        '  return keys;' +
+        '};' +
+        'for (var i = 0; i < __records.length; i++) {' +
+        '  var r = __records[i];' +
+        '  if (!r || !r.url || !r.method) continue;' +
+        '  var ks = makeVariantKeys(r.method, r.url, r.requestBody || r.requestBodyBase64 || "");' +
+        '  for (var j = 0; j < ks.length; j++) { if (!__byKey.has(ks[j])) __byKey.set(ks[j], r); }' +
+        '}' +
+        'function findRecord(method, url, body) {' +
+        '  return matchAPI({ records: __records, byKey: __byKey, baseUrl: __baseUrl, method: method, url: url, body: body });' +
+        '}' +
+
+        // ---------- decodeBase64 ----------
+        'function decodeBase64(b64) {' +
+        '  var bin = atob(b64); var arr = new Uint8Array(bin.length);' +
+        '  for (var i = 0; i < bin.length; i++) arr[i] = bin.charCodeAt(i);' +
+        '  return arr;' +
+        '}' +
+
+        // ---------- patch fetch ----------
+        'var originalFetch = self.fetch;' +
+        'self.fetch = function(input, init) {' +
+        '  var url = (typeof input === "string") ? input : (input && input.url) ? input.url : String(input);' +
+        '  var method = (init && init.method) ? init.method : "GET";' +
+        '  var body = (init && init.body) ? init.body : "";' +
+        '  var record;' +
+        '  try { record = findRecord(method, url, body); } catch(e) {}' +
+        '  if (record) {' +
+        '    var headers = new Headers();' +
+        '    var rh = record.responseHeaders || {};' +
+        '    for (var k in rh) { try { headers.append(k, rh[k]); } catch(e) {} }' +
+        '    if (record.responseEncoding === "base64" && record.responseBodyBase64) {' +
+        '      return Promise.resolve(new Response(decodeBase64(record.responseBodyBase64), { status: record.status || 200, statusText: record.statusText || "OK", headers: headers }));' +
+        '    }' +
+        '    return Promise.resolve(new Response(record.responseBody || "", { status: record.status || 200, statusText: record.statusText || "OK", headers: headers }));' +
+        '  }' +
+        '  return originalFetch.apply(self, arguments);' +
+        '};' +
+
+        // ---------- patch XHR ----------
+        'var origXHROpen = XMLHttpRequest.prototype.open;' +
+        'var origXHRSend = XMLHttpRequest.prototype.send;' +
+        'XMLHttpRequest.prototype.open = function(m, u) { this.__ppM = m; this.__ppU = u; return origXHROpen.apply(this, arguments); };' +
+        'XMLHttpRequest.prototype.send = function(body) {' +
+        '  var xhr = this; var method = xhr.__ppM || "GET"; var url = xhr.__ppU || "";' +
+        '  var record; try { record = findRecord(method, url, body); } catch(e) {}' +
+        '  if (record) {' +
+        '    var defineP = function(o,k,v){try{Object.defineProperty(o,k,{value:v,writable:true,configurable:true})}catch(e){try{o[k]=v}catch(e2){}}};' +
+        '    setTimeout(function() {' +
+        '      defineP(xhr,"readyState",4); defineP(xhr,"status",record.status||200); defineP(xhr,"statusText",record.statusText||"OK");' +
+        '      if (xhr.responseType==="arraybuffer"&&record.responseBodyBase64){defineP(xhr,"response",decodeBase64(record.responseBodyBase64).buffer);defineP(xhr,"responseText","");}' +
+        '      else if (xhr.responseType==="blob"&&record.responseBodyBase64){defineP(xhr,"response",new Blob([decodeBase64(record.responseBodyBase64)]));defineP(xhr,"responseText","");}' +
+        '      else{defineP(xhr,"response",record.responseBody||"");defineP(xhr,"responseText",record.responseBody||"");}' +
+        '      if(typeof xhr.onreadystatechange==="function")xhr.onreadystatechange();' +
+        '      if(typeof xhr.onload==="function")xhr.onload(new Event("load"));' +
+        '      if(typeof xhr.onloadend==="function")xhr.onloadend(new Event("loadend"));' +
+        '    }, 0); return;' +
+        '  }' +
+        '  var st=record?undefined:404;' +
+        '  setTimeout(function(){' +
+        '    defineP(xhr,"readyState",4);defineP(xhr,"status",404);defineP(xhr,"statusText","Not Found");' +
+        '    defineP(xhr,"response","");defineP(xhr,"responseText","");' +
+        '    if(typeof xhr.onreadystatechange==="function")xhr.onreadystatechange();' +
+        '    if(typeof xhr.onload==="function")xhr.onload(new Event("load"));' +
+        '  },0);' +
+        '};' +
+
+        '})();\\n';
+    }
+
+    window.Worker = function PagepocketWorkerProxy(urlOrBlob, options) {
+      var preamble = __pagepocketBuildWorkerPreamble();
+
+      var scriptUrl = (typeof urlOrBlob === 'string') ? urlOrBlob
+                    : (urlOrBlob instanceof URL) ? urlOrBlob.href
+                    : '';
+
+      // Use rawFetch (unpatched) for blob: URLs — they are in-memory Blob objects
+      // that the replay fetch would fail to match against api.json.
+      // Use window.fetch (patched) for regular URLs — the worker script is saved
+      // in the snapshot and must be served via the replay layer (especially offline).
+      var rawFetch = (window.fetch && window.fetch.__pagepocketOriginal) || fetch;
+      var fetchForUrl = function(url) {
+        return (url && url.startsWith('blob:')) ? rawFetch(url) : window.fetch(url);
+      };
+
+      // Helper: create a real Worker from source code string.
+      var createWorkerFromSource = function(originalCode) {
+        var combined = preamble + originalCode;
+        var blob = new Blob([combined], { type: 'application/javascript' });
+        var blobUrl = URL.createObjectURL(blob);
+        try {
+          return new OriginalWorker(blobUrl, options);
+        } finally {
+          // Revoke after a tick so the Worker has time to load.
+          setTimeout(function() { URL.revokeObjectURL(blobUrl); }, 5000);
+        }
+      };
+
+      // For blob: URLs, fetch the source, prepend preamble, create new blob Worker.
+      if (scriptUrl.startsWith('blob:')) {
+        // We need to return a Worker-like object synchronously, but blob fetch is async.
+        // Create a "pending" real Worker that we'll swap in once the source is fetched.
+        // Use a thin proxy that queues postMessage calls until the real Worker is ready.
+        var pendingMessages = [];
+        var realWorker = null;
+        var proxy = {
+          postMessage: function(data, transfer) {
+            if (realWorker) { realWorker.postMessage(data, transfer); }
+            else { pendingMessages.push([data, transfer]); }
+          },
+          terminate: function() { if (realWorker) realWorker.terminate(); realWorker = { postMessage: function(){}, terminate: function(){} }; },
+          addEventListener: function(t, fn) { if (realWorker) realWorker.addEventListener(t, fn); else (proxy.__listeners = proxy.__listeners || []).push([t, fn]); },
+          removeEventListener: function(t, fn) { if (realWorker) realWorker.removeEventListener(t, fn); },
+          dispatchEvent: function(e) { if (realWorker) return realWorker.dispatchEvent(e); return false; },
+          onmessage: null,
+          onerror: null
+        };
+
+        fetchForUrl(scriptUrl).then(function(r) { return r.text(); }).then(function(code) {
+          realWorker = createWorkerFromSource(code);
+          // Wire up onmessage/onerror
+          if (proxy.onmessage) realWorker.onmessage = proxy.onmessage;
+          if (proxy.onerror) realWorker.onerror = proxy.onerror;
+          // Replay queued listeners
+          if (proxy.__listeners) {
+            for (var i = 0; i < proxy.__listeners.length; i++) {
+              realWorker.addEventListener(proxy.__listeners[i][0], proxy.__listeners[i][1]);
+            }
+          }
+          // Flush queued messages
+          for (var i = 0; i < pendingMessages.length; i++) {
+            realWorker.postMessage(pendingMessages[i][0], pendingMessages[i][1]);
+          }
+          pendingMessages = [];
+        }).catch(function(e) {
+          console.warn('[pagepocket] Worker proxy: cannot fetch blob', e);
+        });
+
+        return proxy;
+      }
+
+      // For regular URLs: fetch, prepend, create.
+      if (scriptUrl) {
+        var pendingMessages2 = [];
+        var realWorker2 = null;
+        var proxy2 = {
+          postMessage: function(data, transfer) {
+            if (realWorker2) { realWorker2.postMessage(data, transfer); }
+            else { pendingMessages2.push([data, transfer]); }
+          },
+          terminate: function() { if (realWorker2) realWorker2.terminate(); realWorker2 = { postMessage: function(){}, terminate: function(){} }; },
+          addEventListener: function(t, fn) { if (realWorker2) realWorker2.addEventListener(t, fn); else (proxy2.__listeners = proxy2.__listeners || []).push([t, fn]); },
+          removeEventListener: function(t, fn) { if (realWorker2) realWorker2.removeEventListener(t, fn); },
+          dispatchEvent: function(e) { if (realWorker2) return realWorker2.dispatchEvent(e); return false; },
+          onmessage: null,
+          onerror: null
+        };
+
+        fetchForUrl(scriptUrl).then(function(r) { return r.text(); }).then(function(code) {
+          realWorker2 = createWorkerFromSource(code);
+          if (proxy2.onmessage) realWorker2.onmessage = proxy2.onmessage;
+          if (proxy2.onerror) realWorker2.onerror = proxy2.onerror;
+          if (proxy2.__listeners) {
+            for (var i = 0; i < proxy2.__listeners.length; i++) {
+              realWorker2.addEventListener(proxy2.__listeners[i][0], proxy2.__listeners[i][1]);
+            }
+          }
+          for (var i = 0; i < pendingMessages2.length; i++) {
+            realWorker2.postMessage(pendingMessages2[i][0], pendingMessages2[i][1]);
+          }
+          pendingMessages2 = [];
+        }).catch(function(e) {
+          console.warn('[pagepocket] Worker proxy: cannot fetch script', e);
+        });
+
+        return proxy2;
+      }
+
+      // Fallback: no URL at all, just create original.
+      return new OriginalWorker(urlOrBlob, options);
+    };
+
+    window.Worker.CONNECTING = 0;
+    window.Worker.OPEN = 1;
+    window.Worker.CLOSING = 2;
+    window.Worker.CLOSED = 3;
+    window.Worker.__pagepocketOriginal = OriginalWorker;
+  }
+`
+};

package/dist/replay/match-api.js

@@ -120,6 +120,23 @@ export function matchAPI(options) {
         }
         return value;
     };
+    const normalizePathLoose = (input) => {
+        const parsed = toUrlOrUndefined(input);
+        if (parsed) {
+            return normalizePath(parsed.pathname);
+        }
+        const rawValue = String(input ?? "");
+        if (!rawValue) {
+            return "";
+        }
+        const valueWithoutHash = rawValue.split("#")[0] ?? "";
+        const valueWithoutQuery = valueWithoutHash.split("?")[0] ?? "";
+        const withoutOrigin = valueWithoutQuery.replace(/^([a-zA-Z][a-zA-Z\d+\-.]*:)?\/\/[^/]+/, "");
+        if (!withoutOrigin) {
+            return "/";
+        }
+        return normalizePath(withoutOrigin.startsWith("/") ? withoutOrigin : `/${withoutOrigin}`);
+    };
     const urlMatches = (inputUrl, recordUrl) => {
         // Strong match first.
         if (urlEquivalent(inputUrl, recordUrl, {
@@ -141,9 +158,7 @@ export function matchAPI(options) {
         if (leftPathSearch === rightPathSearch) {
             return true;
         }
-        const leftPath = normalizePath(left.pathname);
-        const rightPath = normalizePath(right.pathname);
-        return leftPath === rightPath;
+        return false;
     };
     const scanRecords = (keyMethod, keyBody) => {
         for (const record of records || []) {
@@ -164,11 +179,96 @@ export function matchAPI(options) {
         }
         return undefined;
     };
+    const scanRecordsIgnoreQueryAndProtocol = (keyMethod, keyBody) => {
+        const inputPathname = normalizePathLoose(url);
+        if (!inputPathname) {
+            return undefined;
+        }
+        // Collect all pathname-matching candidates first.
+        const candidates = [];
+        for (const record of records || []) {
+            if (!record || !record.url || !record.method) {
+                continue;
+            }
+            if (record.method.toUpperCase() !== keyMethod) {
+                continue;
+            }
+            const recordPathname = normalizePathLoose(record.url);
+            if (!recordPathname || recordPathname !== inputPathname) {
+                continue;
+            }
+            const recordBody = record.requestBody || record.requestBodyBase64 || "";
+            if (keyBody && recordBody !== keyBody) {
+                continue;
+            }
+            candidates.push(record);
+        }
+        if (candidates.length === 0) {
+            return undefined;
+        }
+        // Single candidate — check if it's a safe fallback.
+        if (candidates.length === 1) {
+            const candidate = candidates[0];
+            const inputParsed = safeUrl(url);
+            const candidateParsed = safeUrl(candidate.url);
+            if (inputParsed && candidateParsed) {
+                const inputKeys = Array.from(inputParsed.searchParams.keys());
+                const candidateKeys = new Set(candidateParsed.searchParams.keys());
+                const inputAllContained = inputKeys.length > 0 && inputKeys.every(k => candidateKeys.has(k));
+                const candidateHasExtra = candidateKeys.size > inputKeys.length;
+                // If input params are a strict subset of candidate (candidate has extra params
+                // like cursor), this is likely a different request — skip it.
+                if (inputAllContained && candidateHasExtra) {
+                    return undefined;
+                }
+            }
+            return candidate;
+        }
+        // Multiple candidates — pick the one with the best query param overlap.
+        const inputParsed = safeUrl(url);
+        const inputSearch = inputParsed ? inputParsed.search : "";
+        let bestRecord;
+        let bestScore = -Infinity;
+        for (const candidate of candidates) {
+            const candidateParsed = safeUrl(candidate.url);
+            const candidateSearch = candidateParsed ? candidateParsed.search : "";
+            // Exact search match is ideal.
+            if (candidateSearch === inputSearch) {
+                return candidate;
+            }
+            // Score by search string similarity — shorter distance is better.
+            // Prefer candidates whose search is a prefix/subset of the input.
+            const inputParams = inputParsed ? inputParsed.searchParams : new URLSearchParams();
+            const candidateParams = candidateParsed ? candidateParsed.searchParams : new URLSearchParams();
+            let shared = 0;
+            let recordOnly = 0;
+            for (const [key, value] of candidateParams.entries()) {
+                if (inputParams.get(key) === value) {
+                    shared++;
+                }
+                else {
+                    recordOnly++;
+                }
+            }
+            const score = shared - recordOnly * 2;
+            if (score > bestScore) {
+                bestScore = score;
+                bestRecord = candidate;
+            }
+        }
+        return bestRecord;
+    };
     for (const [keyMethod, keyBody] of matchOrder) {
         const record = scanRecords(keyMethod, keyBody);
         if (record) {
             return record;
         }
     }
+    for (const [keyMethod, keyBody] of matchOrder) {
+        const record = scanRecordsIgnoreQueryAndProtocol(keyMethod, keyBody);
+        if (record) {
+            return record;
+        }
+    }
     return undefined;
 }

package/dist/replay/templates/loader-template.d.ts

@@ -0,0 +1,15 @@
+export type LoaderOptions = {
+    pageUrl: string;
+    apiPath: string;
+    resourcesPathUrl: string;
+    title?: string;
+};
+/**
+ * Build a loader HTML page that pre-fetches `resources_path.json`, `api.json`,
+ * and the actual page HTML in parallel. Shows an SVG spinner for at least 400ms,
+ * then fades out to reveal the page content.
+ *
+ * Usage:
+ *   buildLoaderHtml({ pageUrl: '/_page.html', apiPath: '/api.json', resourcesPathUrl: '/resources_path.json' })
+ */
+export declare const buildLoaderHtml: (options: LoaderOptions) => string;

package/dist/replay/templates/loader-template.js

@@ -0,0 +1,164 @@
+/**
+ * Build a loader HTML page that pre-fetches `resources_path.json`, `api.json`,
+ * and the actual page HTML in parallel. Shows an SVG spinner for at least 400ms,
+ * then fades out to reveal the page content.
+ *
+ * Usage:
+ *   buildLoaderHtml({ pageUrl: '/_page.html', apiPath: '/api.json', resourcesPathUrl: '/resources_path.json' })
+ */
+export const buildLoaderHtml = (options) => {
+    const { pageUrl, apiPath, resourcesPathUrl, title } = options;
+    const escapedTitle = escapeHtml(title ?? "Loading\u2026");
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapedTitle}</title>
+<style>
+  body { margin: 0; }
+  .pp-overlay {
+    position: fixed;
+    inset: 0;
+    z-index: 2147483647;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: #fff;
+    transition: opacity 0.4s ease;
+  }
+  .pp-overlay.pp-fade-out {
+    opacity: 0;
+    pointer-events: none;
+  }
+  .pp-spin {
+    animation: pp-rotate 0.8s linear infinite;
+  }
+  @keyframes pp-rotate { to { transform: rotate(360deg); } }
+  .pp-error {
+    color: #d32f2f;
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    white-space: pre-wrap;
+    max-width: 600px;
+    text-align: center;
+  }
+</style>
+</head>
+<body>
+<div class="pp-overlay" id="ppOverlay">
+  ${SPINNER_SVG}
+</div>
+<script>
+(function () {
+  var pageUrl = ${JSON.stringify(pageUrl)};
+  var apiPath = ${JSON.stringify(apiPath)};
+  var resourcesPathUrl = ${JSON.stringify(resourcesPathUrl)};
+  var startTime = Date.now();
+  var MIN_DISPLAY_MS = 400;
+
+  function showError(message) {
+    var overlay = document.getElementById('ppOverlay');
+    if (overlay) {
+      overlay.innerHTML = '<div class="pp-error">' + message + '</div>';
+    }
+  }
+
+  function fetchText(url) {
+    return fetch(url).then(function (response) {
+      if (!response.ok) {
+        throw new Error('Failed to fetch ' + url + ' (' + response.status + ')');
+      }
+      return response.text();
+    });
+  }
+
+  function fetchJson(url) {
+    return fetch(url).then(function (response) {
+      if (!response.ok) {
+        throw new Error('Failed to fetch ' + url + ' (' + response.status + ')');
+      }
+      return response.json();
+    });
+  }
+
+  function waitMinDuration() {
+    var elapsed = Date.now() - startTime;
+    var remaining = MIN_DISPLAY_MS - elapsed;
+
+    if (remaining <= 0) {
+      return Promise.resolve();
+    }
+
+    return new Promise(function (resolve) {
+      setTimeout(resolve, remaining);
+    });
+  }
+
+  Promise.all([
+    fetchJson(resourcesPathUrl),
+    fetchJson(apiPath),
+    fetchText(pageUrl)
+  ])
+    .then(function (results) {
+      var resourcesPath = results[0];
+      var apiSnapshot = results[1];
+      var pageHtml = results[2];
+
+      window.__pagepocketResourcesPath = resourcesPath;
+      window.__pagepocketApiSnapshot = apiSnapshot;
+
+      var overlayHtml = ${JSON.stringify(OVERLAY_INJECTION)};
+
+      document.open();
+      document.write(overlayHtml + pageHtml);
+      document.close();
+
+      return waitMinDuration();
+    })
+    .then(function () {
+      var overlay = document.getElementById('ppOverlay');
+
+      if (!overlay) {
+        return;
+      }
+
+      overlay.classList.add('pp-fade-out');
+      overlay.addEventListener('transitionend', function () {
+        overlay.remove();
+      });
+    })
+    .catch(function (error) {
+      showError('Failed to load snapshot:\\\\n' + String(error));
+    });
+})();
+</script>
+</body>
+</html>
+`;
+};
+const escapeHtml = (input) => input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+const SPINNER_SVG = [
+    '<svg class="pp-spin" width="40" height="40" viewBox="0 0 40 40" xmlns="http://www.w3.org/2000/svg">',
+    '  <circle cx="20" cy="20" r="17" fill="none" stroke="rgba(0,0,0,0.08)" stroke-width="3"/>',
+    '  <circle cx="20" cy="20" r="17" fill="none" stroke="#222" stroke-width="3"',
+    '    stroke-dasharray="80 27" stroke-linecap="round"/>',
+    "</svg>"
+].join("\n");
+const OVERLAY_INJECTION = [
+    "<style>",
+    "  .pp-overlay {",
+    "    position: fixed; inset: 0; z-index: 2147483647;",
+    "    display: flex; align-items: center; justify-content: center;",
+    "    background: #fff;",
+    "    transition: opacity 0.4s ease;",
+    "  }",
+    "  .pp-overlay.pp-fade-out {",
+    "    opacity: 0; pointer-events: none;",
+    "  }",
+    "  .pp-spin {",
+    "    animation: pp-rotate 0.8s linear infinite;",
+    "  }",
+    "  @keyframes pp-rotate { to { transform: rotate(360deg); } }",
+    "</style>",
+    `<div class="pp-overlay" id="ppOverlay">${SPINNER_SVG}</div>`
+].join("\n");

package/dist/replay/templates/match-api-source.d.ts

@@ -1 +1 @@
-export declare const matchAPISource = "function matchAPI(options) {\n    const { records, byKey, baseUrl, method, url, body } = options;\n    const normalizeBody = (value) => {\n        if (value === undefined || value === null)\n            return \"\";\n        if (typeof value === \"string\")\n            return value;\n        try {\n            return String(value);\n        }\n        catch {\n            return \"\";\n        }\n    };\n    const normalizeUrl = (input) => {\n        try {\n            return new URL(input, baseUrl).toString();\n        }\n        catch {\n            return input;\n        }\n    };\n    const stripHash = (value) => {\n        const index = value.indexOf(\"#\");\n        return index === -1 ? value : value.slice(0, index);\n    };\n    const stripTrailingSlash = (value) => {\n        if (value.length > 1 && value.endsWith(\"/\")) {\n            return value.slice(0, -1);\n        }\n        return value;\n    };\n    const safeUrl = (input) => {\n        try {\n            return new URL(input, baseUrl);\n        }\n        catch {\n            return null;\n        }\n    };\n    const toPathSearch = (input) => {\n        const parsed = safeUrl(input);\n        if (!parsed)\n            return input;\n        return parsed.pathname + parsed.search;\n    };\n    const toPathname = (input) => {\n        const parsed = safeUrl(input);\n        return parsed ? parsed.pathname : input;\n    };\n    const buildUrlVariants = (input) => {\n        const variants = new Set();\n        const push = (value) => {\n            if (!value)\n                return;\n            variants.add(value);\n        };\n        const raw = String(input ?? \"\");\n        push(raw);\n        push(stripHash(raw));\n        push(stripTrailingSlash(raw));\n        push(stripTrailingSlash(stripHash(raw)));\n        const absolute = normalizeUrl(raw);\n        push(absolute);\n        const absoluteNoHash = stripHash(absolute);\n        push(absoluteNoHash);\n        push(stripTrailingSlash(absoluteNoHash));\n        const pathSearch = toPathSearch(raw);\n        push(pathSearch);\n        push(stripTrailingSlash(pathSearch));\n        const pathname = toPathname(raw);\n        push(pathname);\n        push(stripTrailingSlash(pathname));\n        return Array.from(variants);\n    };\n    const makeKey = (keyMethod, keyUrl, keyBody) => keyMethod.toUpperCase() + \" \" + normalizeUrl(keyUrl) + \" \" + normalizeBody(keyBody);\n    const urlVariants = buildUrlVariants(url);\n    const bodyValue = normalizeBody(body);\n    const methodValue = (method || \"GET\").toUpperCase();\n    const tryLookup = (keyMethod, keyBody) => {\n        if (!byKey)\n            return undefined;\n        for (const urlVariant of urlVariants) {\n            const record = byKey.get(makeKey(keyMethod, urlVariant, keyBody));\n            if (record)\n                return record;\n        }\n        return undefined;\n    };\n    const matchOrder = [\n        [methodValue, bodyValue],\n        [methodValue, \"\"],\n        [\"GET\", \"\"],\n        [\"GET\", bodyValue]\n    ];\n    for (const [keyMethod, keyBody] of matchOrder) {\n        const record = tryLookup(keyMethod, keyBody);\n        if (record)\n            return record;\n    }\n    const urlMatches = (inputUrl, recordUrl) => {\n        const inputAbs = stripHash(normalizeUrl(inputUrl));\n        const recordAbs = stripHash(normalizeUrl(recordUrl));\n        if (inputAbs === recordAbs)\n            return true;\n        const inputPathSearch = stripTrailingSlash(toPathSearch(inputUrl));\n        const recordPathSearch = stripTrailingSlash(toPathSearch(recordUrl));\n        if (inputPathSearch === recordPathSearch)\n            return true;\n        const inputPath = stripTrailingSlash(toPathname(inputUrl));\n        const recordPath = stripTrailingSlash(toPathname(recordUrl));\n        if (inputPath === recordPath)\n            return true;\n        return false;\n    };\n    const scanRecords = (keyMethod, keyBody) => {\n        for (const record of records || []) {\n            if (!record || !record.url || !record.method)\n                continue;\n            if (record.method.toUpperCase() !== keyMethod)\n                continue;\n            if (!urlMatches(url, record.url))\n                continue;\n            const recordBody = record.requestBody || record.requestBodyBase64 || \"\";\n            if (keyBody && recordBody !== keyBody)\n                continue;\n            return record;\n        }\n        return undefined;\n    };\n    for (const [keyMethod, keyBody] of matchOrder) {\n        const record = scanRecords(keyMethod, keyBody);\n        if (record)\n            return record;\n    }\n    return undefined;\n}";
+export declare const matchAPISource = "function matchAPI(options) {\n    const { records, byKey, baseUrl, method, url, body } = options;\n    const normalizeBody = (value) => {\n        if (value === undefined || value === null)\n            return \"\";\n        if (typeof value === \"string\")\n            return value;\n        try {\n            return String(value);\n        }\n        catch {\n            return \"\";\n        }\n    };\n    const normalizeUrl = (input) => {\n        try {\n            return new URL(input, baseUrl).toString();\n        }\n        catch {\n            return input;\n        }\n    };\n    const stripHash = (value) => {\n        const index = value.indexOf(\"#\");\n        return index === -1 ? value : value.slice(0, index);\n    };\n    const stripTrailingSlash = (value) => {\n        if (value.length > 1 && value.endsWith(\"/\")) {\n            return value.slice(0, -1);\n        }\n        return value;\n    };\n    const safeUrl = (input) => {\n        try {\n            return new URL(input, baseUrl);\n        }\n        catch {\n            return null;\n        }\n    };\n    const toPathSearch = (input) => {\n        const parsed = safeUrl(input);\n        if (!parsed)\n            return input;\n        return parsed.pathname + parsed.search;\n    };\n    const toPathname = (input) => {\n        const parsed = safeUrl(input);\n        return parsed ? parsed.pathname : input;\n    };\n    const buildUrlVariants = (input) => {\n        const variants = new Set();\n        const push = (value) => {\n            if (!value)\n                return;\n            variants.add(value);\n        };\n        const raw = String(input ?? \"\");\n        push(raw);\n        push(stripHash(raw));\n        push(stripTrailingSlash(raw));\n        push(stripTrailingSlash(stripHash(raw)));\n        const absolute = normalizeUrl(raw);\n        push(absolute);\n        const absoluteNoHash = stripHash(absolute);\n        push(absoluteNoHash);\n        push(stripTrailingSlash(absoluteNoHash));\n        const pathSearch = toPathSearch(raw);\n        push(pathSearch);\n        push(stripTrailingSlash(pathSearch));\n        const pathname = toPathname(raw);\n        push(pathname);\n        push(stripTrailingSlash(pathname));\n        return Array.from(variants);\n    };\n    const makeKey = (keyMethod, keyUrl, keyBody) => keyMethod.toUpperCase() + \" \" + normalizeUrl(keyUrl) + \" \" + normalizeBody(keyBody);\n    const urlVariants = buildUrlVariants(url);\n    const bodyValue = normalizeBody(body);\n    const methodValue = (method || \"GET\").toUpperCase();\n    const tryLookup = (keyMethod, keyBody) => {\n        if (!byKey)\n            return undefined;\n        for (const urlVariant of urlVariants) {\n            const record = byKey.get(makeKey(keyMethod, urlVariant, keyBody));\n            if (record)\n                return record;\n        }\n        return undefined;\n    };\n    const matchOrder = [\n        [methodValue, bodyValue],\n        [methodValue, \"\"],\n        [\"GET\", \"\"],\n        [\"GET\", bodyValue]\n    ];\n    for (const [keyMethod, keyBody] of matchOrder) {\n        const record = tryLookup(keyMethod, keyBody);\n        if (record)\n            return record;\n    }\n    const urlMatches = (inputUrl, recordUrl) => {\n        const inputAbs = stripHash(normalizeUrl(inputUrl));\n        const recordAbs = stripHash(normalizeUrl(recordUrl));\n        if (inputAbs === recordAbs)\n            return true;\n        const inputPathSearch = stripTrailingSlash(toPathSearch(inputUrl));\n        const recordPathSearch = stripTrailingSlash(toPathSearch(recordUrl));\n        if (inputPathSearch === recordPathSearch)\n            return true;\n        return false;\n    };\n    const normalizePathLoose = (input) => {\n        const parsed = safeUrl(input);\n        if (parsed) {\n            return stripTrailingSlash(parsed.pathname);\n        }\n        const rawValue = String(input ?? \"\");\n        if (!rawValue) {\n            return \"\";\n        }\n        const valueWithoutHash = rawValue.split(\"#\")[0] ?? \"\";\n        const valueWithoutQuery = valueWithoutHash.split(\"?\")[0] ?? \"\";\n        const withoutOrigin = valueWithoutQuery.replace(/^([a-zA-Z][a-zA-Z\\d+\\-.]*:)?\\/\\/[^/]+/, \"\");\n        if (!withoutOrigin) {\n            return \"/\";\n        }\n        return stripTrailingSlash(withoutOrigin.startsWith(\"/\") ? withoutOrigin : \"/\" + withoutOrigin);\n    };\n    const scanRecords = (keyMethod, keyBody) => {\n        for (const record of records || []) {\n            if (!record || !record.url || !record.method)\n                continue;\n            if (record.method.toUpperCase() !== keyMethod)\n                continue;\n            if (!urlMatches(url, record.url))\n                continue;\n            const recordBody = record.requestBody || record.requestBodyBase64 || \"\";\n            if (keyBody && recordBody !== keyBody)\n                continue;\n            return record;\n        }\n        return undefined;\n    };\n    const scanRecordsIgnoreQueryAndProtocol = (keyMethod, keyBody) => {\n        const inputPathname = normalizePathLoose(url);\n        if (!inputPathname) {\n            return undefined;\n        }\n        const candidates = [];\n        for (const record of records || []) {\n            if (!record || !record.url || !record.method)\n                continue;\n            if (record.method.toUpperCase() !== keyMethod)\n                continue;\n            const recordPathname = normalizePathLoose(record.url);\n            if (!recordPathname || recordPathname !== inputPathname)\n                continue;\n            const recordBody = record.requestBody || record.requestBodyBase64 || \"\";\n            if (keyBody && recordBody !== keyBody)\n                continue;\n            candidates.push(record);\n        }\n        if (candidates.length === 0)\n            return undefined;\n        if (candidates.length === 1) {\n            const candidate = candidates[0];\n            const inputParsed = safeUrl(url);\n            const candidateParsed = safeUrl(candidate.url);\n            if (inputParsed && candidateParsed) {\n                const inputKeys = Array.from(inputParsed.searchParams.keys());\n                const candidateKeys = new Set(candidateParsed.searchParams.keys());\n                const inputAllContained = inputKeys.length > 0 && inputKeys.every(k => candidateKeys.has(k));\n                const candidateHasExtra = candidateKeys.size > inputKeys.length;\n                if (inputAllContained && candidateHasExtra)\n                    return undefined;\n            }\n            return candidate;\n        }\n        const inputParsed = safeUrl(url);\n        const inputSearch = inputParsed ? inputParsed.search : \"\";\n        let bestRecord = undefined;\n        let bestScore = -Infinity;\n        for (const candidate of candidates) {\n            const candidateParsed = safeUrl(candidate.url);\n            const candidateSearch = candidateParsed ? candidateParsed.search : \"\";\n            if (candidateSearch === inputSearch)\n                return candidate;\n            const inputParams = inputParsed ? inputParsed.searchParams : new URLSearchParams();\n            const candidateParams = candidateParsed ? candidateParsed.searchParams : new URLSearchParams();\n            let shared = 0;\n            let recordOnly = 0;\n            for (const [key, value] of candidateParams.entries()) {\n                if (inputParams.get(key) === value) {\n                    shared++;\n                }\n                else {\n                    recordOnly++;\n                }\n            }\n            const score = shared - recordOnly * 2;\n            if (score > bestScore) {\n                bestScore = score;\n                bestRecord = candidate;\n            }\n        }\n        return bestRecord;\n    };\n    for (const [keyMethod, keyBody] of matchOrder) {\n        const record = scanRecords(keyMethod, keyBody);\n        if (record)\n            return record;\n    }\n    for (const [keyMethod, keyBody] of matchOrder) {\n        const record = scanRecordsIgnoreQueryAndProtocol(keyMethod, keyBody);\n        if (record)\n            return record;\n    }\n    return undefined;\n}";