@bendover111222333444/epoxy-transport 3.0.2

package/esbuild.bundle.mjs

@@ -0,0 +1,120 @@
+import { dtsPlugin } from "esbuild-plugin-d.ts";
+import { build } from "esbuild";
+import path from 'node:path'
+import fs, { readFileSync } from 'node:fs'
+import { umdWrapper } from "esbuild-plugin-umd-wrapper";
+
+const umdWrapperOptions = {
+  libraryName: "EpoxyTransport", // default is unset
+  external: "inherit", // <= default
+  amdLoaderName: "define" // <= default
+}
+
+//for the CJS build: we take the import url and translate it into it's corresponding functions and annd that back to the file.
+const dataUrl = {
+  name: 'data-url-to-functions',
+  setup(build) {
+    build.onLoad({ filter: /\.js$/ }, (args) => {
+      const source = readFileSync(args.path, 'utf-8');
+      const transformedSource = source.replace(/import\s+(?:{[^}]*}\s+from\s+)?['"]data:application\/javascript;base64,([^'"]+)['"];\s*/g, (_, b64) => {
+        const code = Buffer.from(b64, 'base64').toString('utf-8');
+        return code;
+      })
+      return {
+        contents: transformedSource,
+        loader: 'js'
+      }
+    });
+  }
+}
+
+let wasmPlugin = {
+  name: 'wasm',
+  setup(build) {
+    // Resolve ".wasm" files to a path with a namespace
+    build.onResolve({ filter: /\.wasm$/ }, args => {
+      // If this is the import inside the stub module, import the
+      // binary itself. Put the path in the "wasm-binary" namespace
+      // to tell our binary load callback to load the binary file.
+      if (args.namespace === 'wasm-stub') {
+        return {
+          path: args.path,
+          namespace: 'wasm-binary',
+        }
+      }
+
+      // Otherwise, generate the JavaScript stub module for this
+      // ".wasm" file. Put it in the "wasm-stub" namespace to tell
+      // our stub load callback to fill it with JavaScript.
+      //
+      // Resolve relative paths to absolute paths here since this
+      // resolve callback is given "resolveDir", the directory to
+      // resolve imports against.
+      if (args.resolveDir === '') {
+        return // Ignore unresolvable paths
+      }
+      return {
+        path: path.isAbsolute(args.path) ? args.path : path.join(args.resolveDir, args.path),
+        namespace: 'wasm-stub',
+      }
+    })
+
+    // Virtual modules in the "wasm-stub" namespace are filled with
+    // the JavaScript code for compiling the WebAssembly binary. The
+    // binary itself is imported from a second virtual module.
+    build.onLoad({ filter: /.*/, namespace: 'wasm-stub' }, async (args) => ({
+      contents: `import wasm from ${JSON.stringify(args.path)}
+        export default (imports) =>
+          WebAssembly.instantiate(wasm, imports).then(
+            result => result.instance.exports)`,
+    }))
+
+    // Virtual modules in the "wasm-binary" namespace contain the
+    // actual bytes of the WebAssembly file. This uses esbuild's
+    // built-in "binary" loader instead of manually embedding the
+    // binary data inside JavaScript code ourselves.
+    build.onLoad({ filter: /.*/, namespace: 'wasm-binary' }, async (args) => ({
+      contents: await fs.promises.readFile(args.path),
+      loader: 'binary',
+    }))
+  },
+}
+let makeAllPackagesExternalPlugin = {
+  name: 'make-all-packages-external',
+  setup(build) {
+
+    // build.onResolve({ filter: /protocol/ }, args => ({ external: false }))
+    let filter = /^[^.\/]|^\.[^.\/]|^\.\.[^\/]/ // Must not start with "/" or "./" or "../"
+    build.onResolve({ filter }, args => ({ path: args.path, external: true }))
+  },
+}
+
+
+build({
+  bundle: true,
+  format: "esm",
+  entryPoints: [`./src/main.ts`],
+  outfile: `./dist/index.mjs`,
+  plugins: [wasmPlugin],
+  external: ["fs", "path"],
+  logLevel: "info",
+})
+
+await build({
+  bundle: true,
+  format: "cjs",
+  entryPoints: { index: './src/main.ts' },
+  outdir: `./dist/`,
+  external: ["fs", "path"],
+  logLevel: "info",
+  plugins: [
+    wasmPlugin,
+    umdWrapper(umdWrapperOptions),
+    dtsPlugin({
+      outDir: `./dist/`,
+      tsconfig: "tsconfig.json"
+    })
+  ]
+})
+
+fs.renameSync('./dist/main.d.ts', './dist/index.d.ts');

package/lib/index.cjs

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

package/package.json

@@ -0,0 +1,34 @@
+{
+	"name": "@bendover111222333444/epoxy-transport",
+	"version": "3.0.2",
+	"description": "a bare transport that implements end-to-end encryption with epoxy-tls and wisp",
+	"main": "./dist/index.mjs",
+	"keywords": [],
+	"author": "",
+	"type": "module",
+	"license": "AGPL-3.0-only",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/MercuryWorkshop/epoxy-transport.git"
+	},
+	"scripts": {
+		"build": "node esbuild.bundle.mjs",
+		"prepack": "npm run build"
+	},
+	"dependencies": {
+		"@mercuryworkshop/epoxy-tls": "2.1.19-1"
+	},
+	"devDependencies": {
+		"@mercuryworkshop/proxy-transports": "^1.0.2",
+		"esbuild": "^0.25.8",
+		"esbuild-plugin-d.ts": "^1.3.1",
+		"esbuild-plugin-umd-wrapper": "^3.0.0"
+	},
+	"exports": {
+    	".": {
+      		"import": "./dist/index.mjs",
+      		"require": "./dist/index.js",
+      		"types": "./dist/index.d.ts"
+    	}
+  	}
+}

package/src/main.ts

@@ -0,0 +1,171 @@
+import type {
+	RawHeaders,
+	TransferrableResponse,
+	ProxyTransport,
+} from "@mercuryworkshop/proxy-transports";
+import initEpoxy, {
+	EpoxyClient,
+	EpoxyClientOptions,
+	EpoxyHandlers,
+	info as epoxyInfo,
+} from "@mercuryworkshop/epoxy-tls";
+
+export { epoxyInfo };
+
+export type EpoxyOptions = {
+	wisp_v2?: boolean;
+	udp_extension_required?: boolean;
+
+	title_case_headers?: boolean;
+	ws_title_case_headers?: boolean;
+
+	wisp_ws_protocols?: string[];
+
+	redirect_limit?: number;
+	header_limit?: number;
+	buffer_size?: number;
+};
+const opts = [
+	"wisp_v2",
+	"udp_extension_required",
+	"title_case_headers",
+	"ws_title_case_headers",
+	"wisp_ws_protocols",
+	"redirect_limit",
+	"header_limit",
+	"buffer_size",
+];
+
+export default class EpoxyTransport implements ProxyTransport {
+	ready = false;
+
+	client_version: typeof epoxyInfo;
+	client: EpoxyClient = null!;
+	wisp: string;
+	opts: EpoxyOptions;
+
+	constructor(opts: EpoxyOptions & { wisp: string }) {
+		this.wisp = opts.wisp;
+		this.opts = opts;
+
+		this.client_version = epoxyInfo;
+	}
+
+	setopt(opts: EpoxyClientOptions, opt: string) {
+		// == allows both null and undefined
+		if (this.opts[opt] != null) opts[opt] = this.opts[opt];
+	}
+
+	async init() {
+		await initEpoxy();
+
+		let options = new EpoxyClientOptions();
+		options.user_agent = navigator.userAgent;
+		opts.forEach((x) => this.setopt(options, x));
+		this.client = new EpoxyClient(this.wisp, options);
+
+		this.ready = true;
+	}
+
+	async meta() {}
+
+	async request(
+		remote: URL,
+		method: string,
+		body: BodyInit | null,
+		headers: RawHeaders,
+		signal: AbortSignal | undefined
+	): Promise<TransferrableResponse> {
+		if (body instanceof Blob) body = await body.arrayBuffer();
+
+		try {
+			let headersObj: Record<string, string> = {};
+			for (let [key, value] of headers) {
+				if (headersObj[key]) {
+					// epoxy does not support multiple headers with the same key
+					console.warn(
+						`Duplicate header key "${key}" detected. Overwriting previous value.`
+					);
+				}
+				headersObj[key] = value;
+			}
+
+			let res = await this.client.fetch(remote.href, {
+				method,
+				body,
+				headers: headersObj,
+				redirect: "manual",
+			});
+			let headersEntries: RawHeaders = [];
+			for (let [key, value] of Object.entries((res as any).rawHeaders) as any) {
+				if (Array.isArray(value)) {
+					for (let v of value) {
+						headersEntries.push([key, v]);
+					}
+				} else {
+					headersEntries.push([key, value]);
+				}
+			}
+			return {
+				body: res.body!,
+				headers: headersEntries,
+				status: res.status,
+				statusText: res.statusText,
+			};
+		} catch (err) {
+			console.error(err);
+			throw err;
+		}
+	}
+
+	connect(
+		url: URL,
+		protocols: string[],
+		requestHeaders: RawHeaders,
+		onopen: (protocol: string, extensions: string) => void,
+		onmessage: (data: Blob | ArrayBuffer | string) => void,
+		onclose: (code: number, reason: string) => void,
+		onerror: (error: string) => void
+	): [
+		(data: Blob | ArrayBuffer | string) => void,
+		(code: number, reason: string) => void,
+	] {
+		let handlers = new EpoxyHandlers(
+			// epoxy does not support getting the server selected protocol/extension
+			() => onopen("", ""),
+			// epoxy does not support getting close code/reason
+			() => onclose(1000, "Closed by remote"),
+			onerror,
+			(data: Uint8Array | string) =>
+				//@ts-ignore
+				data instanceof Uint8Array ? onmessage(data.buffer) : onmessage(data)
+		);
+
+		let headersObj: Record<string, string> = {};
+		for (let [key, value] of requestHeaders) {
+			if (headersObj[key]) {
+				console.warn(
+					`Duplicate header key "${key}" detected. Overwriting previous value.`
+				);
+			}
+			headersObj[key] = value;
+		}
+
+		let ws = this.client.connect_websocket(
+			handlers,
+			url.href,
+			protocols,
+			headersObj
+		);
+
+		return [
+			async (data) => {
+				if (data instanceof Blob) data = await data.arrayBuffer();
+				(await ws).send(data);
+			},
+			async (code, reason) => {
+				(await ws).close(code, reason || "");
+			},
+		];
+	}
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+	"compilerOptions": {
+		"outDir": "dist",
+		"sourceMap": true,
+		"target": "ES2022",
+		"lib": ["DOM", "DOM.Iterable", "ESNext"],
+		"strict": true,
+		"stripInternal": true,
+		"module": "ES6",
+		"moduleResolution": "Bundler",
+		"allowSyntheticDefaultImports": true,
+		"declaration": true,
+		"noImplicitAny": false
+	},
+	"include": ["src"]
+}