@mercuryworkshop/proxy-bootstrap 0.0.1

package/dist/.downloads/scramjet/package/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/dist/.downloads/scramjet/package/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/dist/.downloads/scramjet/package/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;

package/dist/.downloads/scramjet/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/.downloads/scramjet/package/dist/types/shared/rewriters/js.d.ts

@@ -0,0 +1,11 @@
+import { ScramjetContext } from "../../shared";
+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, isModule?: boolean): RewriterResult;
+export declare function rewriteJs(js: string | Uint8Array, url: string | null, context: ScramjetContext, meta: URLMeta, isModule?: boolean): string | Uint8Array;
+export {};

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

@@ -0,0 +1,25 @@
+import { ScramjetContext } from "../../shared";
+import { _URL } from "../snapshot";
+export type NavigationType = "user" | "link" | "location";
+export type RewriteUrlOptions = {
+    referrerPolicy?: string;
+    isModule?: boolean;
+    navigateType?: NavigationType;
+    topFrame?: string;
+    parentFrame?: string;
+    isIframe?: string;
+    mode?: string;
+    credentials?: string;
+    destination?: RequestDestination;
+};
+export type URLMeta = {
+    origin: _URL;
+    base: _URL;
+    topFrameName?: string;
+    parentFrameName?: string;
+    referrerPolicy?: 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, options?: RewriteUrlOptions): string;
+export declare function unrewriteUrl(url: string | URL, context: ScramjetContext): string;

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

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

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

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

package/dist/.downloads/scramjet/package/dist/types/shared/set-cookie-parser.d.ts

@@ -0,0 +1,20 @@
+type ParsedCookie = {
+    name: string;
+    value: string;
+    expires?: Date;
+    maxAge?: number;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: string;
+    partitioned?: boolean;
+    [key: string]: unknown;
+};
+declare function parseString(setCookieValue: string): ParsedCookie | null;
+declare function parseNameValuePair(nameValuePairStr: string): {
+    name: string;
+    value: string;
+} | null;
+declare function parse(input: string | undefined): ParsedCookie[];
+declare function splitCookiesString(cookiesString: unknown): string[];
+export default parse;
+export { parse, parseNameValuePair, parseString, splitCookiesString };

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

@@ -0,0 +1,236 @@
+export declare const String: StringConstructor;
+export declare const String_fromCodePoint: (...codePoints: number[]) => string;
+export declare const String_fromCharCode: (...codes: number[]) => string;
+export declare const Number: NumberConstructor;
+export declare const Number_parseInt: (string: string, radix?: number) => number;
+export declare const Object_keys: {
+    (o: object): string[];
+    (o: {}): string[];
+};
+export declare const Object_values: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): T[];
+    (o: {}): any[];
+};
+export declare const Object_entries: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): [string, T][];
+    (o: {}): [string, any][];
+};
+export declare const Object_hasOwn: (o: object, v: PropertyKey) => boolean;
+export declare const Object_getOwnPropertyNames: (o: any) => string[];
+export declare const Object_getOwnPropertyDescriptor: (o: any, p: PropertyKey) => PropertyDescriptor | undefined;
+export declare const Object_getOwnPropertyDescriptors: <T>(o: T) => { [P in keyof T]: TypedPropertyDescriptor<T[P]>; } & {
+    [x: string]: PropertyDescriptor;
+};
+export declare const Object_getOwnPropertySymbols: (o: any) => symbol[];
+export declare const Object_defineProperty: <T>(o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType<any>) => T;
+export declare const Object_defineProperties: <T>(o: T, properties: PropertyDescriptorMap & ThisType<any>) => T;
+export declare const Object_setPrototypeOf: (o: any, proto: object | null) => any;
+export declare const Reflect_get: typeof Reflect.get;
+export declare const Reflect_set: typeof Reflect.set;
+export declare const Reflect_has: typeof Reflect.has;
+export declare const Reflect_ownKeys: typeof Reflect.ownKeys;
+export declare const Reflect_construct: typeof Reflect.construct;
+export declare const Reflect_apply: typeof Reflect.apply;
+export declare const Array_from: {
+    <T>(arrayLike: ArrayLike<T>): T[];
+    <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+    <T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+    <T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+};
+export declare const Array_isArray: (arg: any) => arg is any[];
+export declare const Array_of: <T>(...items: T[]) => T[];
+export declare const JSON_parse: (text: string, reviver?: (this: any, key: string, value: any) => any) => any;
+export declare const JSON_stringify: {
+    (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+    (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+};
+export declare const TextEncoder_encode: any;
+export declare const TextDecoder_decode: any;
+export declare const Performance_now: any;
+export declare const btoa: typeof globalThis.btoa;
+export declare const atob: typeof globalThis.atob;
+export declare const URL_createObjectURL: any;
+export declare const URL_revokeObjectURL: any;
+export declare const Error: ErrorConstructor;
+export declare const Math_random: () => number;
+export declare const Math_min: (...values: number[]) => number;
+export declare const Promise_all: any;
+export declare const Promise_race: any;
+export declare const Promise_resolve: any;
+export declare const Promise_reject: any;
+export declare const Promise_allSettled: any;
+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"> & {
+    new (...args: Args): WrappedInstance<Instance>;
+    prototype: WrappedInstance<Instance>;
+    readonly [WrappedBrand]: T;
+} : T & {
+    readonly [WrappedBrand]: T;
+};
+export declare const _URL: Omit<{
+    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;
+    };
+};
+export type _URL = Wrapped<URL>;
+export declare const _Headers: Omit<{
+    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;
+    };
+};
+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 type _Date = Wrapped<Date>;
+export declare const _URLSearchParams: Omit<{
+    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;
+    };
+};
+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 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 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 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 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 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 type _Uint8Array = Wrapped<Uint8Array>;
+export declare const _TextDecoder: Omit<{
+    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;
+    };
+};
+export type _TextDecoder = Wrapped<TextDecoder>;
+export declare const _TextEncoder: Omit<{
+    new (): TextEncoder;
+    prototype: TextEncoder;
+}, "prototype"> & {
+    new (): TextEncoder & {
+        readonly [WrappedBrand]: TextEncoder;
+    };
+    prototype: TextEncoder & {
+        readonly [WrappedBrand]: TextEncoder;
+    };
+    readonly [WrappedBrand]: {
+        new (): TextEncoder;
+        prototype: TextEncoder;
+    };
+};
+export type _TextEncoder = Wrapped<TextEncoder>;
+export declare function makeWrap<T extends object>(source: T): Wrapped<T>;
+export {};

package/dist/.downloads/scramjet/package/dist/types/shared/sniffEncoding.d.ts

@@ -0,0 +1,65 @@
+/**
+ * WHATWG Encoding Sniffing Algorithm
+ *
+ * Implements the encoding sniffing algorithm from the HTML spec:
+ * https://html.spec.whatwg.org/multipage/parsing.html#determining-the-character-encoding
+ *
+ * And the "algorithm for extracting a character encoding from a meta element":
+ * https://html.spec.whatwg.org/multipage/urls-and-fetching.html#algorithm-for-extracting-a-character-encoding-from-a-meta-element
+ *
+ * And "get an encoding" from the Encoding spec:
+ * https://encoding.spec.whatwg.org/#concept-encoding-get
+ */
+/**
+ * https://encoding.spec.whatwg.org/#concept-encoding-get
+ *
+ * "To get an encoding from a string label":
+ * 1. Remove any leading and trailing ASCII whitespace from label.
+ * 2. If label is an ASCII case-insensitive match for any of the labels listed
+ *    in the table, return the corresponding encoding; otherwise return failure.
+ */
+export declare function getEncoding(label: string): string | null;
+/**
+ * https://html.spec.whatwg.org/multipage/urls-and-fetching.html#algorithm-for-extracting-a-character-encoding-from-a-meta-element
+ *
+ * The algorithm for extracting a character encoding from a `meta` element,
+ * given a string s.
+ */
+export declare function extractCharsetFromMeta(s: string): string | null;
+/**
+ * https://html.spec.whatwg.org/multipage/parsing.html#prescan-a-byte-stream-to-determine-its-encoding
+ *
+ * Prescan the first `limit` bytes of a byte stream to determine its encoding.
+ * Returns an encoding name or null if none found.
+ */
+export declare function prescanByteStream(bytes: Uint8Array, limit?: number): string | null;
+/**
+ * https://encoding.spec.whatwg.org/#bom-sniff
+ *
+ * BOM sniff: check the first 2-3 bytes for a byte order mark.
+ */
+export declare function bomSniff(bytes: Uint8Array): string | null;
+/**
+ * Extract the charset parameter from a Content-Type header value.
+ *
+ * This parses the Content-Type more carefully than a naive split — it handles
+ * quoted values and multiple parameters.
+ *
+ * This follows what MIME Sniffing / HTTP specs say: find `charset=` parameter.
+ */
+export declare function extractCharsetFromContentType(contentType: string): string | null;
+/**
+ * Determine the character encoding of an HTML document's byte stream.
+ *
+ * Implements a simplified version of the WHATWG encoding sniffing algorithm
+ * for use in a service worker / proxy context:
+ *
+ * 1. BOM sniffing (certain)
+ * 2. Transport layer: Content-Type header charset parameter (certain)
+ * 3. Prescan byte stream: look for <meta charset> or
+ *    <meta http-equiv="content-type" content="...charset=..."> in first 1024 bytes (tentative)
+ * 4. Default to UTF-8
+ *
+ * Returns an encoding name suitable for use with TextDecoder.
+ */
+export declare function sniffEncoding(bytes: Uint8Array, contentTypeHeader: string | null): string;

package/dist/.downloads/scramjet/package/dist/types/shared/util.d.ts

@@ -0,0 +1,2 @@
+export declare const bytesToBase64: (bytes: Uint8Array) => string;
+export declare function base64Encode(text: string): string;

package/dist/.downloads/scramjet/package/dist/types/symbols.d.ts

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

package/dist/.downloads/scramjet/package/dist/types/types.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 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;
+    disableComputedWrap: boolean;
+    rewriterLogs: boolean;
+    captureErrors: boolean;
+    cleanErrors: boolean;
+    scramitize: boolean;
+    sourcemaps: boolean;
+    destructureRewrites: boolean;
+    allowInvalidJs: boolean;
+    allowFailedIntercepts: boolean;
+    debugTrampolines: boolean;
+    debugSourceURL: boolean;
+    encapsulateWorkers: 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;
+    }
+    interface HTMLDocument {
+    }
+}
+export type AnyFunction = Function;

package/dist/.downloads/scramjet/package/lib/index.cjs

@@ -0,0 +1,7 @@
+"use strict";
+
+const { resolve } = require("node:path");
+
+const scramjetPath = resolve(__dirname, "..", "dist");
+
+exports.scramjetPath = scramjetPath;

package/dist/.downloads/scramjet/package/lib/index.d.ts

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

package/dist/.downloads/scramjet/package/lib/types.d.ts

@@ -0,0 +1,20 @@
+import * as controller from "../dist/types/controller/index.ts";
+import { ScramjetConfig } from "../dist/types/types.ts";
+import * as worker from "../dist/types/worker";
+import * as shared from "../dist/types/shared";
+import * as client from "../dist/types/shared";
+
+declare global {
+	function $scramjetLoadController(): typeof controller;
+	function $scramjetLoadWorker(): typeof worker;
+	function $scramjetLoadClient(config: ScramjetConfig): typeof client;
+	function $scramjetLoadShared(): typeof shared;
+	/// load any file from scramjet source
+	function $scramjetRequire(path: string): any;
+	var $scramjetVersion: {
+		build: string;
+		version: string;
+	};
+}
+
+export type * from "../dist/types/index";

package/dist/.downloads/scramjet/package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@mercuryworkshop/scramjet",
+  "version": "2.0.5-alpha",
+  "description": "An experimental web proxy that aims to be the successor to Ultraviolet",
+  "type": "module",
+  "types": "./dist/types/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MercuryWorkshop/scramjet"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/scramjet.mjs"
+    },
+    "./path": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.cjs"
+    },
+    "./bundled": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/scramjet_bundled.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "lib"
+  ],
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "ava": {
+    "files": [
+      "tests/ci/**/*.js"
+    ],
+    "verbose": true
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.35.0",
+    "@estruyf/github-actions-reporter": "^1.10.0",
+    "@fastify/static": "^8.2.0",
+    "@mercuryworkshop/wisp-js": "^0.4.0",
+    "@nebula-services/bare-server-node": "^2.0.4",
+    "@types/eslint": "^9.6.1",
+    "@types/estree": "^1.0.8",
+    "@types/node": "^24.3.1",
+    "@types/serviceworker": "^0.0.160",
+    "@typescript-eslint/eslint-plugin": "8.57.3-alpha.3",
+    "@typescript-eslint/parser": "8.57.3-alpha.3",
+    "actionlint": "^2.0.6",
+    "ava": "^6.4.1",
+    "dotenv": "^17.2.2",
+    "eslint": "^10.1.0",
+    "fastify": "^5.6.0",
+    "glob": "^11.0.3",
+    "prettier": "^3.6.2",
+    "remark": "^15.0.1",
+    "remark-cli": "^12.0.1",
+    "remark-frontmatter": "^5.0.0",
+    "remark-mdx": "^3.1.1",
+    "remark-stringify": "^11.0.0",
+    "ts-checker-rspack-plugin": "^1.1.5",
+    "tsc-alias": "^1.8.16",
+    "tslib": "^2.8.1",
+    "typescript": "^5.9.2"
+  },
+  "dependencies": {
+    "@mercuryworkshop/proxy-transports": "1.0.2",
+    "dom-serializer": "^2.0.0",
+    "domhandler": "^5.0.3",
+    "domutils": "^3.2.2",
+    "htmlparser2": "^12.0.0",
+    "idb": "^8.0.3",
+    "parse-domain": "^8.2.2"
+  },
+  "scripts": {
+    "build": "cd ../.. && rspack build --mode production",
+    "rewriter:build": "cd rewriter/wasm/ && bash build.sh && cd ../../",
+    "dev": "node server.js",
+    "dev:debug": "DEBUG=1 node server.js",
+    "pub": "npm publish --no-git-checks --access public",
+    "format": "prettier --write .",
+    "format:docs": "remark \"docs/**/*.{md,mdx}\" --output",
+    "lint": "eslint ./src/",
+    "lint:fix": "eslint ./src/ --fix",
+    "lint:workflows": "actionlint .github/workflows/*.yml",
+    "lint:all": "npm run lint && npm run lint:workflows",
+    "test": "npm run test:package",
+    "test:package": "ava tests/ci/packageValidation.js",
+    "preinstall": "npx only-allow pnpm"
+  }
+}