roxxie-proxy-u-prod 0.1.0

package/source/packages/scramjet/packages/core/dist/types/Tap.d.ts

@@ -0,0 +1,39 @@
+type Description = {
+    context?: object;
+    props?: object;
+};
+type Callback<T extends Description> = (context: T["context"], props: T["props"]) => void | Promise<void>;
+export type TapOrder = {
+    /** Run before these plugins. */
+    before?: readonly string[];
+    /** Run after these plugins. */
+    after?: readonly string[];
+};
+type CallbackInfo<T extends Description> = {
+    callback: Callback<T>;
+    plugin: Plugin;
+    order: TapOrder;
+};
+type InternalHookDescription = {
+    tap: TapInternal;
+    key: string;
+};
+type TapInternal = {
+    callbacks: Record<string, CallbackInfo<Description>[]>;
+};
+export type TapInstance<T extends Record<string, Description>> = {
+    [K in keyof T]: T[K] & InternalHookDescription;
+};
+export declare class Plugin {
+    name: string;
+    readonly tapOrder: TapOrder;
+    constructor(name: string, tapOrder?: TapOrder);
+    tap<T extends Description>(hook: T, callback: Callback<T>, order?: TapOrder): void;
+}
+export declare class Tap {
+    static dispatch<T extends Description>(hook: T, context: T["context"], props: T["props"]): Promise<void[]> | null;
+    static tap<T extends Description>(hook: T, callback: Callback<T>, plugin?: Plugin, order?: TapOrder): void;
+    static create<T extends Record<string, Description>>(): TapInstance<T>;
+    static getTappers<T extends Description>(hook: T): Plugin[];
+}
+export {};

package/source/packages/scramjet/packages/core/dist/types/client/client.d.ts

@@ -0,0 +1,115 @@
+import { BareCompatibleClient, ProxyTransport, RawHeaders } from "@mercuryworkshop/proxy-transports";
+import { LifecycleHooks } from "./events";
+import { RewriteUrlOptions, type URLMeta } from "../shared/rewriters/url";
+import { HtmlRewriterHooks, ScramjetContext, ScramjetHeaders } from "../shared";
+import { SingletonBox } from "./singletonbox";
+import { ScramjetConfig } from "../types";
+import { type CookieSyncEntry, type CookieSyncOptions, TrackedHistoryState } from "../fetch";
+import { AnyFunction } from "../types";
+import { _URL } from "../shared/snapshot";
+type IfEquals<T, U, Y = unknown, N = never> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? Y : N;
+type Traverse<O extends Record<any, any>, P extends string> = P extends `${infer K}.${infer R}` ? Traverse<O[K], R> : O[P];
+type GlobalTraverse<P extends string> = Traverse<GlobalThis & Record<string, any>, P>;
+type ProxyApplyThis<T extends string> = unknown extends ThisParameterType<Extract<GlobalTraverse<T>, AnyFunction>> ? T extends `${infer ClassName}.prototype.${string}` ? GlobalTraverse<ClassName> extends {
+    prototype: infer Proto;
+} ? Proto : unknown : unknown : ThisParameterType<Extract<GlobalTraverse<T>, AnyFunction>>;
+export type ScramjetClientInit = {
+    context: ScramjetContext;
+    transport: ProxyTransport;
+    sendSetCookie: (cookies: CookieSyncEntry[], options?: CookieSyncOptions) => Promise<void>;
+    shouldBlockMessageEvent?: (ev: MessageEvent) => boolean;
+    hookSubcontext: (self: Self, frame?: HTMLIFrameElement) => ScramjetClient;
+    initHeaders: RawHeaders;
+    history: TrackedHistoryState[];
+};
+type NativeStore = {
+    store: Record<string, any>;
+    construct: <T extends string>(target: T, ...args: ConstructorParameters<GlobalTraverse<T>>) => InstanceType<GlobalTraverse<T>>;
+    call: <T extends string>(target: T, that: ProxyApplyThis<T>, ...args: Parameters<GlobalTraverse<T>>) => ReturnType<GlobalTraverse<T>>;
+};
+type DescriptorStore = {
+    store: Record<string, PropertyDescriptor>;
+    get: <T extends string>(target: T, that: any) => GlobalTraverse<T>;
+    set: <T extends string>(target: T, that: any, value: GlobalTraverse<T>) => void;
+};
+export type ProxyCtx<T extends string = string, U extends "construct" | "apply" = "apply"> = {
+    fn: GlobalTraverse<T>;
+    this: IfEquals<U, "construct", null, ProxyApplyThis<T>>;
+    args: IfEquals<U, "construct", ConstructorParameters<GlobalTraverse<T>>, Parameters<GlobalTraverse<T>>>;
+    newTarget: IfEquals<U, "construct", GlobalTraverse<T>, null>;
+    return: (r: IfEquals<U, "construct", InstanceType<GlobalTraverse<T>>, ReturnType<GlobalTraverse<T>>>) => void;
+    call: () => IfEquals<U, "construct", InstanceType<GlobalTraverse<T>>, ReturnType<GlobalTraverse<T>>>;
+};
+export type Proxy<T extends string = string> = {
+    construct?(ctx: ProxyCtx<T, "construct">): any;
+    apply?(ctx: ProxyCtx<T, "apply">): any;
+};
+export type TrapCtx<T extends string> = {
+    this: any;
+    get: () => GlobalTraverse<T>;
+    set: (v: GlobalTraverse<T>) => void;
+};
+export type Trap<T extends string> = {
+    writable?: boolean;
+    value?: any;
+    enumerable?: boolean;
+    configurable?: boolean;
+    get?: (ctx: TrapCtx<T>) => GlobalTraverse<T>;
+    set?: (ctx: TrapCtx<T>, v: GlobalTraverse<T>) => void;
+};
+export type ScramjetModule = {
+    enabled: (client: ScramjetClient) => boolean | undefined;
+    disabled: (client: ScramjetClient, self: GlobalThis) => void | undefined;
+    order: number | undefined;
+    default: (client: ScramjetClient, self: GlobalThis) => void;
+};
+export declare class ScramjetClient {
+    global: GlobalThis;
+    init: ScramjetClientInit;
+    locationProxy: any;
+    serviceWorker: ServiceWorkerContainer;
+    bare: BareCompatibleClient;
+    natives: NativeStore;
+    descriptors: DescriptorStore;
+    wrapfn: (i: any, ...args: any) => any;
+    eventcallbacks: Map<any, [
+        {
+            event: string;
+            originalCallback: AnyFunction;
+            proxiedCallback: AnyFunction;
+        }
+    ]>;
+    meta: URLMeta;
+    box: SingletonBox;
+    context: ScramjetContext;
+    initHeaders: ScramjetHeaders;
+    history: TrackedHistoryState[];
+    private flagCache;
+    hooks: {
+        rewriter: {
+            html: import("../Tap").TapInstance<HtmlRewriterHooks>;
+        };
+        lifecycle: import("../Tap").TapInstance<LifecycleHooks>;
+    };
+    constructor(global: GlobalThis, init: ScramjetClientInit);
+    /** Apply document injection init when a client was already installed (e.g. early contentWindow). */
+    syncDocumentInit(init: {
+        initHeaders: RawHeaders;
+        history: TrackedHistoryState[];
+        cookies?: string;
+    }): void;
+    hook(): void;
+    get url(): _URL;
+    set url(url: _URL | string);
+    Proxy<T extends string>(name: T, handler: Proxy<T>): void;
+    Proxy<const T extends readonly string[]>(name: T, handler: Proxy<T[number]>): void;
+    RawProxy(target: any, prop: string, handler: Proxy<any>, debugname?: string): void;
+    Trap<T extends string>(name: T, handler: Trap<T>): void;
+    Trap<const T extends readonly string[]>(name: T, handler: Trap<T[number]>): void;
+    RawTrap(target: any, prop: string, descriptor: Trap<any>): void;
+    rewriteUrl(url: string | URL, options?: RewriteUrlOptions): string;
+    unrewriteUrl(url: string | URL): string;
+    flagEnabled(flag: keyof ScramjetConfig["flags"]): boolean;
+    get config(): ScramjetConfig;
+}
+export {};

package/source/packages/scramjet/packages/core/dist/types/client/entry.d.ts

@@ -0,0 +1,5 @@
+export declare const iswindow: boolean;
+export declare const isworker: boolean;
+export declare const issw: boolean;
+export declare const isdedicated: boolean;
+export declare const isshared: boolean;

package/source/packages/scramjet/packages/core/dist/types/client/events.d.ts

@@ -0,0 +1,10 @@
+export type LifecycleHooks = {
+    navigate: {
+        context: {
+            type: "location" | "history" | "hashchange";
+        };
+        props: {
+            url: string;
+        };
+    };
+};

package/source/packages/scramjet/packages/core/dist/types/client/helpers.d.ts

@@ -0,0 +1 @@
+export declare function getOwnPropertyDescriptorHandler(target: any, prop: any): PropertyDescriptor;

package/source/packages/scramjet/packages/core/dist/types/client/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./client";
+export * from "./entry";
+export * from "./events";
+export * from "./helpers";
+export * from "./location";
+export * from "./index";
+export * from "./location";

package/source/packages/scramjet/packages/core/dist/types/client/location.d.ts

@@ -0,0 +1,2 @@
+import { ScramjetClient } from "./index";
+export declare function createLocationProxy(client: ScramjetClient, self: GlobalThis): any;

package/source/packages/scramjet/packages/core/dist/types/client/shared/eval.d.ts

@@ -0,0 +1,3 @@
+import { ScramjetClient } from "../index";
+export default function (client: ScramjetClient, self: Self): void;
+export declare function indirectEval(this: ScramjetClient, strict: boolean, js: any): any;

package/source/packages/scramjet/packages/core/dist/types/client/shared/sourcemaps.d.ts

@@ -0,0 +1,19 @@
+import { ScramjetClient } from "../index";
+declare enum RewriteType {
+    Insert = 0,
+    Replace = 1
+}
+type Rewrite = {
+    start: number;
+} & ({
+    type: RewriteType.Insert;
+    size: number;
+} | {
+    type: RewriteType.Replace;
+    end: number;
+    str: string;
+});
+export type SourceMaps = Record<string, Rewrite[]>;
+export declare const enabled: (client: ScramjetClient) => boolean;
+export default function (client: ScramjetClient, self: Self): void;
+export {};

package/source/packages/scramjet/packages/core/dist/types/client/shared/wrap.d.ts

@@ -0,0 +1,4 @@
+import { ScramjetClient } from "../index";
+export declare function createWrapFn(client: ScramjetClient, self: GlobalThis): (identifier: any, strict: boolean) => any;
+export declare const order = 4;
+export default function (client: ScramjetClient, self: GlobalThis): void;

package/source/packages/scramjet/packages/core/dist/types/client/singletonbox.d.ts

@@ -0,0 +1,18 @@
+import { IncrementalHtmlRewriter } from "../shared";
+import { ScramjetClient } from "./client";
+import { SourceMaps } from "./shared/sourcemaps";
+export declare class SingletonBox {
+    ownerclient: ScramjetClient;
+    clients: ScramjetClient[];
+    globals: Map<Self, ScramjetClient>;
+    documents: Map<Document, ScramjetClient>;
+    histories: Map<History, ScramjetClient>;
+    locations: Map<Location, ScramjetClient>;
+    writeRewriters: WeakMap<Document, IncrementalHtmlRewriter>;
+    unproxy: Map<any, any>;
+    ctors: Record<string, Function[]>;
+    sourcemaps: SourceMaps;
+    constructor(ownerclient: ScramjetClient);
+    registerClient(client: ScramjetClient, global: Self): void;
+    instanceof(obj: any, name: string): boolean;
+}

package/source/packages/scramjet/packages/core/dist/types/fetch/body.d.ts

@@ -0,0 +1,3 @@
+import { BareResponse } from "@mercuryworkshop/proxy-transports";
+import { BodyType, ScramjetFetchHandler, ScramjetFetchParsed, ScramjetFetchRequest } from ".";
+export declare function rewriteBody(handler: ScramjetFetchHandler, request: ScramjetFetchRequest, parsed: ScramjetFetchParsed, response: BareResponse): Promise<BodyType>;

package/source/packages/scramjet/packages/core/dist/types/fetch/fetch.d.ts

@@ -0,0 +1,7 @@
+import { BareResponse } from "@mercuryworkshop/proxy-transports";
+import { ScramjetFetchHandler, ScramjetFetchParsed, ScramjetFetchRequest, ScramjetFetchResponse } from ".";
+import { ScramjetHeaders } from "../shared";
+export declare function doHandleFetch(handler: ScramjetFetchHandler, request: ScramjetFetchRequest): Promise<ScramjetFetchResponse>;
+export declare function doNetworkFetch(handler: ScramjetFetchHandler, request: ScramjetFetchRequest, parsed: ScramjetFetchParsed, newheaders: ScramjetHeaders): Promise<BareResponse>;
+/** Simplified registrable-domain check used for cross-site redirect detection. */
+export declare function registrableDomainForRedirect(hostname: string): string;

package/source/packages/scramjet/packages/core/dist/types/fetch/headers.d.ts

@@ -0,0 +1,19 @@
+import { ScramjetHeaders } from "../shared";
+import { ScramjetFetchHandler, ScramjetFetchParsed, ScramjetFetchRequest } from ".";
+import { RawHeaders } from "@mercuryworkshop/proxy-transports";
+export declare function rewriteResponseHeaders(handler: ScramjetFetchHandler, request: ScramjetFetchRequest, parsed: ScramjetFetchParsed, rawHeaders: RawHeaders): Promise<ScramjetHeaders>;
+export declare function rewriteRequestHeaders(request: ScramjetFetchRequest, handler: ScramjetFetchHandler, parsed: ScramjetFetchParsed): ScramjetHeaders;
+/**
+ * Compute the immediate Sec-Fetch-Site relation between an initiator origin and
+ * a destination URL.
+ *
+ * - "same-origin" if scheme + host + port match exactly.
+ * - "same-site" if scheme matches and the registrable domains match.
+ * - "cross-site" otherwise.
+ */
+export declare function computeFetchSite(originUrl: URL, destUrl: URL): "same-origin" | "same-site" | "cross-site";
+/**
+ * Combine two Sec-Fetch-Site classifications, returning the "worst" (least
+ * trusted) of the two. Used when propagating state through redirect chains.
+ */
+export declare function worstFetchSite(a: "none" | "same-origin" | "same-site" | "cross-site", b: "none" | "same-origin" | "same-site" | "cross-site"): "none" | "same-origin" | "same-site" | "cross-site";

package/source/packages/scramjet/packages/core/dist/types/fetch/index.d.ts

@@ -0,0 +1,128 @@
+import { BareCompatibleClient, BareResponse, ProxyTransport, BareRequestInit } from "@mercuryworkshop/proxy-transports";
+import { type URLMeta } from "../shared/rewriters/url";
+import { ScramjetHeaders } from "../shared/headers";
+import { HtmlRewriterHooks, ScramjetContext } from "../shared";
+import { TapInstance } from "../Tap";
+import { _URL } from "../shared/snapshot";
+export interface ScramjetFetchRequest {
+    rawUrl: URL;
+    rawReferrer: string | null;
+    rawDestination: RequestDestination;
+    mode: RequestMode;
+    referrer: string;
+    method: string;
+    body: BodyType | null;
+    cache: RequestCache;
+    initialHeaders: ScramjetHeaders;
+    rawClientUrl?: URL;
+    /** The service worker FetchEvent.clientId that originated this request. */
+    clientId: string;
+}
+export interface ScramjetFetchParsed {
+    url: _URL;
+    clientUrl?: _URL;
+    referrerSourceUrl?: _URL | null;
+    hadExtraParams: boolean;
+    crossSiteRedirect: boolean;
+    fetchSiteState?: "same-origin" | "same-site" | "cross-site";
+    fetchInitiatorOrigin?: string;
+    fetchCredentialsInclude?: boolean;
+    fetchMode?: RequestMode;
+    isIframe?: boolean;
+    destination: RequestDestination;
+    meta: URLMeta;
+    isModule: boolean;
+    isFakeDataURL: boolean;
+    referrerPolicy?: string;
+    trackedClient?: ScramjetFetchTrackedClient;
+}
+export interface ScramjetFetchResponse {
+    body: BodyType;
+    headers: ScramjetHeaders;
+    status: number;
+    statusText: string;
+}
+export type CookieSyncEntry = {
+    url: URL;
+    cookie: string;
+};
+export type CookieSyncOptions = {
+    clear?: boolean;
+    destination?: RequestDestination;
+};
+export type FetchHandlerInit = {
+    transport: ProxyTransport;
+    context: ScramjetContext;
+    crossOriginIsolated?: boolean;
+    sendSetCookie: (cookies: CookieSyncEntry[], options?: CookieSyncOptions) => Promise<void>;
+    fetchDataUrl(dataUrl: string): Promise<BareResponse>;
+    fetchBlobUrl(blobUrl: string): Promise<BareResponse>;
+};
+export type TrackedHistoryState = {
+    url: string;
+    refererPolicy?: string;
+};
+export declare class ScramjetFetchTrackedClient {
+    clientId: string;
+    history: TrackedHistoryState[];
+    constructor(clientId: string);
+}
+export declare class ScramjetFetchHandler extends EventTarget {
+    client: BareCompatibleClient;
+    crossOriginIsolated: boolean;
+    context: ScramjetContext;
+    trackedClients: Map<string, ScramjetFetchTrackedClient>;
+    hooks: {
+        rewriter: {
+            html: TapInstance<HtmlRewriterHooks>;
+        };
+        fetch: TapInstance<FetchHooks>;
+    };
+    fetchDataUrl: (dataUrl: string) => Promise<Response>;
+    fetchBlobUrl: (blobUrl: string) => Promise<Response>;
+    sendSetCookie: (cookies: CookieSyncEntry[], options?: CookieSyncOptions) => Promise<void>;
+    constructor(init: FetchHandlerInit);
+    handleFetch(request: ScramjetFetchRequest): Promise<ScramjetFetchResponse>;
+}
+export type FetchHooks = {
+    intercept: {
+        context: {
+            request: ScramjetFetchRequest;
+            parsed: ScramjetFetchParsed;
+        };
+        props: {
+            response?: ScramjetFetchResponse;
+        };
+    };
+    request: {
+        context: {
+            request: ScramjetFetchRequest;
+            parsed: ScramjetFetchParsed;
+            client: BareCompatibleClient;
+        };
+        props: {
+            init: BareRequestInit;
+            url: URL;
+            earlyResponse?: BareResponse;
+        };
+    };
+    preresponse: {
+        context: {
+            request: ScramjetFetchRequest;
+            parsed: ScramjetFetchParsed;
+        };
+        props: {
+            response: BareResponse;
+        };
+    };
+    response: {
+        context: {
+            request: ScramjetFetchRequest;
+            parsed: ScramjetFetchParsed;
+        };
+        props: {
+            response: ScramjetFetchResponse;
+        };
+    };
+};
+export type BodyType = string | ArrayBuffer | Blob | ReadableStream<any>;

package/source/packages/scramjet/packages/core/dist/types/fetch/parse.d.ts

@@ -0,0 +1,23 @@
+import { ScramjetFetchHandler, ScramjetFetchParsed, ScramjetFetchRequest } from ".";
+export declare const QP: {
+    readonly referrerPolicy: "$rfp";
+    readonly referrerSource: "$rfs";
+    readonly isModule: "$module";
+    readonly topFrame: "$tf";
+    readonly parentFrame: "$pf";
+    readonly isIframe: "$iframe";
+    readonly mode: "$mode";
+    readonly credentials: "$cred";
+    readonly destination: "$dest";
+    readonly initiatorOrigin: "$io";
+    readonly fetchSite: "$fs";
+    readonly crossSiteRedirect: "$csr";
+    readonly fakeDataURL: "$fakedataurl";
+};
+export type QueryParamKey = keyof typeof QP;
+export type QueryParams = Partial<Record<QueryParamKey, string>>;
+export declare function parseQueryParams(searchParams: URLSearchParams): {
+    params: QueryParams;
+    extras: Record<string, string>;
+};
+export declare function parseRequest(request: ScramjetFetchRequest, handler: ScramjetFetchHandler): ScramjetFetchParsed;

package/source/packages/scramjet/packages/core/dist/types/fetch/util.d.ts

@@ -0,0 +1,7 @@
+import { ScramjetHeaders } from "../shared";
+import { BareResponse } from "@mercuryworkshop/proxy-transports";
+import { ScramjetFetchParsed } from ".";
+export declare function normalizeContentType(parsed: ScramjetFetchParsed, headers: ScramjetHeaders): void;
+export declare function isRedirect(response: BareResponse): boolean;
+export declare function isDocument(parsed: ScramjetFetchParsed): boolean;
+export declare function createReferrerString(clientUrl: URL, resource: URL, policy: string | null): string;

package/source/packages/scramjet/packages/core/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+import "./global.d";
+import { ScramjetVersionInfo, ScramjetConfig } from "./types";
+export declare const versionInfo: ScramjetVersionInfo;
+export declare const defaultConfig: ScramjetConfig;
+export declare const defaultConfigDev: ScramjetConfig;
+export * from "./symbols";
+export * from "./types";
+export * from "./Tap";
+export * from "./shared";
+export * from "./fetch";
+export { BareResponse } from "@mercuryworkshop/proxy-transports";
+export * from "./client";

package/source/packages/scramjet/packages/core/dist/types/shared/cookie.d.ts

@@ -0,0 +1,26 @@
+export type Cookie = {
+    name: string;
+    value: string;
+    path?: string;
+    expires?: number;
+    maxAge?: number;
+    domain?: string;
+    hostOnly?: boolean;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: string;
+};
+export declare class CookieJar {
+    private cookies;
+    private byDomain;
+    private defaultPath;
+    private pathMatches;
+    private indexCookie;
+    private unindexCookie;
+    private removeById;
+    setCookies(cookieString: string, url: URL): void;
+    getCookies(url: URL, fromJs: boolean, sameSiteContext?: "strict" | "lax" | "cross-site"): string;
+    load(cookies: string | Record<string, Cookie>): void;
+    clear(): void;
+    dump(): string;
+}

package/source/packages/scramjet/packages/core/dist/types/shared/headers.d.ts

@@ -0,0 +1,13 @@
+import { RawHeaders } from "@mercuryworkshop/proxy-transports";
+export declare class ScramjetHeaders {
+    headers: {};
+    set(key: string, v: string): void;
+    get(key: string): string | null;
+    delete(key: string): void;
+    has(key: string): boolean;
+    toRawHeaders(): RawHeaders;
+    toNativeHeaders(): Headers;
+    static fromRawHeaders(raw: RawHeaders): ScramjetHeaders;
+    static fromNativeHeaders(native: Headers): ScramjetHeaders;
+    clone(): ScramjetHeaders;
+}

package/source/packages/scramjet/packages/core/dist/types/shared/htmlRules.d.ts

@@ -0,0 +1,6 @@
+import { URLMeta } from "./rewriters/url";
+import { ScramjetContext } from "../shared";
+export declare const htmlRules: {
+    [key: string]: "*" | string[] | ((...any: any[]) => string | null);
+    fn: (value: string, context: ScramjetContext, meta: URLMeta, attrs?: Record<string, string | undefined>) => string | null;
+}[];

package/source/packages/scramjet/packages/core/dist/types/shared/index.d.ts

@@ -0,0 +1,50 @@
+import { ScramjetConfig, ScramjetFlags } from "../types";
+import DomHandler, { Element } from "domhandler";
+import { URLMeta } from "./rewriters/url";
+import { CookieJar } from "./cookie";
+import { TapInstance } from "../Tap";
+import { HtmlContext } from "../shared/rewriters/html";
+export * from "./cookie";
+export * from "./headers";
+export * from "./htmlRules";
+export * from "./mime";
+export * from "./rewriters";
+export declare function flagEnabled(flag: keyof ScramjetFlags, context: ScramjetContext, url: URL): boolean;
+export type ScramjetInterface = {
+    codecEncode: (input: string) => string;
+    codecDecode: (input: string) => string;
+    getInjectScripts(meta: URLMeta, handler: DomHandler, htmlcontext: HtmlContext, script: (src: string) => Element): Element[];
+    getWorkerInjectScripts?(meta: URLMeta, isModule: boolean, script: (src: string) => string): string;
+};
+export type ScramjetContext = {
+    config: ScramjetConfig;
+    prefix: URL;
+    interface: ScramjetInterface;
+    cookieJar: CookieJar;
+    hooks?: {
+        rewriter: {
+            html: TapInstance<HtmlRewriterHooks>;
+        };
+    };
+};
+export type HtmlRewriterHooks = {
+    pre: {
+        context: {
+            handler: DomHandler;
+            meta: URLMeta;
+            origHtml: string;
+            htmlcontext: HtmlContext;
+        };
+    };
+    post: {
+        context: {
+            handler: DomHandler;
+            meta: URLMeta;
+            origHtml: string;
+            htmlcontext: HtmlContext;
+        };
+        props: {
+            setRawHtml?: string;
+        };
+    };
+};

package/source/packages/scramjet/packages/core/dist/types/shared/mime.d.ts

@@ -0,0 +1,53 @@
+export interface ParsedMimeType {
+    type: string;
+    subtype: string;
+    /** `type`/`subtype` in ASCII lowercase; excludes parameters. */
+    essence: string;
+}
+/**
+ * Parses a MIME type string (e.g. a Content-Type value) into type, subtype, and essence.
+ * Returns null if the input is not a valid MIME type.
+ */
+export declare function parseMimeType(input: string): ParsedMimeType | null;
+/** A MIME type whose type is "image". */
+export declare function isImageMimeType(mime: string | ParsedMimeType): boolean;
+/** Audio, video, or essence `application/ogg`. */
+export declare function isAudioOrVideoMimeType(mime: string | ParsedMimeType): boolean;
+/** Type `font` or a registered font essence. */
+export declare function isFontMimeType(mime: string | ParsedMimeType): boolean;
+/** Subtype ends with `+zip` or essence `application/zip`. */
+export declare function isZipBasedMimeType(mime: string | ParsedMimeType): boolean;
+/** One of the archive essences. */
+export declare function isArchiveMimeType(mime: string | ParsedMimeType): boolean;
+/** Subtype ends with `+xml` or essence `text/xml` / `application/xml`. */
+export declare function isXmlMimeType(mime: string | ParsedMimeType): boolean;
+/** Essence `text/html`. */
+export declare function isHtmlMimeType(mime: string | ParsedMimeType): boolean;
+/** XML, HTML, or `application/pdf`. */
+export declare function isScriptableMimeType(mime: string | ParsedMimeType): boolean;
+/** Essence is one of the JavaScript MIME type essences. */
+export declare function isJavascriptMimeType(mime: string | ParsedMimeType): boolean;
+/**
+ * True if the string is an ASCII case-insensitive match for one of the
+ * JavaScript MIME type essence strings (not necessarily a full parsed MIME type).
+ */
+export declare function isJavascriptMimeTypeEssenceMatch(s: string): boolean;
+/**
+ * Script block type string for a `<script>` element (prepare a script).
+ * Resolves `type` when present; otherwise maps obsolete `language` to `text/…`.
+ * @see https://html.spec.whatwg.org/multipage/scripting.html#prepare-a-script
+ */
+export declare function getScriptBlockTypeString(type: string | null | undefined, language: string | null | undefined, hasTypeAttribute?: boolean, hasLanguageAttribute?: boolean): string;
+/**
+ * Whether a `<script type="...">` value denotes executable JavaScript
+ * (classic or module script), not a data block or import map.
+ * @see https://html.spec.whatwg.org/multipage/scripting.html#attr-script-type
+ */
+export declare function isScriptType(type: string | null | undefined): boolean;
+/** Whether `type` denotes a JavaScript module script. */
+export declare function isModuleScriptType(type: string | null | undefined): boolean;
+/**
+ * MIME types typically shown inline in a browsing context (navigation / iframe),
+ * as opposed to triggering a download when Content-Disposition is absent.
+ */
+export declare function isInlineDisplayableMimeType(mime: string | ParsedMimeType): boolean;

package/source/packages/scramjet/packages/core/dist/types/shared/refresh.d.ts

@@ -0,0 +1,7 @@
+export type ParsedDeclarativeRefresh = {
+    time: number;
+    urlStart: number;
+    urlEnd: number;
+    url: string | null;
+};
+export declare function parseDeclarativeRefresh(input: string): ParsedDeclarativeRefresh | null;

package/source/packages/scramjet/packages/core/dist/types/shared/rewriters/css.d.ts

@@ -0,0 +1,4 @@
+import { URLMeta } from "./url";
+import { ScramjetContext } from "../../shared";
+export declare function rewriteCss(css: string, context: ScramjetContext, meta: URLMeta): string;
+export declare function unrewriteCss(css: string, context: ScramjetContext): string;

package/source/packages/scramjet/packages/core/dist/types/shared/rewriters/html.d.ts

@@ -0,0 +1,33 @@
+import { URLMeta } from "./url";
+import { ScramjetContext } from "../../shared";
+import { RawHeaders } from "@mercuryworkshop/proxy-transports";
+import { TrackedHistoryState } from "../../fetch";
+export type ForeignContext = "svg" | "math" | "html";
+export type HtmlContext = {
+    loadScripts: boolean;
+    inline: boolean;
+    source: string;
+    apisource?: string;
+    headers?: RawHeaders;
+    foreignContext?: ForeignContext;
+    history?: TrackedHistoryState[];
+};
+export declare class IncrementalHtmlRewriter {
+    private readonly context;
+    private readonly meta;
+    private readonly htmlcontext;
+    private readonly handler;
+    private readonly parser;
+    private readonly completedElements;
+    private readonly emittedLengths;
+    private readonly rewrittenNodes;
+    private ended;
+    constructor(context: ScramjetContext, meta: URLMeta, htmlcontext: HtmlContext);
+    write(html: string): string;
+    end(html?: string): string;
+    private flush;
+    private getAvailableOutput;
+}
+export declare function rewriteHtml(html: string, context: ScramjetContext, meta: URLMeta, htmlcontext: HtmlContext): string;
+export declare function unrewriteHtml(html: string, foreignContext?: ForeignContext): string;
+export declare function rewriteSrcset(srcset: string, context: ScramjetContext, meta: URLMeta): string;