@mercuryworkshop/scramjet 2.0.0-alpha → 2.0.1-alpha

package/dist/types/client/client.d.ts

@@ -0,0 +1,91 @@
+type ScramjetFrame = any;
+import { BareCompatibleClient, ProxyTransport } from "@mercuryworkshop/proxy-transports";
+import { type URLMeta } from "../shared/rewriters/url";
+import { ScramjetContext } from "../shared";
+import { SingletonBox } from "./singletonbox";
+import { ScramjetConfig } from "../types";
+export type ScramjetClientInit = {
+    context: ScramjetContext;
+    transport: ProxyTransport;
+    sendSetCookie: (url: URL, cookie: string) => Promise<void>;
+    shouldPassthroughWebsocket?: (url: string | URL) => boolean;
+    shouldBlockMessageEvent?: (ev: MessageEvent) => boolean;
+    hookSubcontext: (self: Self, frame?: HTMLIFrameElement) => ScramjetClient;
+};
+type NativeStore = {
+    store: Record<string, any>;
+    call: (target: string, that: any, ...args: any[]) => any;
+    construct: (target: string, ...args: any[]) => any;
+};
+type DescriptorStore = {
+    store: Record<string, PropertyDescriptor>;
+    get: (target: string, that: any) => any;
+    set: (target: string, that: any, value: any) => void;
+};
+export type AnyFunction = Function;
+export type ScramjetModule = {
+    enabled: (client: ScramjetClient) => boolean | undefined;
+    disabled: (client: ScramjetClient, self: typeof globalThis) => void | undefined;
+    order: number | undefined;
+    default: (client: ScramjetClient, self: typeof globalThis) => void;
+};
+export type ProxyCtx = {
+    fn: AnyFunction;
+    this: any;
+    args: any[];
+    newTarget: AnyFunction;
+    return: (r: any) => void;
+    call: () => any;
+};
+export type Proxy = {
+    construct?(ctx: ProxyCtx): any;
+    apply?(ctx: ProxyCtx): any;
+};
+export type TrapCtx<T> = {
+    this: any;
+    get: () => T;
+    set: (v: T) => void;
+};
+export type Trap<T> = {
+    writable?: boolean;
+    value?: any;
+    enumerable?: boolean;
+    configurable?: boolean;
+    get?: (ctx: TrapCtx<T>) => T;
+    set?: (ctx: TrapCtx<T>, v: T) => void;
+};
+export declare class ScramjetClient {
+    global: typeof 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;
+    constructor(global: typeof globalThis, init: ScramjetClientInit);
+    get frame(): ScramjetFrame | null;
+    get isSubframe(): boolean;
+    hook(): void;
+    get url(): URL;
+    set url(url: URL | string);
+    Proxy(name: string | string[], handler: Proxy): void;
+    RawProxy(target: any, prop: string, handler: Proxy, debugname?: string): void;
+    Trap<T>(name: string | string[], descriptor: Trap<T>): PropertyDescriptor;
+    RawTrap<T>(target: any, prop: string, descriptor: Trap<T>): PropertyDescriptor;
+    rewriteUrl(url: string | URL): string;
+    unrewriteUrl(url: string | URL): string;
+    flagEnabled(flag: keyof ScramjetConfig["flags"]): boolean;
+    get config(): ScramjetConfig;
+}
+export {};

package/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/dist/types/client/events.d.ts

@@ -0,0 +1,38 @@
+import { ScramjetClient } from "./index";
+/**
+ * Union type for all Scramjet proxified navigation events.
+ */
+export type ScramjetEvent = NavigateEvent | UrlChangeEvent | ScramjetContextEvent;
+/**
+ * Type map for all Scramjet navigation events with their corresponding event types.
+ */
+export type ScramjetEvents = {
+    navigate: NavigateEvent;
+    urlchange: UrlChangeEvent;
+    contextInit: ScramjetContextEvent;
+};
+/**
+ * Navigation event class fired when Scramjet frame navigates to a new proxified URL.
+ */
+export declare class NavigateEvent extends Event {
+    url: string;
+    type: string;
+    constructor(url: string);
+}
+/**
+ * URL change event class fired when the proxified URL changes in a Scramjet frame.
+ */
+export declare class UrlChangeEvent extends Event {
+    url: string;
+    type: string;
+    constructor(url: string);
+}
+/**
+ * Event class fired when Scramjet initializes in a frame.
+ */
+export declare class ScramjetContextEvent extends Event {
+    window: Self;
+    client: ScramjetClient;
+    type: string;
+    constructor(window: Self, client: ScramjetClient);
+}

package/dist/types/client/helpers.d.ts

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

package/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/dist/types/client/location.d.ts

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

package/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/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/dist/types/client/shared/wrap.d.ts

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

package/dist/types/client/singletonbox.d.ts

@@ -0,0 +1,14 @@
+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>;
+    locations: Map<Location, ScramjetClient>;
+    ctors: Record<string, Function[]>;
+    sourcemaps: SourceMaps;
+    constructor(ownerclient: ScramjetClient);
+    registerClient(client: ScramjetClient, global: Self): void;
+    instanceof(obj: any, name: string): boolean;
+}

package/dist/types/fetch/index.d.ts

@@ -0,0 +1,80 @@
+import { BareCompatibleClient, BareResponse, ProxyTransport, RawHeaders, BareRequestInit } from "@mercuryworkshop/proxy-transports";
+import { type URLMeta } from "../shared/rewriters/url";
+import { ScramjetHeaders } from "../shared/headers";
+import { ScramjetContext } from "../shared";
+import DomHandler from "domhandler";
+export interface ScramjetFetchRequest {
+    rawUrl: URL;
+    destination: RequestDestination;
+    mode: RequestMode;
+    referrer: string;
+    method: string;
+    body: BodyType | null;
+    cache: RequestCache;
+    initialHeaders: ScramjetHeaders;
+    rawClientUrl?: URL;
+}
+export interface ScramjetFetchParsed {
+    url: URL;
+    clientUrl?: URL;
+    meta: URLMeta;
+    scriptType: "module" | "regular";
+}
+export interface ScramjetFetchResponse {
+    body: BodyType;
+    headers: ScramjetHeaders;
+    status: number;
+    statusText: string;
+}
+export type FetchHandlerInit = {
+    transport: ProxyTransport;
+    context: ScramjetContext;
+    crossOriginIsolated?: boolean;
+    sendSetCookie: (url: URL, cookie: string) => Promise<void>;
+    fetchDataUrl(dataUrl: string): Promise<BareResponse>;
+    fetchBlobUrl(blobUrl: string): Promise<BareResponse>;
+};
+export declare class ScramjetFetchHandler extends EventTarget {
+    client: BareCompatibleClient;
+    crossOriginIsolated: boolean;
+    context: ScramjetContext;
+    fetchDataUrl: (dataUrl: string) => Promise<Response>;
+    fetchBlobUrl: (blobUrl: string) => Promise<Response>;
+    sendSetCookie: (url: URL, cookie: string) => Promise<void>;
+    constructor(init: FetchHandlerInit);
+    handleFetch(request: ScramjetFetchRequest): Promise<ScramjetFetchResponse>;
+}
+export declare function parseRequest(request: ScramjetFetchRequest, handler: ScramjetFetchHandler): ScramjetFetchParsed;
+export declare function rewriteHeaders(handler: ScramjetFetchHandler, request: ScramjetFetchRequest, parsed: ScramjetFetchParsed, rawHeaders: RawHeaders): Promise<ScramjetHeaders>;
+type BodyType = string | ArrayBuffer | Blob | ReadableStream<any>;
+export declare class ScramjetHTMLPreRewriteEvent extends Event {
+    handler: DomHandler;
+    context: ScramjetFetchRequest;
+    parsed: ScramjetFetchParsed;
+    constructor(handler: DomHandler, context: ScramjetFetchRequest, parsed: ScramjetFetchParsed);
+}
+export declare class ScramjetHTMLPostRewriteEvent extends Event {
+    handler: DomHandler;
+    context: ScramjetFetchRequest;
+    parsed: ScramjetFetchParsed;
+    constructor(handler: DomHandler, context: ScramjetFetchRequest, parsed: ScramjetFetchParsed);
+}
+export declare class ScramjetResponseEvent extends Event {
+    context: ScramjetFetchRequest;
+    parsed: ScramjetFetchParsed;
+    response: ScramjetFetchResponse;
+    _response?: ScramjetFetchResponse | Promise<ScramjetFetchResponse>;
+    constructor(context: ScramjetFetchRequest, parsed: ScramjetFetchParsed, response: ScramjetFetchResponse);
+    respondWith(response: ScramjetFetchResponse | Promise<ScramjetFetchResponse>): void;
+}
+export declare class ScramjetRequestEvent extends Event {
+    context: ScramjetFetchRequest;
+    url: URL;
+    parsed: ScramjetFetchParsed;
+    init: BareRequestInit;
+    client: BareCompatibleClient;
+    _response?: BareResponse | Promise<BareResponse> | Response | Promise<Response>;
+    constructor(context: ScramjetFetchRequest, url: URL, parsed: ScramjetFetchParsed, init: BareRequestInit, client: BareCompatibleClient);
+    respondWith(response: BareResponse | Promise<BareResponse>): void;
+}
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,9 @@
+import "./global.d";
+import { ScramjetConfig } from "./types";
+export * from "./client";
+export * from "./shared";
+export * from "./symbols";
+export * from "./types";
+export * from "./fetch";
+export declare const defaultConfig: ScramjetConfig;
+export declare const defaultConfigDev: ScramjetConfig;

package/dist/types/shared/cookie.d.ts

@@ -0,0 +1,18 @@
+export type Cookie = {
+    name: string;
+    value: string;
+    path?: string;
+    expires?: string;
+    maxAge?: number;
+    domain?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: "strict" | "lax" | "none";
+};
+export declare class CookieJar {
+    private cookies;
+    setCookies(cookies: string[], url: URL): void;
+    getCookies(url: URL, fromJs: boolean): string;
+    load(cookies: string): null;
+    dump(): string;
+}

package/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/dist/types/shared/htmlRules.d.ts

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

package/dist/types/shared/index.d.ts

@@ -0,0 +1,23 @@
+import { ScramjetConfig, ScramjetFlags, ScramjetVersionInfo } from "../types";
+import DomHandler, { Element } from "domhandler";
+import { URLMeta } from "./rewriters/url";
+import { CookieJar } from "./cookie";
+export * from "./cookie";
+export * from "./headers";
+export * from "./htmlRules";
+export * from "./rewriters";
+export * from "./security";
+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, script: (src: string) => Element): Element[];
+    getWorkerInjectScripts?(meta: URLMeta, type: "module" | "regular", script: (src: string) => string): string;
+};
+export type ScramjetContext = {
+    config: ScramjetConfig;
+    prefix: URL;
+    interface: ScramjetInterface;
+    cookieJar: CookieJar;
+};
+export declare const versionInfo: ScramjetVersionInfo;

package/dist/types/shared/rewriters/css.d.ts

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

package/dist/types/shared/rewriters/html.d.ts

@@ -0,0 +1,6 @@
+import { DomHandler } from "domhandler";
+import { URLMeta } from "./url";
+import { ScramjetContext } from "..";
+export declare function rewriteHtml(html: string, context: ScramjetContext, meta: URLMeta, fromTop?: boolean, preRewrite?: (handler: DomHandler) => void, postRewrite?: (handler: DomHandler) => void): string;
+export declare function unrewriteHtml(html: string): string;
+export declare function rewriteSrcset(srcset: string, context: ScramjetContext, meta: URLMeta): string;

package/dist/types/shared/rewriters/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./css";
+export * from "./html";
+export * from "./js";
+export * from "./url";
+export * from "./worker";
+export * from "./wasm";

package/dist/types/shared/rewriters/js.d.ts

@@ -0,0 +1,11 @@
+import { ScramjetContext } from "..";
+import { URLMeta } from "./url";
+type RewriterResult = {
+    js: string | Uint8Array;
+    map: Uint8Array | null;
+    tag: string;
+    errors: string[];
+};
+export declare function rewriteJsInner(js: string | Uint8Array, url: string | null, context: ScramjetContext, meta: URLMeta, module?: boolean): RewriterResult;
+export declare function rewriteJs(js: string | Uint8Array, url: string | null, context: ScramjetContext, meta: URLMeta, module?: boolean): string | Uint8Array;
+export {};

package/dist/types/shared/rewriters/url.d.ts

@@ -0,0 +1,11 @@
+import { ScramjetContext } from "..";
+export type URLMeta = {
+    origin: URL;
+    base: URL;
+    topFrameName?: string;
+    parentFrameName?: string;
+};
+export declare function rewriteBlob(url: string, context: ScramjetContext, meta: URLMeta): string;
+export declare function unrewriteBlob(url: string, context: ScramjetContext, meta: URLMeta): string;
+export declare function rewriteUrl(url: string | URL, context: ScramjetContext, meta: URLMeta): string;
+export declare function unrewriteUrl(url: string | URL, context: ScramjetContext): string;

package/dist/types/shared/rewriters/wasm.d.ts

@@ -0,0 +1,8 @@
+import { Rewriter } from "../../../rewriter/wasm/out/wasm.js";
+import type { JsRewriterOutput } from "../../../rewriter/wasm/out/wasm.js";
+import { ScramjetContext } from "..";
+export type { JsRewriterOutput, Rewriter };
+import { URLMeta } from "./url";
+export declare function setWasm(u8: Uint8Array | ArrayBuffer): void;
+export declare const textDecoder: TextDecoder;
+export declare function getRewriter(context: ScramjetContext, meta: URLMeta): [Rewriter, () => void];

package/dist/types/shared/rewriters/worker.d.ts

@@ -0,0 +1,3 @@
+import { ScramjetContext } from "..";
+import { URLMeta } from "./url";
+export declare function rewriteWorkers(context: ScramjetContext, js: string | Uint8Array, type: "module" | "regular", url: string, meta: URLMeta): string;

package/dist/types/shared/security/index.d.ts

@@ -0,0 +1 @@
+export * from "./siteTests";

package/dist/types/shared/security/siteTests.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/symbols.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview
+ * See `types.ts` for context on these symbols.
+ */
+export declare const SCRAMJETCLIENTNAME = "scramjet client global";
+export declare const SCRAMJETCLIENT: unique symbol;
+export declare const SCRAMJETFRAME: unique symbol;

package/dist/types/types.d.ts

@@ -0,0 +1,114 @@
+import { ScramjetClient } from "./client/index";
+import { SCRAMJETCLIENT } from "./symbols";
+import { DBSchema } from "idb";
+/**
+ * Version information for the current Scramjet build.
+ * Contains both the semantic version string and the git commit hash for build identification.
+ */
+export interface ScramjetVersionInfo {
+    /** The semantic version */
+    version: string;
+    /** The git commit hash that this build was created from */
+    build: string;
+    /** The date of the build */
+    date: string;
+}
+/**
+ * Scramjet Feature Flags, configured at build time
+ */
+export type ScramjetFlags = {
+    syncxhr: boolean;
+    strictRewrites: boolean;
+    rewriterLogs: boolean;
+    captureErrors: boolean;
+    cleanErrors: boolean;
+    scramitize: boolean;
+    sourcemaps: boolean;
+    destructureRewrites: boolean;
+    allowInvalidJs: boolean;
+    allowFailedIntercepts: boolean;
+    debugTrampolines: boolean;
+};
+export interface ScramjetConfig {
+    globals: {
+        wrapfn: string;
+        wrappropertybase: string;
+        wrappropertyfn: string;
+        cleanrestfn: string;
+        importfn: string;
+        rewritefn: string;
+        metafn: string;
+        wrappostmessagefn: string;
+        pushsourcemapfn: string;
+        trysetfn: string;
+        templocid: string;
+        tempunusedid: string;
+    };
+    maskedfiles: string[];
+    flags: ScramjetFlags;
+    siteFlags: Record<string, Partial<ScramjetFlags>>;
+}
+/**
+ * The config for Scramjet initialization.
+ */
+export interface ScramjetInitConfig extends Omit<ScramjetConfig, "codec" | "flags"> {
+    flags: Partial<ScramjetFlags>;
+    codec: {
+        encode: (url: string) => string;
+        decode: (url: string) => string;
+    };
+}
+declare global {
+    interface Window {
+        WASM: string;
+        REAL_WASM: Uint8Array;
+        /**
+         * The scramjet client belonging to a window.
+         */
+        [SCRAMJETCLIENT]: ScramjetClient;
+    }
+    interface HTMLDocument {
+        /**
+         * Should be the same as window.
+         */
+        [SCRAMJETCLIENT]: ScramjetClient;
+    }
+    interface HTMLIFrameElement {
+    }
+}
+export type SiteDirective = "same-origin" | "same-site" | "cross-site" | "none";
+export interface RedirectTracker {
+    originalReferrer: string;
+    mostRestrictiveSite: SiteDirective;
+    referrerPolicy: string;
+    chainStarted: number;
+}
+export interface ReferrerPolicyData {
+    policy: string;
+    referrer: string;
+}
+export interface ScramjetDB extends DBSchema {
+    config: {
+        key: string;
+        value: ScramjetConfig;
+    };
+    cookies: {
+        key: string;
+        value: any;
+    };
+    redirectTrackers: {
+        key: string;
+        value: RedirectTracker;
+    };
+    referrerPolicies: {
+        key: string;
+        value: ReferrerPolicyData;
+    };
+    publicSuffixList: {
+        key: string;
+        value: {
+            data: string[];
+            expiry: number;
+        };
+    };
+}

package/lib/index.d.ts

@@ -1,3 +1,8 @@
+/**
+ * @fileoverview
+ * Scramjet path export for routing functionality
+ */
+
 declare const scramjetPath: string;
 
 export { scramjetPath };