@arcjet/redact-wasm 1.7.0 → 1.8.0

package/dist/_virtual/_./wasm/arcjet_analyze_bindings_redact.component.core2.js

@@ -0,0 +1,12 @@
+//#region \0./wasm/arcjet_analyze_bindings_redact.component.core2.js
+/**
+* This file contains an Arcjet Wasm binary inlined as a base64 Data URL with
+* the application/wasm MIME type, then decoded into a WebAssembly.Module.
+*/
+const wasmBase64 = "data:application/wasm;base64,AGFzbQEAAAABEAJgA39/fwBgBn9/f39/fwADAwIAAQQFAXABAgIHFAMBMAAAATEAAQgkaW1wb3J0cwEACiMCDQAgACABIAJBABEAAAsTACAAIAEgAiADIAQgBUEBEQEACwAvCXByb2R1Y2VycwEMcHJvY2Vzc2VkLWJ5AQ13aXQtY29tcG9uZW50BzAuMjQ0LjA=";
+async function wasm() {
+	const buf = await (await fetch(wasmBase64, { cache: "no-store" })).arrayBuffer();
+	return WebAssembly.compile(buf);
+}
+//#endregion
+export { wasm };

package/dist/_virtual/_./wasm/arcjet_analyze_bindings_redact.component.core3.js

@@ -0,0 +1,12 @@
+//#region \0./wasm/arcjet_analyze_bindings_redact.component.core3.js
+/**
+* This file contains an Arcjet Wasm binary inlined as a base64 Data URL with
+* the application/wasm MIME type, then decoded into a WebAssembly.Module.
+*/
+const wasmBase64 = "data:application/wasm;base64,AGFzbQEAAAABEAJgA39/fwBgBn9/f39/fwACGgMAATAAAAABMQABAAgkaW1wb3J0cwFwAQICCQgBAEEACwIAAQAvCXByb2R1Y2VycwEMcHJvY2Vzc2VkLWJ5AQ13aXQtY29tcG9uZW50BzAuMjQ0LjA=";
+async function wasm() {
+	const buf = await (await fetch(wasmBase64, { cache: "no-store" })).arrayBuffer();
+	return WebAssembly.compile(buf);
+}
+//#endregion
+export { wasm };

package/dist/edge-light.d.ts

@@ -0,0 +1,9 @@
+import { ArcjetRedactCustomRedact, SensitiveInfoEntity } from "./wasm/interfaces/arcjet-redact-custom-redact.js";
+import { RedactSensitiveInfoConfig, RedactedSensitiveInfoEntity, instantiate } from "./wasm/arcjet_analyze_bindings_redact.component.js";
+
+//#region src/edge-light.d.ts
+declare function initializeWasm(detect: CustomDetect, replace: CustomRedact): Promise<Awaited<ReturnType<typeof instantiate>> | undefined>;
+type CustomDetect = typeof ArcjetRedactCustomRedact.detectSensitiveInfo;
+type CustomRedact = typeof ArcjetRedactCustomRedact.redactSensitiveInfo;
+//#endregion
+export { type CustomDetect, type CustomRedact, type RedactSensitiveInfoConfig, type RedactedSensitiveInfoEntity, type SensitiveInfoEntity, initializeWasm };

package/dist/edge-light.js

@@ -0,0 +1,24 @@
+import { instantiate } from "./wasm/arcjet_analyze_bindings_redact.component.js";
+import componentCoreWasm from "./wasm/arcjet_analyze_bindings_redact.component.core.wasm?module";
+import componentCore2Wasm from "./wasm/arcjet_analyze_bindings_redact.component.core2.wasm?module";
+import componentCore3Wasm from "./wasm/arcjet_analyze_bindings_redact.component.core3.wasm?module";
+//#region src/edge-light.ts
+async function moduleFromPath(path) {
+	if (path === "arcjet_analyze_bindings_redact.component.core.wasm") return componentCoreWasm;
+	if (path === "arcjet_analyze_bindings_redact.component.core2.wasm") return componentCore2Wasm;
+	if (path === "arcjet_analyze_bindings_redact.component.core3.wasm") return componentCore3Wasm;
+	throw new Error(`Unknown path: ${path}`);
+}
+async function initializeWasm(detect, replace) {
+	const coreImports = { "arcjet:redact/custom-redact": {
+		detectSensitiveInfo: detect,
+		redactSensitiveInfo: replace
+	} };
+	try {
+		return await instantiate(moduleFromPath, coreImports);
+	} catch {
+		console.debug("WebAssembly is not supported in this runtime");
+	}
+}
+//#endregion
+export { initializeWasm };

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+import { ArcjetRedactCustomRedact, SensitiveInfoEntity } from "./wasm/interfaces/arcjet-redact-custom-redact.js";
+import { RedactSensitiveInfoConfig, RedactedSensitiveInfoEntity, instantiate } from "./wasm/arcjet_analyze_bindings_redact.component.js";
+
+//#region src/index.d.ts
+/**
+* Initialize the WebAssembly.
+*
+* @param detect
+*   Custom detection function.
+* @param replace
+*   Custom replacement function.
+* @returns
+*   Promise to the initialized WebAssembly instance.
+*/
+declare function initializeWasm(detect: CustomDetect, replace: CustomRedact): Promise<Awaited<ReturnType<typeof instantiate>> | undefined>;
+/**
+* Detect sensitive info.
+*
+* @param tokens
+*   Tokens to detect in.
+* @returns
+*   Array of detected entities.
+*/
+type CustomDetect = typeof ArcjetRedactCustomRedact.detectSensitiveInfo;
+/**
+* Redact sensitive info.
+*
+* @param entityType
+*   Entity to redact.
+* @param plaintext
+*   The plaintext string to redact.
+* @returns
+*   Redacted string.
+*/
+type CustomRedact = typeof ArcjetRedactCustomRedact.redactSensitiveInfo;
+//#endregion
+export { type RedactSensitiveInfoConfig, type RedactedSensitiveInfoEntity, type SensitiveInfoEntity, initializeWasm };

package/dist/index.js

@@ -0,0 +1,37 @@
+import { instantiate } from "./wasm/arcjet_analyze_bindings_redact.component.js";
+import { wasm } from "./_virtual/_./wasm/arcjet_analyze_bindings_redact.component.core.js";
+import { wasm as wasm$1 } from "./_virtual/_./wasm/arcjet_analyze_bindings_redact.component.core2.js";
+import { wasm as wasm$2 } from "./_virtual/_./wasm/arcjet_analyze_bindings_redact.component.core3.js";
+//#region src/index.ts
+const componentCoreWasmPromise = wasm();
+const componentCore2WasmPromise = wasm$1();
+const componentCore3WasmPromise = wasm$2();
+async function moduleFromPath(path) {
+	if (path === "arcjet_analyze_bindings_redact.component.core.wasm") return componentCoreWasmPromise;
+	if (path === "arcjet_analyze_bindings_redact.component.core2.wasm") return componentCore2WasmPromise;
+	if (path === "arcjet_analyze_bindings_redact.component.core3.wasm") return componentCore3WasmPromise;
+	throw new Error(`Unknown path: ${path}`);
+}
+/**
+* Initialize the WebAssembly.
+*
+* @param detect
+*   Custom detection function.
+* @param replace
+*   Custom replacement function.
+* @returns
+*   Promise to the initialized WebAssembly instance.
+*/
+async function initializeWasm(detect, replace) {
+	const coreImports = { "arcjet:redact/custom-redact": {
+		detectSensitiveInfo: detect,
+		redactSensitiveInfo: replace
+	} };
+	try {
+		return await instantiate(moduleFromPath, coreImports);
+	} catch {
+		console.debug("WebAssembly is not supported in this runtime");
+	}
+}
+//#endregion
+export { initializeWasm };

package/dist/wasm/arcjet_analyze_bindings_redact.component.d.ts

@@ -0,0 +1,45 @@
+import { ArcjetRedactCustomRedact, SensitiveInfoEntity } from "./interfaces/arcjet-redact-custom-redact.js";
+
+//#region src/wasm/arcjet_analyze_bindings_redact.component.d.ts
+interface RedactSensitiveInfoConfig {
+  entities?: Array<SensitiveInfoEntity>;
+  contextWindowSize?: number;
+  skipCustomDetect: boolean;
+  skipCustomRedact: boolean;
+}
+interface RedactedSensitiveInfoEntity {
+  original: string;
+  redacted: string;
+  start: number;
+  end: number;
+  identifiedType: SensitiveInfoEntity;
+}
+interface ImportObject {
+  'arcjet:redact/custom-redact': typeof ArcjetRedactCustomRedact;
+}
+interface Root {
+  redact(content: string, options: RedactSensitiveInfoConfig): Array<RedactedSensitiveInfoEntity>;
+}
+/**
+* Instantiates this component with the provided imports and
+* returns a map of all the exports of the component.
+*
+* This function is intended to be similar to the
+* `WebAssembly.instantiate` function. The second `imports`
+* argument is the "import object" for wasm, except here it
+* uses component-model-layer types instead of core wasm
+* integers/numbers/etc.
+*
+* The first argument to this function, `getCoreModule`, is
+* used to compile core wasm modules within the component.
+* Components are composed of core wasm modules and this callback
+* will be invoked per core wasm module. The caller of this
+* function is responsible for reading the core wasm module
+* identified by `path` and returning its compiled
+* `WebAssembly.Module` object. This would use `compileStreaming`
+* on the web, for example.
+*/
+declare function instantiate(getCoreModule: (path: string) => WebAssembly.Module, imports: ImportObject, instantiateCore?: (module: WebAssembly.Module, imports: Record<string, any>) => WebAssembly.Instance): Root;
+declare function instantiate(getCoreModule: (path: string) => WebAssembly.Module | Promise<WebAssembly.Module>, imports: ImportObject, instantiateCore?: (module: WebAssembly.Module, imports: Record<string, any>) => WebAssembly.Instance | Promise<WebAssembly.Instance>): Root | Promise<Root>;
+//#endregion
+export { ImportObject, RedactSensitiveInfoConfig, RedactedSensitiveInfoEntity, Root, type SensitiveInfoEntity, instantiate };

package/dist/wasm/arcjet_analyze_bindings_redact.component.js

@@ -0,0 +1,273 @@
+//#region src/wasm/arcjet_analyze_bindings_redact.component.js
+function instantiate(getCoreModule, imports, instantiateCore = WebAssembly.instantiate) {
+	let dv = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer());
+	const dataView = (mem) => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
+	function toUint32(val) {
+		return val >>> 0;
+	}
+	const utf8Decoder = new TextDecoder();
+	const utf8Encoder = new TextEncoder();
+	let utf8EncodedLen = 0;
+	function utf8Encode(s, realloc, memory) {
+		if (typeof s !== "string") throw new TypeError("expected a string");
+		if (s.length === 0) {
+			utf8EncodedLen = 0;
+			return 1;
+		}
+		let buf = utf8Encoder.encode(s);
+		let ptr = realloc(0, 0, 1, buf.length);
+		new Uint8Array(memory.buffer).set(buf, ptr);
+		utf8EncodedLen = buf.length;
+		return ptr;
+	}
+	const module0 = getCoreModule("arcjet_analyze_bindings_redact.component.core.wasm");
+	const module1 = getCoreModule("arcjet_analyze_bindings_redact.component.core2.wasm");
+	const module2 = getCoreModule("arcjet_analyze_bindings_redact.component.core3.wasm");
+	const { detectSensitiveInfo, redactSensitiveInfo } = imports["arcjet:redact/custom-redact"];
+	let gen = (function* init() {
+		let exports0;
+		let exports1;
+		let memory0;
+		let realloc0;
+		function trampoline0(arg0, arg1, arg2) {
+			var len1 = arg1;
+			var base1 = arg0;
+			var result1 = [];
+			for (let i = 0; i < len1; i++) {
+				const base = base1 + i * 8;
+				var ptr0 = dataView(memory0).getInt32(base + 0, true);
+				var len0 = dataView(memory0).getInt32(base + 4, true);
+				var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
+				result1.push(result0);
+			}
+			var vec5 = detectSensitiveInfo(result1);
+			var len5 = vec5.length;
+			var result5 = realloc0(0, 0, 4, len5 * 16);
+			for (let i = 0; i < vec5.length; i++) {
+				const e = vec5[i];
+				const base = result5 + i * 16;
+				var variant4 = e;
+				if (variant4 === null || variant4 === void 0) dataView(memory0).setInt8(base + 0, 0, true);
+				else {
+					const e = variant4;
+					dataView(memory0).setInt8(base + 0, 1, true);
+					var variant3 = e;
+					switch (variant3.tag) {
+						case "email":
+							dataView(memory0).setInt8(base + 4, 0, true);
+							break;
+						case "phone-number":
+							dataView(memory0).setInt8(base + 4, 1, true);
+							break;
+						case "ip-address":
+							dataView(memory0).setInt8(base + 4, 2, true);
+							break;
+						case "credit-card-number":
+							dataView(memory0).setInt8(base + 4, 3, true);
+							break;
+						case "custom": {
+							const e = variant3.val;
+							dataView(memory0).setInt8(base + 4, 4, true);
+							var ptr2 = utf8Encode(e, realloc0, memory0);
+							var len2 = utf8EncodedLen;
+							dataView(memory0).setInt32(base + 12, len2, true);
+							dataView(memory0).setInt32(base + 8, ptr2, true);
+							break;
+						}
+						default: throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant3.tag)}\` (received \`${variant3}\`) specified for \`SensitiveInfoEntity\``);
+					}
+				}
+			}
+			dataView(memory0).setInt32(arg2 + 4, len5, true);
+			dataView(memory0).setInt32(arg2 + 0, result5, true);
+		}
+		function trampoline1(arg0, arg1, arg2, arg3, arg4, arg5) {
+			let variant1;
+			switch (arg0) {
+				case 0:
+					variant1 = { tag: "email" };
+					break;
+				case 1:
+					variant1 = { tag: "phone-number" };
+					break;
+				case 2:
+					variant1 = { tag: "ip-address" };
+					break;
+				case 3:
+					variant1 = { tag: "credit-card-number" };
+					break;
+				case 4:
+					var ptr0 = arg1;
+					var len0 = arg2;
+					variant1 = {
+						tag: "custom",
+						val: utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0))
+					};
+					break;
+				default: throw new TypeError("invalid variant discriminant for SensitiveInfoEntity");
+			}
+			var ptr2 = arg3;
+			var len2 = arg4;
+			var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
+			var variant4 = redactSensitiveInfo(variant1, result2);
+			if (variant4 === null || variant4 === void 0) dataView(memory0).setInt8(arg5 + 0, 0, true);
+			else {
+				const e = variant4;
+				dataView(memory0).setInt8(arg5 + 0, 1, true);
+				var ptr3 = utf8Encode(e, realloc0, memory0);
+				var len3 = utf8EncodedLen;
+				dataView(memory0).setInt32(arg5 + 8, len3, true);
+				dataView(memory0).setInt32(arg5 + 4, ptr3, true);
+			}
+		}
+		let exports2;
+		let postReturn0;
+		Promise.all([
+			module0,
+			module1,
+			module2
+		]).catch(() => {});
+		({exports: exports0} = yield instantiateCore(yield module1));
+		({exports: exports1} = yield instantiateCore(yield module0, { "arcjet:redact/custom-redact": {
+			"detect-sensitive-info": exports0["0"],
+			"redact-sensitive-info": exports0["1"]
+		} }));
+		memory0 = exports1.memory;
+		realloc0 = exports1.cabi_realloc;
+		({exports: exports2} = yield instantiateCore(yield module2, { "": {
+			$imports: exports0.$imports,
+			"0": trampoline0,
+			"1": trampoline1
+		} }));
+		postReturn0 = exports1.cabi_post_redact;
+		function redact(arg0, arg1) {
+			var ptr0 = utf8Encode(arg0, realloc0, memory0);
+			var len0 = utf8EncodedLen;
+			var { entities: v1_0, contextWindowSize: v1_1, skipCustomDetect: v1_2, skipCustomRedact: v1_3 } = arg1;
+			var variant5 = v1_0;
+			let variant5_0;
+			let variant5_1;
+			let variant5_2;
+			if (variant5 === null || variant5 === void 0) {
+				variant5_0 = 0;
+				variant5_1 = 0;
+				variant5_2 = 0;
+			} else {
+				var vec4 = variant5;
+				var len4 = vec4.length;
+				var result4 = realloc0(0, 0, 4, len4 * 12);
+				for (let i = 0; i < vec4.length; i++) {
+					const e = vec4[i];
+					const base = result4 + i * 12;
+					var variant3 = e;
+					switch (variant3.tag) {
+						case "email":
+							dataView(memory0).setInt8(base + 0, 0, true);
+							break;
+						case "phone-number":
+							dataView(memory0).setInt8(base + 0, 1, true);
+							break;
+						case "ip-address":
+							dataView(memory0).setInt8(base + 0, 2, true);
+							break;
+						case "credit-card-number":
+							dataView(memory0).setInt8(base + 0, 3, true);
+							break;
+						case "custom": {
+							const e = variant3.val;
+							dataView(memory0).setInt8(base + 0, 4, true);
+							var ptr2 = utf8Encode(e, realloc0, memory0);
+							var len2 = utf8EncodedLen;
+							dataView(memory0).setInt32(base + 8, len2, true);
+							dataView(memory0).setInt32(base + 4, ptr2, true);
+							break;
+						}
+						default: throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant3.tag)}\` (received \`${variant3}\`) specified for \`SensitiveInfoEntity\``);
+					}
+				}
+				variant5_0 = 1;
+				variant5_1 = result4;
+				variant5_2 = len4;
+			}
+			var variant6 = v1_1;
+			let variant6_0;
+			let variant6_1;
+			if (variant6 === null || variant6 === void 0) {
+				variant6_0 = 0;
+				variant6_1 = 0;
+			} else {
+				const e = variant6;
+				variant6_0 = 1;
+				variant6_1 = toUint32(e);
+			}
+			const ret = exports1.redact(ptr0, len0, variant5_0, variant5_1, variant5_2, variant6_0, variant6_1, v1_2 ? 1 : 0, v1_3 ? 1 : 0);
+			var len11 = dataView(memory0).getInt32(ret + 4, true);
+			var base11 = dataView(memory0).getInt32(ret + 0, true);
+			var result11 = [];
+			for (let i = 0; i < len11; i++) {
+				const base = base11 + i * 36;
+				var ptr7 = dataView(memory0).getInt32(base + 0, true);
+				var len7 = dataView(memory0).getInt32(base + 4, true);
+				var result7 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr7, len7));
+				var ptr8 = dataView(memory0).getInt32(base + 8, true);
+				var len8 = dataView(memory0).getInt32(base + 12, true);
+				var result8 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr8, len8));
+				let variant10;
+				switch (dataView(memory0).getUint8(base + 24, true)) {
+					case 0:
+						variant10 = { tag: "email" };
+						break;
+					case 1:
+						variant10 = { tag: "phone-number" };
+						break;
+					case 2:
+						variant10 = { tag: "ip-address" };
+						break;
+					case 3:
+						variant10 = { tag: "credit-card-number" };
+						break;
+					case 4:
+						var ptr9 = dataView(memory0).getInt32(base + 28, true);
+						var len9 = dataView(memory0).getInt32(base + 32, true);
+						variant10 = {
+							tag: "custom",
+							val: utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr9, len9))
+						};
+						break;
+					default: throw new TypeError("invalid variant discriminant for SensitiveInfoEntity");
+				}
+				result11.push({
+					original: result7,
+					redacted: result8,
+					start: dataView(memory0).getInt32(base + 16, true) >>> 0,
+					end: dataView(memory0).getInt32(base + 20, true) >>> 0,
+					identifiedType: variant10
+				});
+			}
+			const retVal = result11;
+			postReturn0(ret);
+			return retVal;
+		}
+		return { redact };
+	})();
+	let promise, resolve, reject;
+	function runNext(value) {
+		try {
+			let done;
+			do
+				({value, done} = gen.next(value));
+			while (!(value instanceof Promise) && !done);
+			if (done) if (resolve) resolve(value);
+			else return value;
+			if (!promise) promise = new Promise((_resolve, _reject) => (resolve = _resolve, reject = _reject));
+			value.then((nextVal) => done ? resolve() : runNext(nextVal), reject);
+		} catch (e) {
+			if (reject) reject(e);
+			else throw e;
+		}
+	}
+	const maybeSyncReturn = runNext(null);
+	return promise || maybeSyncReturn;
+}
+//#endregion
+export { instantiate };

package/dist/wasm/interfaces/arcjet-redact-custom-redact.d.ts

@@ -0,0 +1,24 @@
+//#region src/wasm/interfaces/arcjet-redact-custom-redact.d.ts
+declare namespace ArcjetRedactCustomRedact {
+  export function detectSensitiveInfo(tokens: Array<string>): Array<SensitiveInfoEntity | undefined>;
+  export function redactSensitiveInfo(entityType: SensitiveInfoEntity, plaintext: string): string | undefined;
+}
+type SensitiveInfoEntity = SensitiveInfoEntityEmail | SensitiveInfoEntityPhoneNumber | SensitiveInfoEntityIpAddress | SensitiveInfoEntityCreditCardNumber | SensitiveInfoEntityCustom;
+interface SensitiveInfoEntityEmail {
+  tag: 'email';
+}
+interface SensitiveInfoEntityPhoneNumber {
+  tag: 'phone-number';
+}
+interface SensitiveInfoEntityIpAddress {
+  tag: 'ip-address';
+}
+interface SensitiveInfoEntityCreditCardNumber {
+  tag: 'credit-card-number';
+}
+interface SensitiveInfoEntityCustom {
+  tag: 'custom';
+  val: string;
+}
+//#endregion
+export { ArcjetRedactCustomRedact, SensitiveInfoEntity, SensitiveInfoEntityCreditCardNumber, SensitiveInfoEntityCustom, SensitiveInfoEntityEmail, SensitiveInfoEntityIpAddress, SensitiveInfoEntityPhoneNumber };

package/dist/wasm.d.ts

@@ -0,0 +1,52 @@
+//#region src/wasm.d.ts
+// Basic interface of WebAssembly that we use.
+// See:
+// <https://github.com/microsoft/TypeScript/blob/7956c0016/src/lib/dom.generated.d.ts#L37654>.
+// This only includes `Module` which we use here.
+// This can be removed when WebAssembly is in `@types/node` as we use that here.
+declare namespace WebAssemblyLike {
+  type ImportExportKind = "function" | "global" | "memory" | "table";
+  interface ModuleExportDescriptor {
+    kind: ImportExportKind;
+    name: string;
+  }
+  interface ModuleImportDescriptor {
+    kind: ImportExportKind;
+    module: string;
+    name: string;
+  }
+  interface Module {}
+  const Module: {
+    prototype: Module;
+    new (bytes: ArrayBufferView<ArrayBuffer> | ArrayBuffer): Module;
+    customSections(moduleObject: Module, sectionName: string): ArrayBuffer[];
+    exports(moduleObject: Module): ModuleExportDescriptor[];
+    imports(moduleObject: Module): ModuleImportDescriptor[];
+  };
+}
+/**
+ * Vercel uses the `.wasm?module` suffix to make WebAssembly available in their
+ * Vercel Functions product.
+ *
+ * https://vercel.com/docs/functions/wasm#using-a-webassembly-file
+ */
+declare module "*.wasm?module" {
+  export default WebAssemblyLike.Module;
+}
+/**
+ * The Cloudflare docs say they support the `.wasm?module` suffix, but that
+ * seems to no longer be the case with Wrangler 2 so we need to have separate
+ * imports for just the `.wasm` files.
+ *
+ * https://developers.cloudflare.com/workers/runtime-apis/webassembly/javascript/#bundling
+ */
+declare module "*.wasm" {
+  export default WebAssemblyLike.Module;
+}
+/**
+ * Our Rollup build turns `.wasm?js` imports into JS imports that provide the
+ * `wasm()` function which decodes a base64 Data URL into a WebAssembly Module
+ */
+declare module "*.wasm?js" {
+  export function wasm(): Promise<WebAssemblyLike.Module>;
+}

package/dist/workerd.d.ts

@@ -0,0 +1,9 @@
+import { ArcjetRedactCustomRedact, SensitiveInfoEntity } from "./wasm/interfaces/arcjet-redact-custom-redact.js";
+import { RedactSensitiveInfoConfig, RedactedSensitiveInfoEntity, instantiate } from "./wasm/arcjet_analyze_bindings_redact.component.js";
+
+//#region src/workerd.d.ts
+declare function initializeWasm(detect: CustomDetect, replace: CustomRedact): Promise<Awaited<ReturnType<typeof instantiate>> | undefined>;
+type CustomDetect = typeof ArcjetRedactCustomRedact.detectSensitiveInfo;
+type CustomRedact = typeof ArcjetRedactCustomRedact.redactSensitiveInfo;
+//#endregion
+export { type CustomDetect, type CustomRedact, type RedactSensitiveInfoConfig, type RedactedSensitiveInfoEntity, type SensitiveInfoEntity, initializeWasm };

package/dist/workerd.js

@@ -0,0 +1,24 @@
+import { instantiate } from "./wasm/arcjet_analyze_bindings_redact.component.js";
+import componentCoreWasm from "./wasm/arcjet_analyze_bindings_redact.component.core.wasm";
+import componentCore2Wasm from "./wasm/arcjet_analyze_bindings_redact.component.core2.wasm";
+import componentCore3Wasm from "./wasm/arcjet_analyze_bindings_redact.component.core3.wasm";
+//#region src/workerd.ts
+async function moduleFromPath(path) {
+	if (path === "arcjet_analyze_bindings_redact.component.core.wasm") return componentCoreWasm;
+	if (path === "arcjet_analyze_bindings_redact.component.core2.wasm") return componentCore2Wasm;
+	if (path === "arcjet_analyze_bindings_redact.component.core3.wasm") return componentCore3Wasm;
+	throw new Error(`Unknown path: ${path}`);
+}
+async function initializeWasm(detect, replace) {
+	const coreImports = { "arcjet:redact/custom-redact": {
+		detectSensitiveInfo: detect,
+		redactSensitiveInfo: replace
+	} };
+	try {
+		return await instantiate(moduleFromPath, coreImports);
+	} catch {
+		console.debug("WebAssembly is not supported in this runtime");
+	}
+}
+//#endregion
+export { initializeWasm };