@mercuryworkshop/scramjet 2.0.5-alpha → 2.0.67-alpha

package/dist/types/Tap.d.ts

@@ -3,11 +3,16 @@ type Description = {
     props?: object;
 };
 type Callback<T extends Description> = (context: T["context"], props: T["props"]) => void | Promise<void>;
-type Sorter = (other: Plugin) => number;
+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;
-    sorter: Sorter;
+    order: TapOrder;
 };
 type InternalHookDescription = {
     tap: TapInternal;
@@ -21,12 +26,14 @@ export type TapInstance<T extends Record<string, Description>> = {
 };
 export declare class Plugin {
     name: string;
-    constructor(name: string);
-    tap<T extends Description>(hook: T, callback: Callback<T>, sorter?: Sorter): void;
+    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[]>;
-    static tap<T extends Description>(hook: T, callback: Callback<T>, plugin: Plugin, sorter: Sorter): void;
+    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/dist/types/client/client.d.ts

@@ -1,17 +1,16 @@
 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 { LifecycleHooks } from "@client/events";
+import { RewriteUrlOptions, type URLMeta } from "@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";
+import { ScramjetConfig } from "@/types";
+import { type CookieSyncEntry, type CookieSyncOptions, TrackedHistoryState } from "@/fetch";
+import { AnyFunction } from "@/types";
+import { _URL } from "@/shared/snapshot";
 export type ScramjetClientInit = {
     context: ScramjetContext;
     transport: ProxyTransport;
     sendSetCookie: (cookies: CookieSyncEntry[], options?: CookieSyncOptions) => Promise<void>;
-    shouldPassthroughWebsocket?: (url: string | URL) => boolean;
     shouldBlockMessageEvent?: (ev: MessageEvent) => boolean;
     hookSubcontext: (self: Self, frame?: HTMLIFrameElement) => ScramjetClient;
     initHeaders: RawHeaders;
@@ -85,11 +84,12 @@ export declare class ScramjetClient {
     context: ScramjetContext;
     initHeaders: ScramjetHeaders;
     history: TrackedHistoryState[];
+    private flagCache;
     hooks: {
         rewriter: {
-            html: import("../Tap").TapInstance<HtmlRewriterHooks>;
+            html: import("@/Tap").TapInstance<HtmlRewriterHooks>;
         };
-        lifecycle: import("../Tap").TapInstance<LifecycleHooks>;
+        lifecycle: import("@/Tap").TapInstance<LifecycleHooks>;
     };
     constructor(global: GlobalThis, init: ScramjetClientInit);
     /** Apply document injection init when a client was already installed (e.g. early contentWindow). */

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

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

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

@@ -1,3 +1,3 @@
-import { ScramjetClient } from "../index";
+import { ScramjetClient } from "@client/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

@@ -1,4 +1,4 @@
-import { ScramjetClient } from "../index";
+import { ScramjetClient } from "@client/index";
 declare enum RewriteType {
     Insert = 0,
     Replace = 1

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

@@ -1,4 +1,4 @@
-import { ScramjetClient } from "../index";
+import { ScramjetClient } from "@client/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/dist/types/client/singletonbox.d.ts

@@ -1,4 +1,4 @@
-import { IncrementalHtmlRewriter } from "../shared";
+import { IncrementalHtmlRewriter } from "@/shared";
 import { ScramjetClient } from "./client";
 import { SourceMaps } from "./shared/sourcemaps";
 export declare class SingletonBox {

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

@@ -1,6 +1,6 @@
 import { BareResponse } from "@mercuryworkshop/proxy-transports";
 import { ScramjetFetchHandler, ScramjetFetchParsed, ScramjetFetchRequest, ScramjetFetchResponse } from ".";
-import { ScramjetHeaders } from "../shared";
+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. */

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

@@ -1,4 +1,4 @@
-import { ScramjetHeaders } from "../shared";
+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>;

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

@@ -12,6 +12,7 @@ export declare const QP: {
     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>>;

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

@@ -1,4 +1,4 @@
-import { ScramjetHeaders } from "../shared";
+import { ScramjetHeaders } from "@/shared";
 import { BareResponse } from "@mercuryworkshop/proxy-transports";
 import { ScramjetFetchParsed } from ".";
 export declare function normalizeContentType(parsed: ScramjetFetchParsed, headers: ScramjetHeaders): void;

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

@@ -1,6 +1,6 @@
-import { URLMeta } from "./rewriters/url";
-import { ScramjetContext } from "../shared";
+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) => string | null;
+    fn: (value: string, context: ScramjetContext, meta: URLMeta, attrs?: Record<string, string | undefined>) => string | null;
 }[];

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

@@ -1,9 +1,9 @@
-import { ScramjetConfig, ScramjetFlags, ScramjetVersionInfo } from "../types";
+import { ScramjetConfig, ScramjetFlags, ScramjetVersionInfo } from "@/types";
 import DomHandler, { Element } from "domhandler";
-import { URLMeta } from "./rewriters/url";
+import { URLMeta } from "@rewriters/url";
 import { CookieJar } from "./cookie";
-import { TapInstance } from "../Tap";
-import { HtmlContext } from "../shared/rewriters/html";
+import { TapInstance } from "@/Tap";
+import { HtmlContext } from "@/shared/rewriters/html";
 export * from "./cookie";
 export * from "./headers";
 export * from "./htmlRules";

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

@@ -32,6 +32,14 @@ export declare function isJavascriptMimeType(mime: string | ParsedMimeType): boo
  * JavaScript MIME type essence strings (not necessarily a full parsed MIME type).
  */
 export declare function isJavascriptMimeTypeEssenceMatch(s: string): boolean;
+/**
+ * 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.

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

@@ -1,4 +1,4 @@
-import { URLMeta } from "./url";
-import { ScramjetContext } from "../../shared";
+import { URLMeta } from "@rewriters/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/dist/types/shared/rewriters/html.d.ts

@@ -1,7 +1,7 @@
-import { URLMeta } from "./url";
-import { ScramjetContext } from "../../shared";
+import { URLMeta } from "@rewriters/url";
+import { ScramjetContext } from "@/shared";
 import { RawHeaders } from "@mercuryworkshop/proxy-transports";
-import { TrackedHistoryState } from "../../fetch";
+import { TrackedHistoryState } from "@/fetch";
 export type ForeignContext = "svg" | "math" | "html";
 export type HtmlContext = {
     loadScripts: boolean;

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

@@ -1,5 +1,5 @@
-import { ScramjetContext } from "../../shared";
-import { URLMeta } from "./url";
+import { ScramjetContext } from "@/shared";
+import { URLMeta } from "@rewriters/url";
 type RewriterResult = {
     js: string | Uint8Array;
     map: Uint8Array | null;

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

@@ -1,4 +1,4 @@
-import { ScramjetContext } from "../../shared";
+import { ScramjetContext } from "@/shared";
 import { _URL } from "../snapshot";
 export type NavigationType = "user" | "link" | "location";
 export type RewriteUrlOptions = {

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

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

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

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

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

@@ -67,170 +67,119 @@ export declare const Promise_any: any;
 export declare const Symbol_for: (key: string) => symbol;
 declare const WrappedBrand: unique symbol;
 type WrappedInstance<T> = T extends object ? Wrapped<T> : T;
-export type Wrapped<T> = T extends abstract new (...args: infer Args) => infer Instance ? Omit<T, "prototype"> & {
+type ConstructorPrototype<T> = T extends {
+    prototype: infer P;
+} ? P : never;
+type InstantiatePrototype<P, Params extends unknown[]> = Params extends [
+    infer A,
+    infer B
+] ? P extends WeakMap<any, any> ? WeakMap<A & WeakKey, B> : P extends Map<any, any> ? Map<A, B> : P : Params extends [infer A] ? P extends WeakSet<any> ? WeakSet<A & object> : P extends Set<any> ? Set<A> : P : P;
+type WrappedCtorStatics<T> = Pick<T, Exclude<keyof T, "prototype">>;
+type WrappedCtor<T, Params extends unknown[], New extends abstract new (...a: any) => any> = New & WrappedCtorStatics<T> & {
+    prototype: Wrapped<InstantiatePrototype<ConstructorPrototype<T>, Params>>;
+    readonly [WrappedBrand]: T;
+};
+type WrappedConstructor<T> = ConstructorPrototype<T> extends Map<any, any> ? T extends {
+    new <K, V>(...args: infer Args): any;
+} ? WrappedCtor<T, [
+    unknown,
+    unknown
+], new <K, V>(...args: Args) => Wrapped<Map<K, V>>> : never : ConstructorPrototype<T> extends WeakMap<any, any> ? T extends {
+    new <K extends WeakKey, V>(...args: infer Args): any;
+} ? WrappedCtor<T, [
+    WeakKey,
+    unknown
+], new <K extends WeakKey, V>(...args: Args) => Wrapped<WeakMap<K, V>>> : never : ConstructorPrototype<T> extends WeakSet<any> ? T extends {
+    new <U extends object>(...args: infer Args): any;
+} ? WrappedCtor<T, [
+    object
+], new <U extends object>(...args: Args) => Wrapped<WeakSet<U>>> : never : ConstructorPrototype<T> extends Set<any> ? T extends {
+    new <U>(...args: infer Args): any;
+} ? WrappedCtor<T, [
+    unknown
+], new <U>(...args: Args) => Wrapped<Set<U>>> : never : T extends {
+    new <K, V>(...args: infer Args): any;
+} ? WrappedCtor<T, [
+    unknown,
+    unknown
+], new <K, V>(...args: Args) => Wrapped<InstantiatePrototype<ConstructorPrototype<T>, [K, V]>>> : T extends {
+    new <U>(...args: infer Args): any;
+} ? WrappedCtor<T, [
+    unknown
+], new <U>(...args: Args) => Wrapped<InstantiatePrototype<ConstructorPrototype<T>, [U]>>> : T extends abstract new (...args: infer Args) => infer Instance ? Omit<T, "prototype"> & {
     new (...args: Args): WrappedInstance<Instance>;
     prototype: WrappedInstance<Instance>;
     readonly [WrappedBrand]: T;
-} : T & {
+} : never;
+export type Wrapped<T> = T extends abstract new (...args: any) => any ? WrappedConstructor<T> : T & {
     readonly [WrappedBrand]: T;
 };
-export declare const _URL: Omit<{
+export declare const _URL: WrappedCtor<{
     new (url: string | URL, base?: string | URL): URL;
     prototype: URL;
     canParse(url: string | URL, base?: string | URL): boolean;
     createObjectURL(obj: Blob | MediaSource): string;
     parse(url: string | URL, base?: string | URL): URL | null;
     revokeObjectURL(url: string): void;
-}, "prototype"> & {
-    new (url: string | URL, base?: string | URL): URL & {
-        readonly [WrappedBrand]: URL;
-    };
-    prototype: URL & {
-        readonly [WrappedBrand]: URL;
-    };
-    readonly [WrappedBrand]: {
-        new (url: string | URL, base?: string | URL): URL;
-        prototype: URL;
-        canParse(url: string | URL, base?: string | URL): boolean;
-        createObjectURL(obj: Blob | MediaSource): string;
-        parse(url: string | URL, base?: string | URL): URL | null;
-        revokeObjectURL(url: string): void;
-    };
-};
+}, [unknown, unknown], new <K, V>(url: string | URL, base?: string | URL) => URL & {
+    readonly [WrappedBrand]: URL;
+}>;
 export type _URL = Wrapped<URL>;
-export declare const _Headers: Omit<{
+export declare const _Headers: WrappedCtor<{
     new (init?: HeadersInit): Headers;
     prototype: Headers;
-}, "prototype"> & {
-    new (init?: HeadersInit): Headers & {
-        readonly [WrappedBrand]: Headers;
-    };
-    prototype: Headers & {
-        readonly [WrappedBrand]: Headers;
-    };
-    readonly [WrappedBrand]: {
-        new (init?: HeadersInit): Headers;
-        prototype: Headers;
-    };
-};
+}, [unknown, unknown], new <K, V>(init?: HeadersInit) => Headers & {
+    readonly [WrappedBrand]: Headers;
+}>;
 export type _Headers = Wrapped<Headers>;
-export declare const _Date: Omit<DateConstructor, "prototype"> & {
-    new (value: string | number | Date): Date & {
-        readonly [WrappedBrand]: Date;
-    };
-    prototype: Date & {
-        readonly [WrappedBrand]: Date;
-    };
-    readonly [WrappedBrand]: DateConstructor;
-};
+export declare const _Date: WrappedCtor<DateConstructor, [unknown, unknown], new <K, V>(value: string | number | Date) => Date & {
+    readonly [WrappedBrand]: Date;
+}>;
 export type _Date = Wrapped<Date>;
-export declare const _URLSearchParams: Omit<{
+export declare const _URLSearchParams: WrappedCtor<{
     new (init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
     prototype: URLSearchParams;
-}, "prototype"> & {
-    new (init?: string | Record<string, string> | string[][] | URLSearchParams): URLSearchParams & {
-        readonly [WrappedBrand]: URLSearchParams;
-    };
-    prototype: URLSearchParams & {
-        readonly [WrappedBrand]: URLSearchParams;
-    };
-    readonly [WrappedBrand]: {
-        new (init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
-        prototype: URLSearchParams;
-    };
-};
+}, [unknown, unknown], new <K, V>(init?: string | Record<string, string> | URLSearchParams | string[][]) => URLSearchParams & {
+    readonly [WrappedBrand]: URLSearchParams;
+}>;
 export type _URLSearchParams = Wrapped<URLSearchParams>;
-export declare const _RegExp: Omit<RegExpConstructor, "prototype"> & {
-    new (pattern: string | RegExp, flags?: string): RegExp & {
-        readonly [WrappedBrand]: RegExp;
-    };
-    prototype: RegExp & {
-        readonly [WrappedBrand]: RegExp;
-    };
-    readonly [WrappedBrand]: RegExpConstructor;
-};
+export declare const _RegExp: WrappedCtor<RegExpConstructor, [unknown, unknown], new <K, V>(pattern: string | RegExp, flags?: string) => RegExp & {
+    readonly [WrappedBrand]: RegExp;
+}>;
 export type _RegExp = Wrapped<RegExp>;
-export declare const _Set: Omit<SetConstructor, "prototype"> & {
-    new (iterable?: Iterable<unknown>): Set<unknown> & {
-        readonly [WrappedBrand]: Set<unknown>;
-    };
-    prototype: Set<unknown> & {
-        readonly [WrappedBrand]: Set<unknown>;
-    };
-    readonly [WrappedBrand]: SetConstructor;
-};
+export declare const _Set: WrappedCtor<SetConstructor, [object], new <U extends object>(iterable?: Iterable<unknown>) => WeakSet<U> & {
+    readonly [WrappedBrand]: WeakSet<U>;
+}>;
 export type _Set<T> = Wrapped<Set<T>>;
-export declare const _Map: Omit<MapConstructor, "prototype"> & {
-    new (iterable?: Iterable<readonly [unknown, unknown]>): Map<unknown, unknown> & {
-        readonly [WrappedBrand]: Map<unknown, unknown>;
-    };
-    prototype: Map<unknown, unknown> & {
-        readonly [WrappedBrand]: Map<unknown, unknown>;
-    };
-    readonly [WrappedBrand]: MapConstructor;
-};
+export declare const _Map: WrappedCtor<MapConstructor, [unknown, unknown], new <K, V>(iterable?: Iterable<readonly [unknown, unknown]>) => Map<K, V> & {
+    readonly [WrappedBrand]: Map<K, V>;
+}>;
 export type _Map<K, V> = Wrapped<Map<K, V>>;
-export declare const _WeakSet: Omit<WeakSetConstructor, "prototype"> & {
-    new (iterable: Iterable<WeakKey>): WeakSet<WeakKey> & {
-        readonly [WrappedBrand]: WeakSet<WeakKey>;
-    };
-    prototype: WeakSet<WeakKey> & {
-        readonly [WrappedBrand]: WeakSet<WeakKey>;
-    };
-    readonly [WrappedBrand]: WeakSetConstructor;
-};
+export declare const _WeakSet: WrappedCtor<WeakSetConstructor, [object], new <U extends object>(iterable: Iterable<WeakKey>) => WeakSet<U> & {
+    readonly [WrappedBrand]: WeakSet<U>;
+}>;
 export type _WeakSet<T extends object> = Wrapped<WeakSet<T>>;
-export declare const _WeakMap: Omit<WeakMapConstructor, "prototype"> & {
-    new (iterable: Iterable<readonly [WeakKey, unknown]>): WeakMap<WeakKey, unknown> & {
-        readonly [WrappedBrand]: WeakMap<WeakKey, unknown>;
-    };
-    prototype: WeakMap<WeakKey, unknown> & {
-        readonly [WrappedBrand]: WeakMap<WeakKey, unknown>;
-    };
-    readonly [WrappedBrand]: WeakMapConstructor;
-};
+export declare const _WeakMap: WrappedCtor<WeakMapConstructor, [WeakKey, unknown], new <K extends WeakKey, V>(iterable: Iterable<readonly [WeakKey, unknown]>) => WeakMap<K, V> & {
+    readonly [WrappedBrand]: WeakMap<K, V>;
+}>;
 export type _WeakMap<K extends object, V extends object> = Wrapped<WeakMap<K, V>>;
-export declare const _Uint8Array: Omit<Uint8ArrayConstructor, "prototype"> & {
-    new (): Uint8Array<ArrayBuffer> & {
-        readonly [WrappedBrand]: Uint8Array<ArrayBuffer>;
-    };
-    prototype: Uint8Array<ArrayBuffer> & {
-        readonly [WrappedBrand]: Uint8Array<ArrayBuffer>;
-    };
-    readonly [WrappedBrand]: Uint8ArrayConstructor;
-};
+export declare const _Uint8Array: WrappedCtor<Uint8ArrayConstructor, [unknown, unknown], new <K, V>() => Uint8Array<ArrayBufferLike> & {
+    readonly [WrappedBrand]: Uint8Array<ArrayBufferLike>;
+}>;
 export type _Uint8Array = Wrapped<Uint8Array>;
-export declare const _TextDecoder: Omit<{
+export declare const _TextDecoder: WrappedCtor<{
     new (label?: string, options?: TextDecoderOptions): TextDecoder;
     prototype: TextDecoder;
-}, "prototype"> & {
-    new (label?: string, options?: TextDecoderOptions): TextDecoder & {
-        readonly [WrappedBrand]: TextDecoder;
-    };
-    prototype: TextDecoder & {
-        readonly [WrappedBrand]: TextDecoder;
-    };
-    readonly [WrappedBrand]: {
-        new (label?: string, options?: TextDecoderOptions): TextDecoder;
-        prototype: TextDecoder;
-    };
-};
+}, [unknown, unknown], new <K, V>(label?: string, options?: TextDecoderOptions) => TextDecoder & {
+    readonly [WrappedBrand]: TextDecoder;
+}>;
 export type _TextDecoder = Wrapped<TextDecoder>;
-export declare const _TextEncoder: Omit<{
+export declare const _TextEncoder: WrappedCtor<{
     new (): TextEncoder;
     prototype: TextEncoder;
-}, "prototype"> & {
-    new (): TextEncoder & {
-        readonly [WrappedBrand]: TextEncoder;
-    };
-    prototype: TextEncoder & {
-        readonly [WrappedBrand]: TextEncoder;
-    };
-    readonly [WrappedBrand]: {
-        new (): TextEncoder;
-        prototype: TextEncoder;
-    };
-};
+}, [unknown, unknown], new <K, V>() => TextEncoder & {
+    readonly [WrappedBrand]: TextEncoder;
+}>;
 export type _TextEncoder = Wrapped<TextEncoder>;
 export declare function makeWrap<T extends object>(source: T): Wrapped<T>;
 export {};

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@mercuryworkshop/scramjet",
-  "version": "2.0.5-alpha",
+  "version": "2.0.67-alpha",
+  "license": "AGPL-3.0-only",
   "description": "An experimental web proxy that aims to be the successor to Ultraviolet",
   "type": "module",
   "types": "./dist/types/index.d.ts",
+  "main": "./dist/scramjet-external.mjs",
+  "module": "./dist/scramjet-external.mjs",
   "repository": {
     "type": "git",
     "url": "https://github.com/MercuryWorkshop/scramjet"
@@ -11,13 +14,17 @@
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
-      "default": "./dist/scramjet.mjs"
+      "default": "./dist/scramjet-external.mjs"
     },
     "./path": {
       "types": "./lib/index.d.ts",
       "default": "./lib/index.cjs"
     },
     "./bundled": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/scramjet.mjs"
+    },
+    "./bundled-wasm": {
       "types": "./dist/types/index.d.ts",
       "default": "./dist/scramjet_bundled.mjs"
     }
@@ -28,7 +35,6 @@
   ],
   "keywords": [],
   "author": "",
-  "license": "MIT",
   "ava": {
     "files": [
       "tests/ci/**/*.js"

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

@@ -1,4 +0,0 @@
-import { ScramjetClient } from "./index";
-export declare const UNSAFE_GLOBALS: string[];
-export declare function createGlobalProxy(client: ScramjetClient, self: typeof globalThis): typeof globalThis;
-export declare function createDocumentProxy(client: ScramjetClient, self: typeof globalThis): any;

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

@@ -1,19 +0,0 @@
-import { ProxyCtx, ScramjetClient } from "../client";
-/**
- * Maps each fast-path wrapper function back to the native function it
- * stands in for, so `Function.prototype.toString` interception
- * (sourcemaps.ts) can return the original native source string and avoid
- * leaking our wrapper's body to anti-tampering checks. Module-level so
- * it survives across module loads and is shared with sourcemaps.ts.
- */
-export declare const NATIVE_BACKING: WeakMap<AnyFunction, AnyFunction>;
-type AnyFunction = (...args: any[]) => any;
-export declare const order = 3;
-export declare const enabled: (c: ScramjetClient) => boolean;
-export default function (client: ScramjetClient, self: typeof window): void;
-/**
- * Legacy helper retained for backward compatibility with any consumer that
- * imported it. New code should rely on the IDL-driven hooks installed above.
- */
-export declare function unproxy(ctx: ProxyCtx, client: ScramjetClient): void;
-export {};

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

@@ -1,50 +0,0 @@
-/**
- * Single character proxy "kind" tag:
- *   "w" -> Window/WindowProxy   "d" -> Document
- *   "*" -> overload disagrees, probe the value at runtime
- */
-export type ProxyKind = "w" | "d" | "*";
-/**
- * Selector for a Window/Document value reachable from an operation argument.
- *   [argIdx, kind]                 -- the entire argument
- *   [argIdx, kind, ...path]        -- a property path inside a dict arg
- *                                     (e.g. options.root)
- */
-export type ArgSelector = readonly [
-    argIdx: number,
-    kind: "w" | "d",
-    ...path: string[]
-];
-/**
- * Operation/constructor table entry:
- *   [owner, member, isStatic, isCtor, argSelectors, returnKind]
- *
- * - owner is the interface/namespace name (e.g. "Document", "Window")
- * - member is the method name; "" for constructors
- * - isStatic=true patches `Owner.member`, false patches `Owner.prototype.member`
- * - isCtor=true patches the interface constructor itself
- * - returnKind=""  means no return wrapping needed
- */
-export type OpEntry = readonly [
-    owner: string,
-    member: string,
-    isStatic: boolean,
-    isCtor: boolean,
-    argSelectors: readonly ArgSelector[],
-    returnKind: ProxyKind | ""
-];
-/**
- * Attribute table entry:
- *   [owner, member, isStatic, kind, readonly]
- *
- * isStatic=true patches `Owner.member`, false patches `Owner.prototype.member`.
- */
-export type AttrEntry = readonly [
-    owner: string,
-    member: string,
-    isStatic: boolean,
-    kind: ProxyKind,
-    readonly: boolean
-];
-export declare const OPERATIONS: readonly OpEntry[];
-export declare const ATTRIBUTES: readonly AttrEntry[];