@pagepocket/lib 0.8.5 → 0.9.0

package/dist/replay/templates/replay-script-template.part-2.js

@@ -0,0 +1,222 @@
+export const buildReplayInjectedScriptPart2 = (options) => {
+    const { matchAPISource } = options;
+    return `
+  const matchAPI = ${matchAPISource};
+
+  const primeLookups = (snapshot) => {
+    records = snapshot.records || [];
+    byKey.clear();
+    for (const record of records) {
+      if (!record || !record.url || !record.method) continue;
+      const keys = makeVariantKeys(record.method, record.url, record.requestBody || record.requestBodyBase64 || "");
+      for (const key of keys) {
+        if (!byKey.has(key)) {
+          byKey.set(key, record);
+        }
+      }
+    }
+  };
+
+  const ready = (async () => {
+    const [apiSnapshot, resourcesPath] = await Promise.all([loadApiSnapshot(), loadResourcesPath()]);
+    resourceIndex = __pagepocketResourceProxy.buildIndex(resourcesPath || {});
+
+    embeddedByPath = new Map();
+    try {
+      const items = (resourcesPath && resourcesPath.items) || [];
+      for (const item of items) {
+        if (!item || !item.path || !item.data || item.dataEncoding !== "base64") {
+          continue;
+        }
+        embeddedByPath.set(item.path, item);
+      }
+    } catch {}
+
+    const snapshot = apiSnapshot || {};
+    primeLookups(snapshot);
+    return snapshot;
+  })();
+
+  const isLocalResource = (value) => {
+    if (!value) return false;
+    if (value.startsWith("data:") || value.startsWith("blob:")) return true;
+    if (value.startsWith("//")) return false;
+    if (value.startsWith("/")) return true;
+    return false;
+  };
+
+  const findRecord = (method, url, body) => {
+    return matchAPI({ records, byKey, baseUrl, method, url, body });
+  };
+
+  const urlLookupCache = new Map();
+  const findByUrl = (url) => {
+    if (isLocalResource(url)) return null;
+    if (urlLookupCache.has(url)) {
+      return urlLookupCache.get(url);
+    }
+    const record = matchAPI({ records, byKey, baseUrl, method: "GET", url, body: "" });
+    urlLookupCache.set(url, record || null);
+    return record;
+  };
+
+  const findLocalPath = (url) => {
+    try {
+      if (!url || isLocalResource(String(url))) {
+        return null;
+      }
+      if (!resourceIndex) {
+        return null;
+      }
+
+      const resolvedPath = __pagepocketResourceProxy.resolveToLocalPath(String(url), baseUrl, resourceIndex);
+      if (!resolvedPath) {
+        return null;
+      }
+
+      const embedded = embeddedByPath && embeddedByPath.get(resolvedPath);
+      if (embedded && embedded.dataEncoding === "base64" && embedded.data) {
+        if (blobUrlByPath.has(resolvedPath)) {
+          return blobUrlByPath.get(resolvedPath);
+        }
+
+        const binary = atob(embedded.data);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i += 1) {
+          bytes[i] = binary.charCodeAt(i);
+        }
+
+        const mime = embedded.mimeType || "application/octet-stream";
+        const blob = new Blob([bytes], { type: mime });
+        const blobUrl = URL.createObjectURL(blob);
+        blobUrlByPath.set(resolvedPath, blobUrl);
+        return blobUrl;
+      }
+
+      return resolvedPath;
+    } catch {
+      return null;
+    }
+  };
+
+  const rewriteResourceUrl = (value, ctx) => {
+    try {
+      const raw = String(value || "");
+      if (!raw) {
+        return raw;
+      }
+
+      if (isLocalResource(raw)) {
+        return raw;
+      }
+
+      const localPath = findLocalPath(raw);
+      if (localPath) {
+        return localPath;
+      }
+
+      const fallbackType = ctx && ctx.fallbackType ? String(ctx.fallbackType) : undefined;
+      const record = findByUrl(raw);
+      if (record) {
+        const dataUrl = toDataUrl(record, fallbackType);
+        if (dataUrl) {
+          return dataUrl;
+        }
+      }
+
+      return raw;
+    } catch {
+      try {
+        return String(value || "");
+      } catch {
+        return value;
+      }
+    }
+  };
+
+  const defineProp = (obj, key, value) => {
+    try {
+      Object.defineProperty(obj, key, { value, configurable: true });
+    } catch {}
+  };
+
+  const decodeBase64 = (input) => {
+    try {
+      const binary = atob(input || "");
+      const bytes = new Uint8Array(binary.length);
+      Array.from(binary).forEach((char, index) => {
+        bytes[index] = char.charCodeAt(0);
+      });
+      return bytes;
+    } catch {
+      return new Uint8Array();
+    }
+  };
+
+  const bytesToBase64 = (bytes) => {
+    const binary = Array.from(bytes, (value) => String.fromCharCode(value)).join("");
+    return btoa(binary);
+  };
+
+  const textToBase64 = (text) => {
+    try {
+      const bytes = new TextEncoder().encode(text || "");
+      return bytesToBase64(bytes);
+    } catch {
+      return btoa(text || "");
+    }
+  };
+
+  const getContentType = (record) => {
+    const headers = record.responseHeaders || {};
+    for (const key in headers) {
+      if (key.toLowerCase() === "content-type") {
+        return headers[key] || "application/octet-stream";
+      }
+    }
+    return "application/octet-stream";
+  };
+
+  const dataUrlCache = new Map();
+  const toDataUrl = (record, fallbackType) => {
+    if (!record) return "";
+    const contentType = getContentType(record) || fallbackType || "application/octet-stream";
+    const cacheKey = (record.url || "") + "|" + contentType + "|" + (record.responseEncoding || "") + "|" +
+      (record.responseBodyBase64 ? "b64:" + record.responseBodyBase64.length : "txt:" + (record.responseBody ? record.responseBody.length : 0));
+    if (dataUrlCache.has(cacheKey)) {
+      return dataUrlCache.get(cacheKey);
+    }
+    if (record.responseEncoding === "base64" && record.responseBodyBase64) {
+      const dataUrl = "data:" + contentType + ";base64," + record.responseBodyBase64;
+      dataUrlCache.set(cacheKey, dataUrl);
+      return dataUrl;
+    }
+    if (record.responseBody) {
+      const dataUrl = "data:" + contentType + ";base64," + textToBase64(record.responseBody);
+      dataUrlCache.set(cacheKey, dataUrl);
+      return dataUrl;
+    }
+    const dataUrl = "data:" + (fallbackType || "application/octet-stream") + ",";
+    dataUrlCache.set(cacheKey, dataUrl);
+    return dataUrl;
+  };
+
+  const responseFromRecord = (record) => {
+    const headers = new Headers(record.responseHeaders || {});
+    if (record.responseEncoding === "base64" && record.responseBodyBase64) {
+      const bytes = decodeBase64(record.responseBodyBase64);
+      return new Response(bytes, {
+        status: record.status || 200,
+        statusText: record.statusText || "OK",
+        headers
+      });
+    }
+    const bodyText = record.responseBody || "";
+    return new Response(bodyText, {
+      status: record.status || 200,
+      statusText: record.statusText || "OK",
+      headers
+    });
+  };
+`;
+};

package/dist/replay/templates/replay-script-template.part-3.d.ts

@@ -0,0 +1,3 @@
+export declare const buildReplayInjectedScriptPart3: (options: {
+    hackerScripts: string;
+}) => string;

package/dist/replay/templates/replay-script-template.part-3.js

@@ -0,0 +1,9 @@
+export const buildReplayInjectedScriptPart3 = (options) => {
+    const { hackerScripts } = options;
+    return `
+
+${hackerScripts}
+})();
+ </script>
+`;
+};

package/dist/resource-proxy/pathname-variants.js

@@ -1,15 +1,17 @@
 import { stripHash, stripTrailingSlash } from "@pagepocket/shared";
 const isLikelyHostname = (value) => {
-    if (!value)
+    if (!value) {
         return false;
-    if (value === "localhost")
+    }
+    if (value === "localhost") {
         return true;
+    }
     return value.includes(".");
 };
 const encodeEmbeddedUrlTailIfPresent = (pathname) => {
     const raw = String(pathname || "");
     if (!raw.includes("/http")) {
-        return null;
+        return undefined;
     }
     const parts = raw.split("/");
     for (let i = 0; i < parts.length; i += 1) {
@@ -28,13 +30,14 @@ const encodeEmbeddedUrlTailIfPresent = (pathname) => {
         const rebuilt = nextParts.join("/") || "/";
         return rebuilt.startsWith("/") ? rebuilt : "/" + rebuilt;
     }
-    return null;
+    return undefined;
 };
 export const makePathnameVariants = (pathname) => {
     const variants = new Set();
     const push = (value) => {
-        if (!value)
+        if (!value) {
             return;
+        }
         variants.add(value);
     };
     push(pathname);

package/dist/resource-proxy.js

@@ -11,12 +11,12 @@ const canonicalizeHttpUrlForIndex = (url) => {
     }
     return url.toString();
 };
-const toUrlOrNull = (value) => {
+const toUrlOrUndefined = (value) => {
     try {
         return new URL(value);
     }
     catch {
-        return null;
+        return undefined;
     }
 };
 export const buildResourceProxyIndex = (snapshot) => {
@@ -29,7 +29,7 @@ export const buildResourceProxyIndex = (snapshot) => {
         if (!item || !item.url || !item.path) {
             continue;
         }
-        const parsed = toUrlOrNull(item.url);
+        const parsed = toUrlOrUndefined(item.url);
         if (!parsed) {
             continue;
         }
@@ -81,14 +81,14 @@ const uniqByPath = (items) => {
 };
 const preferSingle = (items, baseUrl, suffixLength) => {
     if (items.length <= 1) {
-        return items[0] ?? null;
+        return items[0];
     }
     const baseParsed = (() => {
         try {
             return new URL(baseUrl);
         }
         catch {
-            return null;
+            return undefined;
         }
     })();
     if (baseParsed) {
@@ -103,14 +103,14 @@ const preferSingle = (items, baseUrl, suffixLength) => {
     // If still ambiguous, only accept when the match key is strong.
     // We treat very short suffix matches (or basename-only) as too risky.
     if (suffixLength < 2) {
-        return null;
+        return undefined;
     }
-    return null;
+    return undefined;
 };
 const tryCandidates = (items, baseUrl, suffixLength) => {
     const unique = uniqByPath(items);
     if (unique.length === 0) {
-        return null;
+        return undefined;
     }
     if (unique.length === 1) {
         return unique[0];
@@ -131,12 +131,12 @@ export const resolveToLocalPath = (options) => {
     if (!requestUrl) {
         return undefined;
     }
-    let abs = null;
+    let abs;
     try {
         abs = new URL(requestUrl, baseUrl);
     }
     catch {
-        abs = null;
+        abs = undefined;
     }
     if (!abs) {
         return undefined;

package/dist/resources.d.ts

@@ -1,11 +1,12 @@
 import * as cheerio from "cheerio";
+import type { AnyCheerioElement } from "./cheerio/types.js";
 export type ResourceReference = {
     attr: string;
-    element: any;
+    element: AnyCheerioElement;
     url: string;
 };
 export type SrcsetReference = {
-    element: any;
+    element: AnyCheerioElement;
     value: string;
 };
 export declare const toAbsoluteUrl: (baseUrl: string, resourceUrl: string) => string;

package/dist/resources.js

@@ -12,7 +12,8 @@ export const extractResourceUrls = (html, baseUrl) => {
     const urls = [];
     const collect = (selector, attr) => {
         $(selector).each((_, element) => {
-            const value = $(element).attr(attr);
+            const $element = $(element);
+            const value = $element.attr(attr);
             if (value) {
                 urls.push({ attr, element });
             }
@@ -27,13 +28,15 @@ export const extractResourceUrls = (html, baseUrl) => {
     collect("audio[src]", "src");
     const srcsetItems = [];
     $("img[srcset], source[srcset]").each((_, element) => {
-        const value = $(element).attr("srcset");
+        const $element = $(element);
+        const value = $element.attr("srcset");
         if (value) {
             srcsetItems.push({ element, value });
         }
     });
     const resourceUrls = urls.map(({ attr, element }) => {
-        const value = $(element).attr(attr) || "";
+        const $element = $(element);
+        const value = $element.attr(attr) || "";
         return {
             attr,
             element,

package/dist/rewrite-links/js-imports.d.ts

@@ -1,3 +1,3 @@
-type UrlResolver = (absoluteUrl: string) => string | null;
+type UrlResolver = (absoluteUrl: string) => string | undefined;
 export declare const rewriteJsText: (source: string, resolve: UrlResolver, baseUrl: string) => Promise<string>;
 export {};

package/dist/rewrite-links/link-rel.d.ts

@@ -1,2 +1,2 @@
-import * as cheerio from "cheerio";
-export declare const shouldRewriteLinkHref: ($element: cheerio.Cheerio<any>) => boolean;
+import type { AnyCheerio } from "../cheerio/types.js";
+export declare const shouldRewriteLinkHref: ($element: AnyCheerio) => boolean;

package/dist/rewrite-links/meta-refresh.d.ts

@@ -1,3 +1,3 @@
-type UrlResolver = (absoluteUrl: string) => string | null;
+type UrlResolver = (absoluteUrl: string) => string | undefined;
 export declare const rewriteMetaRefresh: (content: string, baseUrl: string, resolve: UrlResolver) => string;
 export {};

package/dist/rewrite-links/meta-refresh.js

@@ -1,11 +1,13 @@
 import { resolveUrlValue } from "./url-resolve.js";
 export const rewriteMetaRefresh = (content, baseUrl, resolve) => {
     const parts = content.split(";");
-    if (parts.length < 2)
+    if (parts.length < 2) {
         return content;
+    }
     const urlPartIndex = parts.findIndex((part) => part.trim().toLowerCase().startsWith("url="));
-    if (urlPartIndex === -1)
+    if (urlPartIndex === -1) {
         return content;
+    }
     const urlPart = parts[urlPartIndex];
     let rawUrl = urlPart.split("=").slice(1).join("=").trim();
     if ((rawUrl.startsWith('"') && rawUrl.endsWith('"')) ||
@@ -13,8 +15,9 @@ export const rewriteMetaRefresh = (content, baseUrl, resolve) => {
         rawUrl = rawUrl.slice(1, -1).trim();
     }
     const resolved = resolveUrlValue(rawUrl, baseUrl, resolve);
-    if (!resolved)
+    if (!resolved) {
         return content;
+    }
     const next = `url=${resolved}`;
     const nextParts = parts.slice();
     nextParts[urlPartIndex] = next;

package/dist/rewrite-links/srcset.d.ts

@@ -1,3 +1,3 @@
-type UrlResolver = (absoluteUrl: string) => string | null;
+type UrlResolver = (absoluteUrl: string) => string | undefined;
 export declare const rewriteSrcsetValue: (value: string, baseUrl: string, resolve: UrlResolver) => string;
 export {};

package/dist/rewrite-links/srcset.js

@@ -16,8 +16,9 @@ const isUnsafeSrcsetValue = (value) => {
 };
 const isDescriptorToken = (token) => {
     const trimmed = token.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return false;
+    }
     return /^\d+(\.\d+)?x$/i.test(trimmed) || /^\d+w$/i.test(trimmed);
 };
 const parseSrcset = (input) => {
@@ -43,8 +44,9 @@ const stringifySrcset = (candidates) => {
     return candidates
         .map((c) => {
         const url = c.url.trim();
-        if (!c.descriptor)
+        if (!c.descriptor) {
             return url;
+        }
         return `${url} ${c.descriptor.trim()}`;
     })
         .filter(Boolean)

package/dist/rewrite-links/url-resolve.d.ts

@@ -1,3 +1,3 @@
-type UrlResolver = (absoluteUrl: string) => string | null;
-export declare const resolveUrlValue: (value: string, baseUrl: string, resolve: UrlResolver) => string | null;
+type UrlResolver = (absoluteUrl: string) => string | undefined;
+export declare const resolveUrlValue: (value: string, baseUrl: string, resolve: UrlResolver) => string | undefined;
 export {};

package/dist/rewrite-links/url-resolve.js

@@ -1,13 +1,13 @@
 import { shouldSkipValue } from "./skip.js";
 export const resolveUrlValue = (value, baseUrl, resolve) => {
     if (shouldSkipValue(value)) {
-        return null;
+        return undefined;
     }
     try {
         const absolute = new URL(value, baseUrl).toString();
         return resolve(absolute);
     }
     catch {
-        return null;
+        return undefined;
     }
 };

package/dist/rewrite-links.d.ts

@@ -1,6 +1,6 @@
 import { rewriteJsText } from "./rewrite-links/js-imports.js";
 import type { ReplaceElementsConfig } from "./types.js";
-type UrlResolver = (absoluteUrl: string) => string | null;
+type UrlResolver = (absoluteUrl: string) => string | undefined;
 export { rewriteJsText };
 export declare const rewriteEntryHtml: (input: {
     html: string;

package/dist/rewrite-links.js

@@ -28,8 +28,9 @@ export const rewriteEntryHtml = async (input) => {
     const rewriteAttr = (selector, attr) => {
         $(selector).each((_, element) => {
             const value = $(element).attr(attr);
-            if (!value)
+            if (!value) {
                 return;
+            }
             const resolved = resolveUrlValue(value, baseUrl, resolve);
             if (resolved) {
                 $(element).attr(attr, resolved);
@@ -53,8 +54,9 @@ export const rewriteEntryHtml = async (input) => {
                 return;
             }
             const value = el.attr("href");
-            if (!value)
+            if (!value) {
                 return;
+            }
             const resolved = resolveUrlValue(value, baseUrl, resolve);
             if (resolved) {
                 el.attr("href", resolved);
@@ -67,25 +69,29 @@ export const rewriteEntryHtml = async (input) => {
         rewriteDataAttrs("[data-url]", "data-url");
         $("img[srcset], source[srcset]").each((_, element) => {
             const value = $(element).attr("srcset");
-            if (!value)
+            if (!value) {
                 return;
+            }
             const rewritten = rewriteSrcsetValue(value, baseUrl, resolve);
             $(element).attr("srcset", rewritten);
         });
         $("link[imagesrcset]").each((_, element) => {
             const value = $(element).attr("imagesrcset");
-            if (!value)
+            if (!value) {
                 return;
+            }
             const rewritten = rewriteSrcsetValue(value, baseUrl, resolve);
             $(element).attr("imagesrcset", rewritten);
         });
         $("meta[http-equiv]").each((_, element) => {
             const httpEquiv = ($(element).attr("http-equiv") || "").toLowerCase();
-            if (httpEquiv !== "refresh")
+            if (httpEquiv !== "refresh") {
                 return;
+            }
             const content = $(element).attr("content");
-            if (!content)
+            if (!content) {
                 return;
+            }
             const rewritten = rewriteMetaRefresh(content, baseUrl, resolve);
             $(element).attr("content", rewritten);
         });

package/dist/snapshot-builder/build-snapshot.js

@@ -8,7 +8,6 @@ import { responseMimeType } from "./http.js";
 import { docDirFromUrl, resolveSnapshotPath } from "./path-map.js";
 import { buildResourcesPathSnapshot } from "./resources-path.js";
 import { maybeRewriteScript, maybeRewriteStylesheet } from "./rewrite-resource.js";
-// NOTE: helpers were extracted into snapshot-builder/* modules.
 export const buildSnapshot = async (input) => {
     const warnings = input.warnings;
     const contentStore = input.capture.contentStore;
@@ -97,7 +96,7 @@ export const buildSnapshot = async (input) => {
             });
         }
         const apiSnapshot = buildApiSnapshot(group.url, input.createdAt, group.apiEntries);
-        const apiBytes = new TextEncoder().encode(`${JSON.stringify(apiSnapshot, null, 2)}\n`);
+        const apiBytes = new TextEncoder().encode(`${JSON.stringify(apiSnapshot, undefined, 2)}\n`);
         const apiRef = await contentStore.put({ kind: "buffer", data: apiBytes }, { url: apiPath, mimeType: "application/json", sizeHint: apiBytes.byteLength });
         files.push({
             path: apiPath,
@@ -109,7 +108,7 @@ export const buildSnapshot = async (input) => {
     }
     {
         const resourcesPath = buildResourcesPathSnapshot(input.createdAt, files);
-        const bytes = new TextEncoder().encode(`${JSON.stringify(resourcesPath, null, 2)}\n`);
+        const bytes = new TextEncoder().encode(`${JSON.stringify(resourcesPath, undefined, 2)}\n`);
         files.push({
             path: "/resources_path.json",
             mimeType: "application/json",

package/dist/snapshot-builder/capture-index/index-capture.js

@@ -9,8 +9,9 @@ const buildByRequestId = (events) => {
     const byId = new Map();
     const ensure = (requestId) => {
         const existing = byId.get(requestId);
-        if (existing)
+        if (existing) {
             return existing;
+        }
         const created = {};
         byId.set(requestId, created);
         return created;

package/dist/snapshot-builder/emit-document.d.ts

@@ -5,7 +5,7 @@ export declare const emitDocumentFile: (input: {
     entryUrl: string;
     groupUrl: string;
     apiPath: string;
-    resolve: (absoluteUrl: string) => string | null;
+    resolve: (absoluteUrl: string) => string | undefined;
     rewriteEntry: boolean;
     replaceElements: BuildOptions["replaceElements"];
     contentStore: BuildOptions["capture"]["contentStore"];

package/dist/snapshot-builder/emit-document.js

@@ -5,7 +5,7 @@ export const emitDocumentFile = async (input) => {
     const stream = await input.contentStore.open(input.resource.contentRef);
     const bytes = await streamToUint8Array(stream);
     const decoded = decodeUtf8(bytes);
-    if (decoded === null) {
+    if (typeof decoded === "undefined") {
         return {
             file: {
                 path: input.path,

package/dist/snapshot-builder/grouping.js

@@ -52,8 +52,8 @@ export const groupResources = (input) => {
         });
     }
     const primaryGroup = primaryDoc
-        ? (groups.get(primaryDoc.request.frameId ?? primaryDoc.request.requestId) ?? null)
-        : null;
+        ? groups.get(primaryDoc.request.frameId ?? primaryDoc.request.requestId)
+        : undefined;
     const groupByUrl = new Map();
     for (const group of groups.values()) {
         groupByUrl.set(group.url, group);

package/dist/snapshot-builder/path-map.d.ts

@@ -1,3 +1,3 @@
 export declare const escapePercentForStaticServers: (value: string) => string;
 export declare const docDirFromUrl: (url: string) => string;
-export declare const resolveSnapshotPath: (urlToPath: Map<string, string>, absoluteUrl: string) => string | null;
+export declare const resolveSnapshotPath: (urlToPath: Map<string, string>, absoluteUrl: string) => string | undefined;

package/dist/snapshot-builder/path-map.js

@@ -24,7 +24,7 @@ export const docDirFromUrl = (url) => {
 export const resolveSnapshotPath = (urlToPath, absoluteUrl) => {
     const resolved = urlToPath.get(absoluteUrl);
     if (!resolved) {
-        return null;
+        return undefined;
     }
     // Defensive: resolved should be a path, but avoid breaking any unexpected
     // absolute URLs.

package/dist/snapshot-builder/resources-path.js

@@ -29,14 +29,18 @@ export const buildResourcesPathSnapshot = (createdAt, files) => {
         });
     }
     items.sort((left, right) => {
-        if (left.path < right.path)
+        if (left.path < right.path) {
             return -1;
-        if (left.path > right.path)
+        }
+        if (left.path > right.path) {
             return 1;
-        if (left.url < right.url)
+        }
+        if (left.url < right.url) {
             return -1;
-        if (left.url > right.url)
+        }
+        if (left.url > right.url) {
             return 1;
+        }
         return 0;
     });
     return {