@pagepocket/lib 0.11.1 → 0.12.0

package/dist/core/pagepocket.d.ts

@@ -15,6 +15,7 @@ export type CaptureTarget = {
 };
 import type { PagePocketOptions } from "../types.js";
 import type { CaptureResult as PagePocketCaptureResult, Plugin as V3Plugin, Unit as V3Unit } from "../units/contracts-bridge.js";
+import type { CaptureOptions } from "../units/types.js";
 export declare class PagePocket {
     private target;
     private options;
@@ -34,5 +35,5 @@ export declare class PagePocket {
     capture(options: {
         units: V3Unit[];
         plugins?: V3Plugin[];
-    } & import("../units/types.js").CaptureOptions): Promise<PagePocketCaptureResult>;
+    } & CaptureOptions): Promise<PagePocketCaptureResult>;
 }

package/dist/hackers/replay-css-proxy.js

@@ -33,8 +33,8 @@ export const replayCssProxy = {
           if (!next) {
             return full;
           }
-          const q = quote || "";
-          return "url(" + q + next + q + ")";
+          const quoteSymbol = quote || "";
+          return "url(" + quoteSymbol + next + quoteSymbol + ")";
         } catch {
           return full;
         }

package/dist/kind-map.js

@@ -42,17 +42,13 @@ export const requiredEntryKindError = (unitName, requiredKind, entry) => {
  * Convenience handler for `mapKind` that throws a standardized
  * "does not support entry kind" error.
  */
-export const throwUnsupportedEntryKind = (unitName) => {
-    return (_kind, entry) => {
-        throw unsupportedEntryKindError(unitName, entry);
-    };
+export const throwUnsupportedEntryKind = (unitName) => (_kind, entry) => {
+    throw unsupportedEntryKindError(unitName, entry);
 };
 /**
  * Convenience handler for `mapKind` that throws a standardized
  * "requires entry kind" error.
  */
-export const throwRequiredEntryKind = (unitName, requiredKind) => {
-    return (_kind, entry) => {
-        throw requiredEntryKindError(unitName, requiredKind, entry);
-    };
+export const throwRequiredEntryKind = (unitName, requiredKind) => (_kind, entry) => {
+    throw requiredEntryKindError(unitName, requiredKind, entry);
 };

package/dist/replace-elements/normalize.js

@@ -3,9 +3,7 @@ const defaultApply = {
     limit: "all",
     onReplaced: "stop"
 };
-const isPlainObject = (value) => {
-    return typeof value === "object" && value !== null;
-};
+const isPlainObject = (value) => typeof value === "object" && value !== null;
 const normalizeApply = (apply) => ({
     scope: apply?.scope ?? defaultApply.scope,
     limit: apply?.limit ?? defaultApply.limit,

package/dist/replace-elements.js

@@ -7,19 +7,19 @@ const runFnRuleOnSelection = async (input) => {
     const selection = $(item.query).toArray();
     const limit = item.apply.limit;
     const max = limit === "all" ? selection.length : Math.max(0, limit);
-    for (let i = 0; i < selection.length && i < max; i += 1) {
-        const el = selection[i];
-        const $el = $(el);
-        if (!isHtmlElement($, $el)) {
+    for (let selectionIndex = 0; selectionIndex < selection.length && selectionIndex < max; selectionIndex += 1) {
+        const selectedElement = selection[selectionIndex];
+        const $selectedElement = $(selectedElement);
+        if (!isHtmlElement($, $selectedElement)) {
             continue;
         }
         const ctx = {
             $,
-            $el,
+            $el: $selectedElement,
             url: input.url,
             entryUrl: input.entryUrl,
             ruleIndex: item.ruleIndex,
-            matchIndex: i
+            matchIndex: selectionIndex
         };
         const result = await item.run(ctx);
         if (!result) {
@@ -27,7 +27,7 @@ const runFnRuleOnSelection = async (input) => {
         }
         const actions = Array.isArray(result) ? result : [result];
         for (const action of actions) {
-            applyReplaceAction($, $el, action);
+            applyReplaceAction($, $selectedElement, action);
         }
     }
 };
@@ -56,22 +56,22 @@ export const applyReplaceElements = async (input) => {
         const limit = item.apply.limit;
         const max = limit === "all" ? selection.length : Math.max(0, limit);
         let replacedCount = 0;
-        for (let i = 0; i < selection.length && replacedCount < max; i += 1) {
-            const el = selection[i];
-            if (item.apply.onReplaced === "stop" && replacedByIndex.has(el)) {
+        for (let selectionIndex = 0; selectionIndex < selection.length && replacedCount < max; selectionIndex += 1) {
+            const selectedElementIdentity = selection[selectionIndex];
+            if (item.apply.onReplaced === "stop" && replacedByIndex.has(selectedElementIdentity)) {
                 continue;
             }
-            const $el = input.$(selection[i]);
-            if (!isHtmlElement(input.$, $el)) {
+            const $selectedElement = input.$(selection[selectionIndex]);
+            if (!isHtmlElement(input.$, $selectedElement)) {
                 continue;
             }
-            if (!elementMatchesFilter(input.$, $el, filter)) {
+            if (!elementMatchesFilter(input.$, $selectedElement, filter)) {
                 continue;
             }
-            applyReplaceAction(input.$, $el, item.rule.replace);
+            applyReplaceAction(input.$, $selectedElement, item.rule.replace);
             replacedCount += 1;
             if (item.apply.onReplaced === "stop") {
-                replacedByIndex.add(el);
+                replacedByIndex.add(selectedElementIdentity);
             }
         }
     }

package/dist/resource-proxy/escape-percent.js

@@ -1,6 +1,4 @@
-const looksAlreadyEscapedForStaticServers = (value) => {
-    return /%25[0-9a-fA-F]{2}/.test(value);
-};
+const looksAlreadyEscapedForStaticServers = (value) => /%25[0-9a-fA-F]{2}/.test(value);
 export const escapePercentForStaticServersOnce = (value) => {
     if (!value) {
         return value;

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

@@ -14,19 +14,19 @@ const encodeEmbeddedUrlTailIfPresent = (pathname) => {
         return undefined;
     }
     const parts = raw.split("/");
-    for (let i = 0; i < parts.length; i += 1) {
-        const scheme = parts[i];
+    for (let partIndex = 0; partIndex < parts.length; partIndex += 1) {
+        const scheme = parts[partIndex];
         if (scheme !== "http:" && scheme !== "https:") {
             continue;
         }
-        const hasDoubleSlash = parts[i + 1] === "";
-        const host = parts[i + 2] || "";
+        const hasDoubleSlash = parts[partIndex + 1] === "";
+        const host = parts[partIndex + 2] || "";
         if (!hasDoubleSlash || !isLikelyHostname(host)) {
             continue;
         }
-        const embedded = scheme + "//" + parts.slice(i + 2).join("/");
+        const embedded = scheme + "//" + parts.slice(partIndex + 2).join("/");
         const encoded = encodeURIComponent(embedded);
-        const nextParts = parts.slice(0, i).concat(encoded);
+        const nextParts = parts.slice(0, partIndex).concat(encoded);
         const rebuilt = nextParts.join("/") || "/";
         return rebuilt.startsWith("/") ? rebuilt : "/" + rebuilt;
     }

package/dist/resource-proxy.js

@@ -92,7 +92,7 @@ const preferSingle = (items, baseUrl, suffixLength) => {
         }
     })();
     if (baseParsed) {
-        const sameOrigin = items.filter((i) => i.parsed.origin === baseParsed.origin);
+        const sameOrigin = items.filter((indexedItem) => indexedItem.parsed.origin === baseParsed.origin);
         if (sameOrigin.length === 1) {
             return sameOrigin[0];
         }
@@ -120,9 +120,9 @@ const tryCandidates = (items, baseUrl, suffixLength) => {
 const makeSuffixes = (pathname) => {
     const parts = pathname.split("/").filter(Boolean);
     const out = [];
-    for (let i = 0; i < parts.length; i += 1) {
-        const suffix = "/" + parts.slice(i).join("/");
-        out.push({ key: suffix, depth: parts.length - i });
+    for (let partIndex = 0; partIndex < parts.length; partIndex += 1) {
+        const suffix = "/" + parts.slice(partIndex).join("/");
+        out.push({ key: suffix, depth: parts.length - partIndex });
     }
     return out;
 };
@@ -175,7 +175,7 @@ export const resolveToLocalPath = (options) => {
     const pathname = abs.pathname || "/";
     const pathnameVariants = makePathnameVariants(pathname);
     const search = abs.search || "";
-    const pathnameWithSearchVariants = pathnameVariants.map((p) => p + search);
+    const pathnameWithSearchVariants = pathnameVariants.map((pathnameVariant) => pathnameVariant + search);
     for (const key of pathnameWithSearchVariants) {
         const items = toArray(index.byPathnameWithSearch.get(key));
         const match = tryCandidates(items, baseUrl, 99);

package/dist/rewrite-links/srcset.js

@@ -24,7 +24,7 @@ const isDescriptorToken = (token) => {
 const parseSrcset = (input) => {
     const rawCandidates = input
         .split(",")
-        .map((c) => c.trim())
+        .map((candidateText) => candidateText.trim())
         .filter(Boolean);
     return rawCandidates.map((candidate) => {
         const tokens = candidate.split(/\s+/).filter(Boolean);
@@ -40,26 +40,24 @@ const parseSrcset = (input) => {
         return { url: candidate };
     });
 };
-const stringifySrcset = (candidates) => {
-    return candidates
-        .map((c) => {
-        const url = c.url.trim();
-        if (!c.descriptor) {
-            return url;
-        }
-        return `${url} ${c.descriptor.trim()}`;
-    })
-        .filter(Boolean)
-        .join(",");
-};
+const stringifySrcset = (candidates) => candidates
+    .map((candidate) => {
+    const url = candidate.url.trim();
+    if (!candidate.descriptor) {
+        return url;
+    }
+    return `${url} ${candidate.descriptor.trim()}`;
+})
+    .filter(Boolean)
+    .join(",");
 export const rewriteSrcsetValue = (value, baseUrl, resolve) => {
     if (isUnsafeSrcsetValue(value)) {
         return "";
     }
     const candidates = parseSrcset(value);
-    const rewritten = candidates.map((c) => {
-        const resolved = resolveUrlValue(c.url, baseUrl, resolve);
-        return { url: resolved ?? c.url, descriptor: c.descriptor };
+    const rewritten = candidates.map((candidate) => {
+        const resolved = resolveUrlValue(candidate.url, baseUrl, resolve);
+        return { url: resolved ?? candidate.url, descriptor: candidate.descriptor };
     });
     return stringifySrcset(rewritten);
 };

package/dist/snapshot-builder/http.js

@@ -1,7 +1,7 @@
 export const headersListToRecord = (headers) => {
     const out = {};
-    for (const h of headers) {
-        out[h.name] = h.value;
+    for (const header of headers) {
+        out[header.name] = header.value;
     }
     return out;
 };

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

@@ -1,16 +1,15 @@
 import { sanitizePosixPath } from "../utils.js";
-export const escapePercentForStaticServers = (value) => {
-    // Many static servers decode percent-encoding in the request path before
-    // resolving it to a filesystem path.
-    //
-    // Our snapshots can contain literal "%2F" sequences in filenames (e.g.
-    // Substack image URLs embedded into a path segment). When a server decodes
-    // "%2F" to "/", it changes the path structure and causes 404s.
-    //
-    // Escaping "%" to "%25" makes the request decode back to the original
-    // filename on disk.
-    return value.split("%").join("%25");
-};
+export const escapePercentForStaticServers = (value) => 
+// Many static servers decode percent-encoding in the request path before
+// resolving it to a filesystem path.
+//
+// Our snapshots can contain literal "%2F" sequences in filenames (e.g.
+// Substack image URLs embedded into a path segment). When a server decodes
+// "%2F" to "/", it changes the path structure and causes 404s.
+//
+// Escaping "%" to "%25" makes the request decode back to the original
+// filename on disk.
+value.split("%").join("%25");
 export const docDirFromUrl = (url) => {
     try {
         const parsed = new URL(url);

package/dist/units/contracts-bridge.d.ts

@@ -1,4 +1,5 @@
 import type { ChannelToken, ReplaceElementsConfig } from "@pagepocket/contracts";
+import type { CaptureOptions, EntryInfo, PagePocketOptions } from "./types.js";
 export type CaptureResult = {
     kind: "raw";
     outputDir: string;
@@ -46,9 +47,9 @@ export interface ElementPatchRegistry {
     compile(): Promise<ReplaceElementsConfig>;
 }
 export interface UnitRuntime {
-    readonly entry: import("./types.js").EntryInfo;
-    readonly options: import("./types.js").CaptureOptions;
-    readonly pocketOptions: import("./types.js").PagePocketOptions;
+    readonly entry: EntryInfo;
+    readonly options: CaptureOptions;
+    readonly pocketOptions: PagePocketOptions;
     publish<T>(t: ChannelToken<T>, value: T): void;
     subscribe<T>(t: ChannelToken<T>): AsyncIterable<T>;
     hasPublisher(t: ChannelToken<unknown>): boolean;
@@ -56,8 +57,8 @@ export interface UnitRuntime {
     defer(promise: DeferredHandle): void;
 }
 export interface PluginHost {
-    readonly entry: import("./types.js").EntryInfo;
-    readonly options: import("./types.js").CaptureOptions;
+    readonly entry: EntryInfo;
+    readonly options: CaptureOptions;
     subscribe<T>(t: ChannelToken<T>): AsyncIterable<T>;
     hasPublisher(t: ChannelToken<unknown>): boolean;
     readonly elements: ElementPatchRegistry;

package/dist/units/internal/async-queue.js

@@ -35,11 +35,11 @@ export class AsyncQueue {
     async *iterate() {
         while (true) {
             if (this.values.length > 0) {
-                const v = this.values.shift();
-                if (v === undefined) {
+                const value = this.values.shift();
+                if (value === undefined) {
                     continue;
                 }
-                yield v;
+                yield value;
                 continue;
             }
             if (this.done) {

package/dist/units/internal/runtime.d.ts

@@ -25,11 +25,11 @@ export declare class RuntimeImpl implements UnitRuntime {
         options: CaptureOptions;
         pocketOptions: PagePocketOptions;
     });
-    publish<T>(t: ChannelToken<T>, value: T): void;
-    subscribe<T>(t: ChannelToken<T>): AsyncIterable<T>;
-    hasPublisher(t: ChannelToken<unknown>): boolean;
+    publish<T>(channelToken: ChannelToken<T>, value: T): void;
+    subscribe<T>(channelToken: ChannelToken<T>): AsyncIterable<T>;
+    hasPublisher(channelToken: ChannelToken<unknown>): boolean;
     defer(promise: Promise<unknown>): void;
-    _ensureChannel(t: ChannelToken<unknown>): void;
+    _ensureChannel(channelToken: ChannelToken<unknown>): void;
     _closeAllChannels(): Promise<void>;
     _awaitDeferred(): Promise<void>;
 }

package/dist/units/internal/runtime.js

@@ -35,8 +35,8 @@ export class RuntimeImpl {
         this.options = input.options;
         this.pocketOptions = input.pocketOptions;
     }
-    publish(t, value) {
-        const state = this.channels.get(t.id);
+    publish(channelToken, value) {
+        const state = this.channels.get(channelToken.id);
         if (!state || state.closed) {
             return;
         }
@@ -45,45 +45,45 @@ export class RuntimeImpl {
             sub.push(value);
         }
     }
-    subscribe(t) {
-        if (!this.channels.has(t.id)) {
-            this.channels.set(t.id, { hasPublisher: false, subs: new Set(), closed: false });
+    subscribe(channelToken) {
+        if (!this.channels.has(channelToken.id)) {
+            this.channels.set(channelToken.id, { hasPublisher: false, subs: new Set(), closed: false });
         }
-        const state = this.channels.get(t.id);
+        const state = this.channels.get(channelToken.id);
         if (!state || state.closed) {
             return emptyAsyncIterable();
         }
-        const q = new AsyncQueue();
+        const queue = new AsyncQueue();
         const sub = {
-            push: (v) => q.push(v),
-            close: () => q.close()
+            push: (value) => queue.push(value),
+            close: () => queue.close()
         };
         state.subs.add(sub);
         const owner = this;
         return (async function* () {
             try {
-                for await (const v of q.iterate()) {
-                    yield v;
+                for await (const value of queue.iterate()) {
+                    yield value;
                 }
             }
             finally {
-                const s = owner.channels.get(t.id);
-                s?.subs.delete(sub);
-                q.close();
+                const channelState = owner.channels.get(channelToken.id);
+                channelState?.subs.delete(sub);
+                queue.close();
             }
         })();
     }
-    hasPublisher(t) {
-        return this.channels.get(t.id)?.hasPublisher === true;
+    hasPublisher(channelToken) {
+        return this.channels.get(channelToken.id)?.hasPublisher === true;
     }
     defer(promise) {
         this.deferred.add(promise);
     }
-    _ensureChannel(t) {
-        if (this.channels.has(t.id)) {
+    _ensureChannel(channelToken) {
+        if (this.channels.has(channelToken.id)) {
             return;
         }
-        this.channels.set(t.id, { hasPublisher: false, subs: new Set(), closed: false });
+        this.channels.set(channelToken.id, { hasPublisher: false, subs: new Set(), closed: false });
     }
     async _closeAllChannels() {
         for (const state of this.channels.values()) {
@@ -103,11 +103,11 @@ export class RuntimeImpl {
 }
 export const mergePatchIntoFreshContext = (patch) => {
     const next = { value: {} };
-    for (const [k, v] of Object.entries(patch)) {
-        if (k === TERMINAL_RESULT_KEY) {
+    for (const [key, value] of Object.entries(patch)) {
+        if (key === TERMINAL_RESULT_KEY) {
             continue;
         }
-        next.value[k] = v;
+        next.value[key] = value;
     }
     return next;
 };

package/dist/units/runner.js

@@ -6,27 +6,25 @@ export const runCapture = async (input) => {
         options: input.options,
         pocketOptions: input.pocketOptions
     });
-    for (const ch of input.declaredChannels ?? []) {
-        rt._ensureChannel(ch);
+    for (const channel of input.declaredChannels ?? []) {
+        rt._ensureChannel(channel);
     }
     const pluginHost = {
         entry: rt.entry,
         options: rt.options,
-        subscribe: (t) => rt.subscribe(t),
-        hasPublisher: (t) => rt.hasPublisher(t),
+        subscribe: (channelToken) => rt.subscribe(channelToken),
+        hasPublisher: (channelToken) => rt.hasPublisher(channelToken),
         elements: rt.elements,
-        defer: (p) => rt.defer(p)
+        defer: (deferredPromise) => rt.defer(deferredPromise)
     };
     const pluginSetupValues = new Map();
     for (const plugin of input.plugins ?? []) {
-        const v = await plugin.setup(pluginHost);
-        if (typeof v !== "undefined") {
-            pluginSetupValues.set(plugin, v);
+        const setupValue = await plugin.setup(pluginHost);
+        if (typeof setupValue !== "undefined") {
+            pluginSetupValues.set(plugin, setupValue);
         }
     }
-    const mergePatch = (_ctx, patch) => {
-        return mergePatchIntoFreshContext(patch);
-    };
+    const mergePatch = (_ctx, patch) => mergePatchIntoFreshContext(patch);
     let ctx = { value: {} };
     let result;
     try {
@@ -42,13 +40,13 @@ export const runCapture = async (input) => {
             let pluginContributedValue = {};
             if (boundPlugins.length > 0) {
                 const pluginResults = await Promise.allSettled(boundPlugins
-                    .filter((p) => typeof p.contribute === "function")
-                    .map(async (p) => p.contribute({ value: ctx.value, setupValue: pluginSetupValues.get(p) }, rt)));
-                for (const r of pluginResults) {
-                    if (r.status !== "fulfilled") {
+                    .filter((pluginBinding) => typeof pluginBinding.contribute === "function")
+                    .map(async (pluginBinding) => pluginBinding.contribute({ value: ctx.value, setupValue: pluginSetupValues.get(pluginBinding) }, rt)));
+                for (const pluginResult of pluginResults) {
+                    if (pluginResult.status !== "fulfilled") {
                         continue;
                     }
-                    const patch = r.value;
+                    const patch = pluginResult.value;
                     if (!patch || typeof patch !== "object") {
                         continue;
                     }

package/dist/units/types.d.ts

@@ -1,4 +1,4 @@
-import type { CompletionStrategy, ContentStore, PathResolver, ResourceFilter } from "../types.js";
+import type { CompletionStrategy, ContentStore, PagePocketOptions, PathResolver, ResourceFilter } from "../types.js";
 export type EntryInfo = {
     kind: "url";
     url: string;
@@ -36,4 +36,4 @@ export interface CaptureOptions {
         maxResources?: number;
     };
 }
-export type PagePocketOptions = import("../types.js").PagePocketOptions;
+export type { PagePocketOptions };

package/dist/utils.js

@@ -4,8 +4,8 @@ const FNV_PRIME = 0x01000193;
 export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 export const hashString = (value) => {
     let hash = FNV_OFFSET;
-    for (let i = 0; i < value.length; i += 1) {
-        hash ^= value.charCodeAt(i);
+    for (let characterIndex = 0; characterIndex < value.length; characterIndex += 1) {
+        hash ^= value.charCodeAt(characterIndex);
         hash = (hash * FNV_PRIME) >>> 0;
     }
     return hash.toString(16).padStart(8, "0");
@@ -24,9 +24,7 @@ export const sanitizePosixPath = (value) => {
     }
     return clean.join("/");
 };
-const getGlobalBuffer = () => {
-    return globalThis.Buffer;
-};
+const getGlobalBuffer = () => globalThis.Buffer;
 export const bytesToBase64 = (bytes) => {
     const BufferCtor = getGlobalBuffer();
     if (BufferCtor) {
@@ -34,8 +32,8 @@ export const bytesToBase64 = (bytes) => {
     }
     let binary = "";
     const chunkSize = 0x8000;
-    for (let i = 0; i < bytes.length; i += chunkSize) {
-        const chunk = bytes.subarray(i, i + chunkSize);
+    for (let chunkStart = 0; chunkStart < bytes.length; chunkStart += chunkSize) {
+        const chunk = bytes.subarray(chunkStart, chunkStart + chunkSize);
         binary += String.fromCharCode(...chunk);
     }
     return btoa(binary);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagepocket/lib",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "description": "Library for rewriting HTML snapshots and inlining local resources.",
   "type": "module",
   "main": "dist/index.js",
@@ -20,9 +20,9 @@
   "dependencies": {
     "cheerio": "^1.0.0-rc.12",
     "domhandler": "^5.0.3",
-    "@pagepocket/contracts": "0.11.1",
-    "@pagepocket/uni-fs": "0.11.1",
-    "@pagepocket/shared": "0.11.1"
+    "@pagepocket/contracts": "0.12.0",
+    "@pagepocket/uni-fs": "0.12.0",
+    "@pagepocket/shared": "0.12.0"
   },
   "devDependencies": {
     "@playwright/test": "^1.50.1",