@arcjet/analyze-wasm - npm Package Compare versions

Comparing version 1.6.1 to 1.7.0-rc.0

dist/_virtual/_./w...rcjet_analyze_js_req.component.core2.js

+//#region \0./wasm/arcjet_analyze_js_req.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,AGFzbQEAAAABFQNgA39/fwBgBH9/f38Bf2ACf38BfwMJCAABAAACAgICBAUBcAEICAcsCQEwAAABMQABATIAAgEzAAMBNAAEATUABQE2AAYBNwAHCCRpbXBvcnRzAQAKawgNACAAIAEgAkEAEQAACw8AIAAgASACIANBAREBAAsNACAAIAEgAkECEQAACw0AIAAgASACQQMRAAALCwAgACABQQQRAgALCwAgACABQQURAgALCwAgACABQQYRAgALCwAgACABQQcRAgALAC8JcHJvZHVjZXJzAQxwcm9jZXNzZWQtYnkBDXdpdC1jb21wb25lbnQHMC4yNTEuMA==";
+async function wasm() {
+	const buf = await (await fetch(wasmBase64, { cache: "no-store" })).arrayBuffer();
+	return WebAssembly.compile(buf);
+}
+//#endregion
+export { wasm };

dist/_virtual/_./w...rcjet_analyze_js_req.component.core3.js

+//#region \0./wasm/arcjet_analyze_js_req.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,AGFzbQEAAAABFQNgA39/fwBgBH9/f38Bf2ACf38BfwI4CQABMAAAAAExAAEAATIAAAABMwAAAAE0AAIAATUAAgABNgACAAE3AAIACCRpbXBvcnRzAXABCAgJDgEAQQALCAABAgMEBQYHAC8JcHJvZHVjZXJzAQxwcm9jZXNzZWQtYnkBDXdpdC1jb21wb25lbnQHMC4yNTEuMA==";
+async function wasm() {
+	const buf = await (await fetch(wasmBase64, { cache: "no-store" })).arrayBuffer();
+	return WebAssembly.compile(buf);
+}
+//#endregion
+export { wasm };

dist/edge-light.d.ts

+import { ImportObject as ImportObject$1, instantiate } from "./wasm/arcjet_analyze_js_req.component.js";
+import { BotConfig, BotResult, DetectSensitiveInfoFunction, DetectedSensitiveInfoEntity, EmailValidationConfig, EmailValidationResult, FilterResult, ImportObject, SensitiveInfoEntities, SensitiveInfoEntity, SensitiveInfoResult } from "./types.js";
+
+//#region src/edge-light.d.ts
+/**
+* Initialize the generated WebAssembly component.
+*
+* @param coreImports
+*   Things, typically functions, to pass into the component.
+* @returns
+*   Promise that resolves to the initialized component.
+*/
+declare function initializeWasm(coreImports: ImportObject$1): Promise<Awaited<ReturnType<typeof instantiate>> | undefined>;
+//#endregion
+export { type BotConfig, type BotResult, type DetectSensitiveInfoFunction, type DetectedSensitiveInfoEntity, type EmailValidationConfig, type EmailValidationResult, type FilterResult, type ImportObject, type SensitiveInfoEntities, type SensitiveInfoEntity, type SensitiveInfoResult, initializeWasm };

dist/edge-light.js

+import { instantiate } from "./wasm/arcjet_analyze_js_req.component.js";
+import componentCoreWasm from "./wasm/arcjet_analyze_js_req.component.core.wasm?module";
+import componentCore2Wasm from "./wasm/arcjet_analyze_js_req.component.core2.wasm?module";
+import componentCore3Wasm from "./wasm/arcjet_analyze_js_req.component.core3.wasm?module";
+//#region src/edge-light.ts
+async function moduleFromPath(path) {
+	if (path === "arcjet_analyze_js_req.component.core.wasm") return componentCoreWasm;
+	if (path === "arcjet_analyze_js_req.component.core2.wasm") return componentCore2Wasm;
+	if (path === "arcjet_analyze_js_req.component.core3.wasm") return componentCore3Wasm;
+	throw new Error(`Unknown path: ${path}`);
+}
+/**
+* Initialize the generated WebAssembly component.
+*
+* @param coreImports
+*   Things, typically functions, to pass into the component.
+* @returns
+*   Promise that resolves to the initialized component.
+*/
+async function initializeWasm(coreImports) {
+	try {
+		return instantiate(moduleFromPath, coreImports);
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { initializeWasm };

dist/index.d.ts

+import { ImportObject as ImportObject$1, instantiate } from "./wasm/arcjet_analyze_js_req.component.js";
+import { BotConfig, BotResult, DetectSensitiveInfoFunction, DetectedSensitiveInfoEntity, EmailValidationConfig, EmailValidationResult, FilterResult, ImportObject, SensitiveInfoEntities, SensitiveInfoEntity, SensitiveInfoResult } from "./types.js";
+
+//#region src/index.d.ts
+/**
+* Initialize the generated WebAssembly component.
+*
+* @param coreImports
+*   Things, typically functions, to pass into the component.
+* @returns
+*   Promise that resolves to the initialized component.
+*/
+declare function initializeWasm(coreImports: ImportObject$1): Promise<Awaited<ReturnType<typeof instantiate>> | undefined>;
+//#endregion
+export { type BotConfig, type BotResult, type DetectSensitiveInfoFunction, type DetectedSensitiveInfoEntity, type EmailValidationConfig, type EmailValidationResult, type FilterResult, type ImportObject, type SensitiveInfoEntities, type SensitiveInfoEntity, type SensitiveInfoResult, initializeWasm };

dist/index.js

+import { instantiate } from "./wasm/arcjet_analyze_js_req.component.js";
+import { wasm } from "./_virtual/_./wasm/arcjet_analyze_js_req.component.core.js";
+import { wasm as wasm$1 } from "./_virtual/_./wasm/arcjet_analyze_js_req.component.core2.js";
+import { wasm as wasm$2 } from "./_virtual/_./wasm/arcjet_analyze_js_req.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_js_req.component.core.wasm") return componentCoreWasmPromise;
+	if (path === "arcjet_analyze_js_req.component.core2.wasm") return componentCore2WasmPromise;
+	if (path === "arcjet_analyze_js_req.component.core3.wasm") return componentCore3WasmPromise;
+	throw new Error(`Unknown path: ${path}`);
+}
+/**
+* Initialize the generated WebAssembly component.
+*
+* @param coreImports
+*   Things, typically functions, to pass into the component.
+* @returns
+*   Promise that resolves to the initialized component.
+*/
+async function initializeWasm(coreImports) {
+	try {
+		return instantiate(moduleFromPath, coreImports);
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { initializeWasm };

dist/types.d.ts

+import { ArcjetJsReqSensitiveInformationIdentifier, SensitiveInfoEntity as SensitiveInfoEntity$1 } from "./wasm/interfaces/arcjet-js-req-sensitive-information-identifier.js";
+import { BotConfig as BotConfig$1, BotResult as BotResult$1, DetectedSensitiveInfoEntity as DetectedSensitiveInfoEntity$1, EmailValidationConfig as EmailValidationConfig$1, EmailValidationResult as EmailValidationResult$1, FilterResult as FilterResult$1, ImportObject as ImportObject$1, SensitiveInfoEntities as SensitiveInfoEntities$1, SensitiveInfoResult as SensitiveInfoResult$1 } from "./wasm/arcjet_analyze_js_req.component.js";
+
+//#region src/types.d.ts
+/**
+* Configuration for bot detection.
+* Generated from the WebAssembly component.
+*/
+type BotConfig = BotConfig$1;
+/**
+* Result of bot detection.
+* Generated from the WebAssembly component.
+*/
+type BotResult = BotResult$1;
+/**
+* Function signature for custom entity detection from JavaScript.
+*
+* Generated from the WebAssembly component.
+*
+* This signature corresponds to similar functions from `@arcjet/redact-wasm`
+* and `@arcjet/redact`.
+*
+* @param tokens
+*   Tokens to detect in.
+* @returns
+*   Array of `undefined` for tokens that are not sensitive or a `string` used as
+*   a label for sensitive info.
+*/
+type DetectSensitiveInfoFunction = typeof ArcjetJsReqSensitiveInformationIdentifier.detect;
+/**
+* Span of sensitive info,
+* with `start` and `end` fields relating to the input value,
+* and an `identifiedType` tag for its kind.
+* Generated from the WebAssembly component.
+*/
+type DetectedSensitiveInfoEntity = DetectedSensitiveInfoEntity$1;
+/**
+* Configuration for email validation.
+* Generated from the WebAssembly component.
+*/
+type EmailValidationConfig = EmailValidationConfig$1;
+/**
+* Result of email validation.
+* Generated from the WebAssembly component.
+*/
+type EmailValidationResult = EmailValidationResult$1;
+/**
+* Result of a filter call.
+* Generated from the WebAssembly component.
+*/
+type FilterResult = FilterResult$1;
+/**
+* Object representing the import structure.
+* These are things that can be passed *into* the WebAssembly.
+* Generated from the WebAssembly component.
+*/
+type ImportObject = ImportObject$1;
+/**
+* Configuration for sensitive info detection.
+* Generated from the WebAssembly component.
+*/
+type SensitiveInfoEntities = SensitiveInfoEntities$1;
+/**
+* Kind of sensitive info.
+* Consists of each of the tags that can detect be detected natively
+* and a custom tag for values detected from JavaScript.
+* Generated from the WebAssembly component.
+*/
+type SensitiveInfoEntity = SensitiveInfoEntity$1;
+/**
+* Result of sensitive info detection.
+* Generated from the WebAssembly component.
+*/
+type SensitiveInfoResult = SensitiveInfoResult$1;
+//#endregion
+export { BotConfig, BotResult, DetectSensitiveInfoFunction, DetectedSensitiveInfoEntity, EmailValidationConfig, EmailValidationResult, FilterResult, ImportObject, SensitiveInfoEntities, SensitiveInfoEntity, SensitiveInfoResult };

dist/types.js

dist/wasm.d.ts

+//#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>;
+}

dist/wasm/arcjet_analyze_js_req.component.d.ts

+import { ArcjetJsReqSensitiveInformationIdentifier, SensitiveInfoEntity } from "./interfaces/arcjet-js-req-sensitive-information-identifier.js";
+import { ArcjetJsReqBotIdentifier, BotEntity } from "./interfaces/arcjet-js-req-bot-identifier.js";
+import { ArcjetJsReqEmailValidatorOverrides } from "./interfaces/arcjet-js-req-email-validator-overrides.js";
+import { ArcjetJsReqFilterOverrides } from "./interfaces/arcjet-js-req-filter-overrides.js";
+import { ArcjetJsReqVerifyBot } from "./interfaces/arcjet-js-req-verify-bot.js";
+
+//#region src/wasm/arcjet_analyze_js_req.component.d.ts
+/**
+* # Variants
+* 
+* ## `"valid"`
+* 
+* ## `"invalid"`
+*/
+type EmailValidity = 'valid' | 'invalid';
+interface EmailValidationResult {
+  validity: EmailValidity;
+  blocked: Array<string>;
+}
+interface AllowEmailValidationConfig {
+  requireTopLevelDomain: boolean;
+  allowDomainLiteral: boolean;
+  allow: Array<string>;
+}
+interface DenyEmailValidationConfig {
+  requireTopLevelDomain: boolean;
+  allowDomainLiteral: boolean;
+  deny: Array<string>;
+}
+type EmailValidationConfig = EmailValidationConfigAllowEmailValidationConfig | EmailValidationConfigDenyEmailValidationConfig;
+interface EmailValidationConfigAllowEmailValidationConfig {
+  tag: 'allow-email-validation-config';
+  val: AllowEmailValidationConfig;
+}
+interface EmailValidationConfigDenyEmailValidationConfig {
+  tag: 'deny-email-validation-config';
+  val: DenyEmailValidationConfig;
+}
+type SensitiveInfoEntities = SensitiveInfoEntitiesAllow | SensitiveInfoEntitiesDeny;
+interface SensitiveInfoEntitiesAllow {
+  tag: 'allow';
+  val: Array<SensitiveInfoEntity>;
+}
+interface SensitiveInfoEntitiesDeny {
+  tag: 'deny';
+  val: Array<SensitiveInfoEntity>;
+}
+interface SensitiveInfoConfig {
+  entities: SensitiveInfoEntities;
+  contextWindowSize?: number;
+  skipCustomDetect: boolean;
+}
+interface DetectedSensitiveInfoEntity {
+  start: number;
+  end: number;
+  identifiedType: SensitiveInfoEntity;
+}
+interface SensitiveInfoResult {
+  allowed: Array<DetectedSensitiveInfoEntity>;
+  denied: Array<DetectedSensitiveInfoEntity>;
+}
+interface AllowedBotConfig {
+  entities: Array<BotEntity>;
+  skipCustomDetect: boolean;
+}
+interface DeniedBotConfig {
+  entities: Array<BotEntity>;
+  skipCustomDetect: boolean;
+}
+type BotConfig = BotConfigAllowedBotConfig | BotConfigDeniedBotConfig;
+interface BotConfigAllowedBotConfig {
+  tag: 'allowed-bot-config';
+  val: AllowedBotConfig;
+}
+interface BotConfigDeniedBotConfig {
+  tag: 'denied-bot-config';
+  val: DeniedBotConfig;
+}
+interface BotResult {
+  allowed: Array<BotEntity>;
+  denied: Array<BotEntity>;
+  verified: boolean;
+  spoofed: boolean;
+}
+interface FilterResult {
+  allowed: boolean;
+  matchedExpressions: Array<string>;
+  undeterminedExpressions: Array<string>;
+}
+interface ImportObject {
+  'arcjet:js-req/bot-identifier': typeof ArcjetJsReqBotIdentifier;
+  'arcjet:js-req/email-validator-overrides': typeof ArcjetJsReqEmailValidatorOverrides;
+  'arcjet:js-req/filter-overrides': typeof ArcjetJsReqFilterOverrides;
+  'arcjet:js-req/sensitive-information-identifier': typeof ArcjetJsReqSensitiveInformationIdentifier;
+  'arcjet:js-req/verify-bot': typeof ArcjetJsReqVerifyBot;
+}
+interface Root {
+  detectBot(request: string, options: BotConfig): BotResult;
+  matchFilters(request: string, localFields: string, expressions: Array<string>, allowIfMatch: boolean): FilterResult;
+  generateFingerprint(request: string, characteristics: Array<string>): string;
+  validateCharacteristics(request: string, characteristics: Array<string>): void;
+  isValidEmail(candidate: string, options: EmailValidationConfig): EmailValidationResult;
+  detectSensitiveInfo(content: string, options: SensitiveInfoConfig): SensitiveInfoResult;
+}
+/**
+* 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 { AllowEmailValidationConfig, AllowedBotConfig, BotConfig, BotConfigAllowedBotConfig, BotConfigDeniedBotConfig, type BotEntity, BotResult, DeniedBotConfig, DenyEmailValidationConfig, DetectedSensitiveInfoEntity, EmailValidationConfig, EmailValidationConfigAllowEmailValidationConfig, EmailValidationConfigDenyEmailValidationConfig, EmailValidationResult, EmailValidity, FilterResult, ImportObject, Root, SensitiveInfoConfig, SensitiveInfoEntities, SensitiveInfoEntitiesAllow, SensitiveInfoEntitiesDeny, type SensitiveInfoEntity, SensitiveInfoResult, instantiate };

dist/wasm/arcjet_analyze_js_req.component.js

+//#region src/wasm/arcjet_analyze_js_req.component.js
+function instantiate(getCoreModule, imports, instantiateCore = WebAssembly.instantiate) {
+	class ComponentError extends Error {
+		constructor(value) {
+			const enumerable = typeof value !== "string";
+			super(enumerable ? `${String(value)} (see error.payload)` : value);
+			Object.defineProperty(this, "payload", {
+				value,
+				enumerable
+			});
+		}
+	}
+	let dv = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer());
+	const dataView = (mem) => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
+	function throwInvalidBool() {
+		throw new TypeError("invalid variant discriminant for bool");
+	}
+	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_js_req.component.core.wasm");
+	const module1 = getCoreModule("arcjet_analyze_js_req.component.core2.wasm");
+	const module2 = getCoreModule("arcjet_analyze_js_req.component.core3.wasm");
+	const { detect } = imports["arcjet:js-req/bot-identifier"];
+	const { hasGravatar, hasMxRecords, isDisposableEmail, isFreeEmail } = imports["arcjet:js-req/email-validator-overrides"];
+	const { ipLookup } = imports["arcjet:js-req/filter-overrides"];
+	const { detect: detect$1 } = imports["arcjet:js-req/sensitive-information-identifier"];
+	const { verify } = imports["arcjet:js-req/verify-bot"];
+	let gen = (function* init() {
+		let exports0;
+		let exports1;
+		let memory0;
+		let realloc0;
+		function trampoline0(arg0, arg1, arg2) {
+			var ptr0 = arg0;
+			var len0 = arg1;
+			var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
+			var vec2 = detect(result0);
+			var len2 = vec2.length;
+			var result2 = realloc0(0, 0, 4, len2 * 8);
+			for (let i = 0; i < vec2.length; i++) {
+				const e = vec2[i];
+				const base = result2 + i * 8;
+				var ptr1 = utf8Encode(e, realloc0, memory0);
+				var len1 = utf8EncodedLen;
+				dataView(memory0).setInt32(base + 4, len1, true);
+				dataView(memory0).setInt32(base + 0, ptr1, true);
+			}
+			dataView(memory0).setInt32(arg2 + 4, len2, true);
+			dataView(memory0).setInt32(arg2 + 0, result2, true);
+		}
+		function trampoline1(arg0, arg1, arg2, arg3) {
+			var ptr0 = arg0;
+			var len0 = arg1;
+			var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
+			var ptr1 = arg2;
+			var len1 = arg3;
+			var result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
+			const ret = verify(result0, result1);
+			var val2 = ret;
+			let enum2;
+			switch (val2) {
+				case "verified":
+					enum2 = 0;
+					break;
+				case "spoofed":
+					enum2 = 1;
+					break;
+				case "unverifiable":
+					enum2 = 2;
+					break;
+				default:
+					if (ret instanceof Error) console.error(ret);
+					throw new TypeError(`"${val2}" is not one of the cases of validator-response`);
+			}
+			return enum2;
+		}
+		function trampoline2(arg0, arg1, arg2) {
+			var ptr0 = arg0;
+			var len0 = arg1;
+			var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
+			var variant2 = ipLookup(result0);
+			if (variant2 === null || variant2 === void 0) dataView(memory0).setInt8(arg2 + 0, 0, true);
+			else {
+				const e = variant2;
+				dataView(memory0).setInt8(arg2 + 0, 1, true);
+				var ptr1 = utf8Encode(e, realloc0, memory0);
+				var len1 = utf8EncodedLen;
+				dataView(memory0).setInt32(arg2 + 8, len1, true);
+				dataView(memory0).setInt32(arg2 + 4, ptr1, true);
+			}
+		}
+		function trampoline3(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 = detect$1(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 trampoline4(arg0, arg1) {
+			var ptr0 = arg0;
+			var len0 = arg1;
+			var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
+			const ret = isFreeEmail(result0);
+			var val1 = ret;
+			let enum1;
+			switch (val1) {
+				case "yes":
+					enum1 = 0;
+					break;
+				case "no":
+					enum1 = 1;
+					break;
+				case "unknown":
+					enum1 = 2;
+					break;
+				default:
+					if (ret instanceof Error) console.error(ret);
+					throw new TypeError(`"${val1}" is not one of the cases of validator-response`);
+			}
+			return enum1;
+		}
+		function trampoline5(arg0, arg1) {
+			var ptr0 = arg0;
+			var len0 = arg1;
+			var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
+			const ret = isDisposableEmail(result0);
+			var val1 = ret;
+			let enum1;
+			switch (val1) {
+				case "yes":
+					enum1 = 0;
+					break;
+				case "no":
+					enum1 = 1;
+					break;
+				case "unknown":
+					enum1 = 2;
+					break;
+				default:
+					if (ret instanceof Error) console.error(ret);
+					throw new TypeError(`"${val1}" is not one of the cases of validator-response`);
+			}
+			return enum1;
+		}
+		function trampoline6(arg0, arg1) {
+			var ptr0 = arg0;
+			var len0 = arg1;
+			var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
+			const ret = hasMxRecords(result0);
+			var val1 = ret;
+			let enum1;
+			switch (val1) {
+				case "yes":
+					enum1 = 0;
+					break;
+				case "no":
+					enum1 = 1;
+					break;
+				case "unknown":
+					enum1 = 2;
+					break;
+				default:
+					if (ret instanceof Error) console.error(ret);
+					throw new TypeError(`"${val1}" is not one of the cases of validator-response`);
+			}
+			return enum1;
+		}
+		function trampoline7(arg0, arg1) {
+			var ptr0 = arg0;
+			var len0 = arg1;
+			var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
+			const ret = hasGravatar(result0);
+			var val1 = ret;
+			let enum1;
+			switch (val1) {
+				case "yes":
+					enum1 = 0;
+					break;
+				case "no":
+					enum1 = 1;
+					break;
+				case "unknown":
+					enum1 = 2;
+					break;
+				default:
+					if (ret instanceof Error) console.error(ret);
+					throw new TypeError(`"${val1}" is not one of the cases of validator-response`);
+			}
+			return enum1;
+		}
+		let exports2;
+		let postReturn0;
+		let postReturn1;
+		let postReturn2;
+		let postReturn3;
+		let postReturn4;
+		let postReturn5;
+		Promise.all([
+			module0,
+			module1,
+			module2
+		]).catch(() => {});
+		({exports: exports0} = yield instantiateCore(yield module1));
+		({exports: exports1} = yield instantiateCore(yield module0, {
+			"arcjet:js-req/bot-identifier": { detect: exports0["0"] },
+			"arcjet:js-req/email-validator-overrides": {
+				"has-gravatar": exports0["7"],
+				"has-mx-records": exports0["6"],
+				"is-disposable-email": exports0["5"],
+				"is-free-email": exports0["4"]
+			},
+			"arcjet:js-req/filter-overrides": { "ip-lookup": exports0["2"] },
+			"arcjet:js-req/sensitive-information-identifier": { detect: exports0["3"] },
+			"arcjet:js-req/verify-bot": { verify: exports0["1"] }
+		}));
+		memory0 = exports1.memory;
+		realloc0 = exports1.cabi_realloc;
+		({exports: exports2} = yield instantiateCore(yield module2, { "": {
+			$imports: exports0.$imports,
+			"0": trampoline0,
+			"1": trampoline1,
+			"2": trampoline2,
+			"3": trampoline3,
+			"4": trampoline4,
+			"5": trampoline5,
+			"6": trampoline6,
+			"7": trampoline7
+		} }));
+		postReturn0 = exports1["cabi_post_detect-bot"];
+		postReturn1 = exports1["cabi_post_match-filters"];
+		postReturn2 = exports1["cabi_post_generate-fingerprint"];
+		postReturn3 = exports1["cabi_post_validate-characteristics"];
+		postReturn4 = exports1["cabi_post_is-valid-email"];
+		postReturn5 = exports1["cabi_post_detect-sensitive-info"];
+		function detectBot(arg0, arg1) {
+			var ptr0 = utf8Encode(arg0, realloc0, memory0);
+			var len0 = utf8EncodedLen;
+			var variant7 = arg1;
+			let variant7_0;
+			let variant7_1;
+			let variant7_2;
+			let variant7_3;
+			switch (variant7.tag) {
+				case "allowed-bot-config":
+					var { entities: v1_0, skipCustomDetect: v1_1 } = variant7.val;
+					var vec3 = v1_0;
+					var len3 = vec3.length;
+					var result3 = realloc0(0, 0, 4, len3 * 8);
+					for (let i = 0; i < vec3.length; i++) {
+						const e = vec3[i];
+						const base = result3 + i * 8;
+						var ptr2 = utf8Encode(e, realloc0, memory0);
+						var len2 = utf8EncodedLen;
+						dataView(memory0).setInt32(base + 4, len2, true);
+						dataView(memory0).setInt32(base + 0, ptr2, true);
+					}
+					variant7_0 = 0;
+					variant7_1 = result3;
+					variant7_2 = len3;
+					variant7_3 = v1_1 ? 1 : 0;
+					break;
+				case "denied-bot-config":
+					var { entities: v4_0, skipCustomDetect: v4_1 } = variant7.val;
+					var vec6 = v4_0;
+					var len6 = vec6.length;
+					var result6 = realloc0(0, 0, 4, len6 * 8);
+					for (let i = 0; i < vec6.length; i++) {
+						const e = vec6[i];
+						const base = result6 + i * 8;
+						var ptr5 = utf8Encode(e, realloc0, memory0);
+						var len5 = utf8EncodedLen;
+						dataView(memory0).setInt32(base + 4, len5, true);
+						dataView(memory0).setInt32(base + 0, ptr5, true);
+					}
+					variant7_0 = 1;
+					variant7_1 = result6;
+					variant7_2 = len6;
+					variant7_3 = v4_1 ? 1 : 0;
+					break;
+				default: throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant7.tag)}\` (received \`${variant7}\`) specified for \`BotConfig\``);
+			}
+			const ret = exports1["detect-bot"](ptr0, len0, variant7_0, variant7_1, variant7_2, variant7_3);
+			let variant15;
+			switch (dataView(memory0).getUint8(ret + 0, true)) {
+				case 0:
+					var len9 = dataView(memory0).getInt32(ret + 8, true);
+					var base9 = dataView(memory0).getInt32(ret + 4, true);
+					var result9 = [];
+					for (let i = 0; i < len9; i++) {
+						const base = base9 + i * 8;
+						var ptr8 = dataView(memory0).getInt32(base + 0, true);
+						var len8 = dataView(memory0).getInt32(base + 4, true);
+						var result8 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr8, len8));
+						result9.push(result8);
+					}
+					var len11 = dataView(memory0).getInt32(ret + 16, true);
+					var base11 = dataView(memory0).getInt32(ret + 12, true);
+					var result11 = [];
+					for (let i = 0; i < len11; i++) {
+						const base = base11 + i * 8;
+						var ptr10 = dataView(memory0).getInt32(base + 0, true);
+						var len10 = dataView(memory0).getInt32(base + 4, true);
+						var result10 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr10, len10));
+						result11.push(result10);
+					}
+					var bool12 = dataView(memory0).getUint8(ret + 20, true);
+					var bool13 = dataView(memory0).getUint8(ret + 21, true);
+					variant15 = {
+						tag: "ok",
+						val: {
+							allowed: result9,
+							denied: result11,
+							verified: bool12 == 0 ? false : bool12 == 1 ? true : throwInvalidBool(),
+							spoofed: bool13 == 0 ? false : bool13 == 1 ? true : throwInvalidBool()
+						}
+					};
+					break;
+				case 1:
+					var ptr14 = dataView(memory0).getInt32(ret + 4, true);
+					var len14 = dataView(memory0).getInt32(ret + 8, true);
+					variant15 = {
+						tag: "err",
+						val: utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr14, len14))
+					};
+					break;
+				default: throw new TypeError("invalid variant discriminant for expected");
+			}
+			const retVal = variant15;
+			postReturn0(ret);
+			if (typeof retVal === "object" && retVal.tag === "err") throw new ComponentError(retVal.val);
+			return retVal.val;
+		}
+		function matchFilters(arg0, arg1, arg2, arg3) {
+			var ptr0 = utf8Encode(arg0, realloc0, memory0);
+			var len0 = utf8EncodedLen;
+			var ptr1 = utf8Encode(arg1, realloc0, memory0);
+			var len1 = utf8EncodedLen;
+			var vec3 = arg2;
+			var len3 = vec3.length;
+			var result3 = realloc0(0, 0, 4, len3 * 8);
+			for (let i = 0; i < vec3.length; i++) {
+				const e = vec3[i];
+				const base = result3 + i * 8;
+				var ptr2 = utf8Encode(e, realloc0, memory0);
+				var len2 = utf8EncodedLen;
+				dataView(memory0).setInt32(base + 4, len2, true);
+				dataView(memory0).setInt32(base + 0, ptr2, true);
+			}
+			const ret = exports1["match-filters"](ptr0, len0, ptr1, len1, result3, len3, arg3 ? 1 : 0);
+			let variant10;
+			switch (dataView(memory0).getUint8(ret + 0, true)) {
+				case 0:
+					var bool4 = dataView(memory0).getUint8(ret + 4, true);
+					var len6 = dataView(memory0).getInt32(ret + 12, true);
+					var base6 = dataView(memory0).getInt32(ret + 8, true);
+					var result6 = [];
+					for (let i = 0; i < len6; i++) {
+						const base = base6 + i * 8;
+						var ptr5 = dataView(memory0).getInt32(base + 0, true);
+						var len5 = dataView(memory0).getInt32(base + 4, true);
+						var result5 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr5, len5));
+						result6.push(result5);
+					}
+					var len8 = dataView(memory0).getInt32(ret + 20, true);
+					var base8 = dataView(memory0).getInt32(ret + 16, true);
+					var result8 = [];
+					for (let i = 0; i < len8; i++) {
+						const base = base8 + i * 8;
+						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));
+						result8.push(result7);
+					}
+					variant10 = {
+						tag: "ok",
+						val: {
+							allowed: bool4 == 0 ? false : bool4 == 1 ? true : throwInvalidBool(),
+							matchedExpressions: result6,
+							undeterminedExpressions: result8
+						}
+					};
+					break;
+				case 1:
+					var ptr9 = dataView(memory0).getInt32(ret + 4, true);
+					var len9 = dataView(memory0).getInt32(ret + 8, true);
+					variant10 = {
+						tag: "err",
+						val: utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr9, len9))
+					};
+					break;
+				default: throw new TypeError("invalid variant discriminant for expected");
+			}
+			const retVal = variant10;
+			postReturn1(ret);
+			if (typeof retVal === "object" && retVal.tag === "err") throw new ComponentError(retVal.val);
+			return retVal.val;
+		}
+		function generateFingerprint(arg0, arg1) {
+			var ptr0 = utf8Encode(arg0, realloc0, memory0);
+			var len0 = utf8EncodedLen;
+			var vec2 = arg1;
+			var len2 = vec2.length;
+			var result2 = realloc0(0, 0, 4, len2 * 8);
+			for (let i = 0; i < vec2.length; i++) {
+				const e = vec2[i];
+				const base = result2 + i * 8;
+				var ptr1 = utf8Encode(e, realloc0, memory0);
+				var len1 = utf8EncodedLen;
+				dataView(memory0).setInt32(base + 4, len1, true);
+				dataView(memory0).setInt32(base + 0, ptr1, true);
+			}
+			const ret = exports1["generate-fingerprint"](ptr0, len0, result2, len2);
+			let variant5;
+			switch (dataView(memory0).getUint8(ret + 0, true)) {
+				case 0:
+					var ptr3 = dataView(memory0).getInt32(ret + 4, true);
+					var len3 = dataView(memory0).getInt32(ret + 8, true);
+					variant5 = {
+						tag: "ok",
+						val: utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3))
+					};
+					break;
+				case 1:
+					var ptr4 = dataView(memory0).getInt32(ret + 4, true);
+					var len4 = dataView(memory0).getInt32(ret + 8, true);
+					variant5 = {
+						tag: "err",
+						val: utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4))
+					};
+					break;
+				default: throw new TypeError("invalid variant discriminant for expected");
+			}
+			const retVal = variant5;
+			postReturn2(ret);
+			if (typeof retVal === "object" && retVal.tag === "err") throw new ComponentError(retVal.val);
+			return retVal.val;
+		}
+		function validateCharacteristics(arg0, arg1) {
+			var ptr0 = utf8Encode(arg0, realloc0, memory0);
+			var len0 = utf8EncodedLen;
+			var vec2 = arg1;
+			var len2 = vec2.length;
+			var result2 = realloc0(0, 0, 4, len2 * 8);
+			for (let i = 0; i < vec2.length; i++) {
+				const e = vec2[i];
+				const base = result2 + i * 8;
+				var ptr1 = utf8Encode(e, realloc0, memory0);
+				var len1 = utf8EncodedLen;
+				dataView(memory0).setInt32(base + 4, len1, true);
+				dataView(memory0).setInt32(base + 0, ptr1, true);
+			}
+			const ret = exports1["validate-characteristics"](ptr0, len0, result2, len2);
+			let variant4;
+			switch (dataView(memory0).getUint8(ret + 0, true)) {
+				case 0:
+					variant4 = {
+						tag: "ok",
+						val: void 0
+					};
+					break;
+				case 1:
+					var ptr3 = dataView(memory0).getInt32(ret + 4, true);
+					var len3 = dataView(memory0).getInt32(ret + 8, true);
+					variant4 = {
+						tag: "err",
+						val: utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3))
+					};
+					break;
+				default: throw new TypeError("invalid variant discriminant for expected");
+			}
+			const retVal = variant4;
+			postReturn3(ret);
+			if (typeof retVal === "object" && retVal.tag === "err") throw new ComponentError(retVal.val);
+			return retVal.val;
+		}
+		function isValidEmail(arg0, arg1) {
+			var ptr0 = utf8Encode(arg0, realloc0, memory0);
+			var len0 = utf8EncodedLen;
+			var variant7 = arg1;
+			let variant7_0;
+			let variant7_1;
+			let variant7_2;
+			let variant7_3;
+			let variant7_4;
+			switch (variant7.tag) {
+				case "allow-email-validation-config":
+					var { requireTopLevelDomain: v1_0, allowDomainLiteral: v1_1, allow: v1_2 } = variant7.val;
+					var vec3 = v1_2;
+					var len3 = vec3.length;
+					var result3 = realloc0(0, 0, 4, len3 * 8);
+					for (let i = 0; i < vec3.length; i++) {
+						const e = vec3[i];
+						const base = result3 + i * 8;
+						var ptr2 = utf8Encode(e, realloc0, memory0);
+						var len2 = utf8EncodedLen;
+						dataView(memory0).setInt32(base + 4, len2, true);
+						dataView(memory0).setInt32(base + 0, ptr2, true);
+					}
+					variant7_0 = 0;
+					variant7_1 = v1_0 ? 1 : 0;
+					variant7_2 = v1_1 ? 1 : 0;
+					variant7_3 = result3;
+					variant7_4 = len3;
+					break;
+				case "deny-email-validation-config":
+					var { requireTopLevelDomain: v4_0, allowDomainLiteral: v4_1, deny: v4_2 } = variant7.val;
+					var vec6 = v4_2;
+					var len6 = vec6.length;
+					var result6 = realloc0(0, 0, 4, len6 * 8);
+					for (let i = 0; i < vec6.length; i++) {
+						const e = vec6[i];
+						const base = result6 + i * 8;
+						var ptr5 = utf8Encode(e, realloc0, memory0);
+						var len5 = utf8EncodedLen;
+						dataView(memory0).setInt32(base + 4, len5, true);
+						dataView(memory0).setInt32(base + 0, ptr5, true);
+					}
+					variant7_0 = 1;
+					variant7_1 = v4_0 ? 1 : 0;
+					variant7_2 = v4_1 ? 1 : 0;
+					variant7_3 = result6;
+					variant7_4 = len6;
+					break;
+				default: throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant7.tag)}\` (received \`${variant7}\`) specified for \`EmailValidationConfig\``);
+			}
+			const ret = exports1["is-valid-email"](ptr0, len0, variant7_0, variant7_1, variant7_2, variant7_3, variant7_4);
+			let variant12;
+			switch (dataView(memory0).getUint8(ret + 0, true)) {
+				case 0: {
+					let enum8;
+					switch (dataView(memory0).getUint8(ret + 4, true)) {
+						case 0:
+							enum8 = "valid";
+							break;
+						case 1:
+							enum8 = "invalid";
+							break;
+						default: throw new TypeError("invalid discriminant specified for EmailValidity");
+					}
+					var len10 = dataView(memory0).getInt32(ret + 12, true);
+					var base10 = dataView(memory0).getInt32(ret + 8, true);
+					var result10 = [];
+					for (let i = 0; i < len10; i++) {
+						const base = base10 + i * 8;
+						var ptr9 = dataView(memory0).getInt32(base + 0, true);
+						var len9 = dataView(memory0).getInt32(base + 4, true);
+						var result9 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr9, len9));
+						result10.push(result9);
+					}
+					variant12 = {
+						tag: "ok",
+						val: {
+							validity: enum8,
+							blocked: result10
+						}
+					};
+					break;
+				}
+				case 1:
+					var ptr11 = dataView(memory0).getInt32(ret + 4, true);
+					var len11 = dataView(memory0).getInt32(ret + 8, true);
+					variant12 = {
+						tag: "err",
+						val: utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr11, len11))
+					};
+					break;
+				default: throw new TypeError("invalid variant discriminant for expected");
+			}
+			const retVal = variant12;
+			postReturn4(ret);
+			if (typeof retVal === "object" && retVal.tag === "err") throw new ComponentError(retVal.val);
+			return retVal.val;
+		}
+		function detectSensitiveInfo(arg0, arg1) {
+			var ptr0 = utf8Encode(arg0, realloc0, memory0);
+			var len0 = utf8EncodedLen;
+			var { entities: v1_0, contextWindowSize: v1_1, skipCustomDetect: v1_2 } = arg1;
+			var variant8 = v1_0;
+			let variant8_0;
+			let variant8_1;
+			let variant8_2;
+			switch (variant8.tag) {
+				case "allow":
+					var vec4 = variant8.val;
+					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\``);
+						}
+					}
+					variant8_0 = 0;
+					variant8_1 = result4;
+					variant8_2 = len4;
+					break;
+				case "deny":
+					var vec7 = variant8.val;
+					var len7 = vec7.length;
+					var result7 = realloc0(0, 0, 4, len7 * 12);
+					for (let i = 0; i < vec7.length; i++) {
+						const e = vec7[i];
+						const base = result7 + i * 12;
+						var variant6 = e;
+						switch (variant6.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 = variant6.val;
+								dataView(memory0).setInt8(base + 0, 4, true);
+								var ptr5 = utf8Encode(e, realloc0, memory0);
+								var len5 = utf8EncodedLen;
+								dataView(memory0).setInt32(base + 8, len5, true);
+								dataView(memory0).setInt32(base + 4, ptr5, true);
+								break;
+							}
+							default: throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant6.tag)}\` (received \`${variant6}\`) specified for \`SensitiveInfoEntity\``);
+						}
+					}
+					variant8_0 = 1;
+					variant8_1 = result7;
+					variant8_2 = len7;
+					break;
+				default: throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant8.tag)}\` (received \`${variant8}\`) specified for \`SensitiveInfoEntities\``);
+			}
+			var variant9 = v1_1;
+			let variant9_0;
+			let variant9_1;
+			if (variant9 === null || variant9 === void 0) {
+				variant9_0 = 0;
+				variant9_1 = 0;
+			} else {
+				const e = variant9;
+				variant9_0 = 1;
+				variant9_1 = toUint32(e);
+			}
+			const ret = exports1["detect-sensitive-info"](ptr0, len0, variant8_0, variant8_1, variant8_2, variant9_0, variant9_1, v1_2 ? 1 : 0);
+			var len12 = dataView(memory0).getInt32(ret + 4, true);
+			var base12 = dataView(memory0).getInt32(ret + 0, true);
+			var result12 = [];
+			for (let i = 0; i < len12; i++) {
+				const base = base12 + i * 20;
+				let variant11;
+				switch (dataView(memory0).getUint8(base + 8, true)) {
+					case 0:
+						variant11 = { tag: "email" };
+						break;
+					case 1:
+						variant11 = { tag: "phone-number" };
+						break;
+					case 2:
+						variant11 = { tag: "ip-address" };
+						break;
+					case 3:
+						variant11 = { tag: "credit-card-number" };
+						break;
+					case 4:
+						var ptr10 = dataView(memory0).getInt32(base + 12, true);
+						var len10 = dataView(memory0).getInt32(base + 16, true);
+						variant11 = {
+							tag: "custom",
+							val: utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr10, len10))
+						};
+						break;
+					default: throw new TypeError("invalid variant discriminant for SensitiveInfoEntity");
+				}
+				result12.push({
+					start: dataView(memory0).getInt32(base + 0, true) >>> 0,
+					end: dataView(memory0).getInt32(base + 4, true) >>> 0,
+					identifiedType: variant11
+				});
+			}
+			var len15 = dataView(memory0).getInt32(ret + 12, true);
+			var base15 = dataView(memory0).getInt32(ret + 8, true);
+			var result15 = [];
+			for (let i = 0; i < len15; i++) {
+				const base = base15 + i * 20;
+				let variant14;
+				switch (dataView(memory0).getUint8(base + 8, true)) {
+					case 0:
+						variant14 = { tag: "email" };
+						break;
+					case 1:
+						variant14 = { tag: "phone-number" };
+						break;
+					case 2:
+						variant14 = { tag: "ip-address" };
+						break;
+					case 3:
+						variant14 = { tag: "credit-card-number" };
+						break;
+					case 4:
+						var ptr13 = dataView(memory0).getInt32(base + 12, true);
+						var len13 = dataView(memory0).getInt32(base + 16, true);
+						variant14 = {
+							tag: "custom",
+							val: utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr13, len13))
+						};
+						break;
+					default: throw new TypeError("invalid variant discriminant for SensitiveInfoEntity");
+				}
+				result15.push({
+					start: dataView(memory0).getInt32(base + 0, true) >>> 0,
+					end: dataView(memory0).getInt32(base + 4, true) >>> 0,
+					identifiedType: variant14
+				});
+			}
+			const retVal = {
+				allowed: result12,
+				denied: result15
+			};
+			postReturn5(ret);
+			return retVal;
+		}
+		return {
+			detectBot,
+			detectSensitiveInfo,
+			generateFingerprint,
+			isValidEmail,
+			matchFilters,
+			validateCharacteristics
+		};
+	})();
+	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 };

dist/wasm/interfaces/arcjet-js-req-bot-identifier.d.ts

+//#region src/wasm/interfaces/arcjet-js-req-bot-identifier.d.ts
+declare namespace ArcjetJsReqBotIdentifier {
+  export function detect(request: string): Array<BotEntity>;
+}
+type BotEntity = string;
+//#endregion
+export { ArcjetJsReqBotIdentifier, BotEntity };

dist/wasm/interfac...t-js-req-email-validator-overrides.d.ts

+//#region src/wasm/interfaces/arcjet-js-req-email-validator-overrides.d.ts
+declare namespace ArcjetJsReqEmailValidatorOverrides {
+  export function isFreeEmail(domain: string): ValidatorResponse;
+  export function isDisposableEmail(domain: string): ValidatorResponse;
+  export function hasMxRecords(domain: string): ValidatorResponse;
+  export function hasGravatar(email: string): ValidatorResponse;
+}
+/**
+ * # Variants
+ * 
+ * ## `"yes"`
+ * 
+ * ## `"no"`
+ * 
+ * ## `"unknown"`
+ */
+type ValidatorResponse = 'yes' | 'no' | 'unknown';
+//#endregion
+export { ArcjetJsReqEmailValidatorOverrides, ValidatorResponse };

dist/wasm/interfaces/arcjet-js-req-filter-overrides.d.ts

+//#region src/wasm/interfaces/arcjet-js-req-filter-overrides.d.ts
+declare namespace ArcjetJsReqFilterOverrides {
+  export function ipLookup(ip: string): string | undefined;
+}
+//#endregion
+export { ArcjetJsReqFilterOverrides };

dist/wasm/interfac...q-sensitive-information-identifier.d.ts

+//#region src/wasm/interfaces/arcjet-js-req-sensitive-information-identifier.d.ts
+declare namespace ArcjetJsReqSensitiveInformationIdentifier {
+  export function detect(tokens: Array<string>): Array<SensitiveInfoEntity | 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 { ArcjetJsReqSensitiveInformationIdentifier, SensitiveInfoEntity, SensitiveInfoEntityCreditCardNumber, SensitiveInfoEntityCustom, SensitiveInfoEntityEmail, SensitiveInfoEntityIpAddress, SensitiveInfoEntityPhoneNumber };

dist/wasm/interfaces/arcjet-js-req-verify-bot.d.ts

+//#region src/wasm/interfaces/arcjet-js-req-verify-bot.d.ts
+declare namespace ArcjetJsReqVerifyBot {
+  export function verify(botId: string, ip: string): ValidatorResponse;
+}
+/**
+ * # Variants
+ * 
+ * ## `"verified"`
+ * 
+ * ## `"spoofed"`
+ * 
+ * ## `"unverifiable"`
+ */
+type ValidatorResponse = 'verified' | 'spoofed' | 'unverifiable';
+//#endregion
+export { ArcjetJsReqVerifyBot, ValidatorResponse };

dist/workerd.d.ts

+import { ImportObject as ImportObject$1, instantiate } from "./wasm/arcjet_analyze_js_req.component.js";
+import { BotConfig, BotResult, DetectSensitiveInfoFunction, DetectedSensitiveInfoEntity, EmailValidationConfig, EmailValidationResult, FilterResult, ImportObject, SensitiveInfoEntities, SensitiveInfoEntity, SensitiveInfoResult } from "./types.js";
+
+//#region src/workerd.d.ts
+/**
+* Initialize the generated WebAssembly component.
+*
+* @param coreImports
+*   Things, typically functions, to pass into the component.
+* @returns
+*   Promise that resolves to the initialized component.
+*/
+declare function initializeWasm(coreImports: ImportObject$1): Promise<Awaited<ReturnType<typeof instantiate>> | undefined>;
+//#endregion
+export { type BotConfig, type BotResult, type DetectSensitiveInfoFunction, type DetectedSensitiveInfoEntity, type EmailValidationConfig, type EmailValidationResult, type FilterResult, type ImportObject, type SensitiveInfoEntities, type SensitiveInfoEntity, type SensitiveInfoResult, initializeWasm };

dist/workerd.js

+import { instantiate } from "./wasm/arcjet_analyze_js_req.component.js";
+import componentCoreWasm from "./wasm/arcjet_analyze_js_req.component.core.wasm";
+import componentCore2Wasm from "./wasm/arcjet_analyze_js_req.component.core2.wasm";
+import componentCore3Wasm from "./wasm/arcjet_analyze_js_req.component.core3.wasm";
+//#region src/workerd.ts
+async function moduleFromPath(path) {
+	if (path === "arcjet_analyze_js_req.component.core.wasm") return componentCoreWasm;
+	if (path === "arcjet_analyze_js_req.component.core2.wasm") return componentCore2Wasm;
+	if (path === "arcjet_analyze_js_req.component.core3.wasm") return componentCore3Wasm;
+	throw new Error(`Unknown path: ${path}`);
+}
+/**
+* Initialize the generated WebAssembly component.
+*
+* @param coreImports
+*   Things, typically functions, to pass into the component.
+* @returns
+*   Promise that resolves to the initialized component.
+*/
+async function initializeWasm(coreImports) {
+	try {
+		return instantiate(moduleFromPath, coreImports);
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { initializeWasm };

package.json

 {
   "name": "@arcjet/analyze-wasm",
-  "version": "1.6.1",
+  "version": "1.7.0-rc.0",
   "description": "WebAssembly bindings to Arcjet's local analysis engine",
@@ -14,9 +14,3 @@ "keywords": [
   ],
-  "license": "Apache-2.0",
   "homepage": "https://arcjet.com",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/arcjet/arcjet-js.git",
-    "directory": "analyze-wasm"
-  },
   "bugs": {
@@ -26,2 +20,3 @@ "url": "https://github.com/arcjet/arcjet-js/issues",
   },
+  "license": "Apache-2.0",
   "author": {
@@ -32,48 +27,52 @@ "name": "Arcjet",
   },
-  "engines": {
-    "node": ">=22.21.0 <23 || >=24.5.0"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/arcjet/arcjet-js.git",
+    "directory": "analyze-wasm"
   },
+  "files": [
+    "dist"
+  ],
   "type": "module",
-  "main": "./index.js",
-  "types": "./index.d.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    "edge-light": "./edge-light.js",
-    "workerd": "./workerd.js",
-    "default": "./index.js"
+    ".": {
+      "edge-light": {
+        "types": "./dist/edge-light.d.ts",
+        "default": "./dist/edge-light.js"
+      },
+      "workerd": {
+        "types": "./dist/workerd.d.ts",
+        "default": "./dist/workerd.js"
+      },
+      "default": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./package.json": "./package.json"
   },
-  "files": [
-    "_virtual/",
-    "wasm/",
-    "edge-light.d.ts",
-    "edge-light.js",
-    "index.d.ts",
-    "index.js",
-    "types.d.ts",
-    "types.js",
-    "workerd.d.ts",
-    "workerd.js"
-  ],
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
   "scripts": {
-    "build:jco": "jco transpile --instantiation async --no-wasi-shim --out-dir wasm/ -- wasm/arcjet_analyze_js_req.component.wasm",
-    "build:rollup": "rollup --config rollup.config.js",
-    "build": "npm run build:jco && npm run build:rollup",
-    "lint": "eslint .",
-    "test-api": "node --test -- test/*.test.js",
-    "test-coverage": "node --experimental-test-coverage --test -- test/*.test.js",
-    "test": "npm run build && npm run lint && npm run test-coverage"
+    "build:jco": "jco transpile --instantiation async --no-wasi-shim --out-dir src/wasm/ -- src/wasm/arcjet_analyze_js_req.component.wasm",
+    "build": "npm run build:jco && tsdown",
+    "typecheck": "tsgo --noEmit",
+    "test-api": "node --test -- test/*.test.ts",
+    "test-coverage": "node --experimental-test-coverage --test -- test/*.test.ts",
+    "test": "npm run build && npm run test-coverage"
   },
   "dependencies": {},
   "devDependencies": {
-    "@arcjet/eslint-config": "1.6.1",
-    "@arcjet/rollup-config": "1.6.1",
     "@bytecodealliance/jco": "1.5.0",
-    "@rollup/wasm-node": "4.62.2",
     "@types/node": "22.19.21",
-    "eslint": "9.39.4",
-    "typescript": "5.9.3"
+    "tsdown": "0.22.3",
+    "typescript": "6.0.3"
   },
-  "publishConfig": {
-    "access": "public",
-    "tag": "latest"
+  "engines": {
+    "node": ">=22.21.0 <23 || >=24.5.0"
   }
 }

_virtual/arcjet_analyze_js_req.component.core2.js

-// @generated by wasm2module - DO NOT EDIT
-/* eslint-disable */
-// @ts-nocheck
-
-/**
- * This file contains an Arcjet Wasm binary inlined as a base64
- * [Data URL](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs)
- * with the application/wasm MIME type.
- *
- * This was chosen to save on storage space over inlining the file directly as
- * a Uint8Array, which would take up ~3x the space of the Wasm file. See
- * https://blobfolio.com/2019/better-binary-batter-mixing-base64-and-uint8array/
- * for more details.
- *
- * It is then decoded into an ArrayBuffer to be used directly via WebAssembly's
- * `compile()` function in our entry point file.
- *
- * This is all done to avoid trying to read or bundle the Wasm asset in various
- * ways based on the platform or bundler a user is targeting. One example being
- * that Next.js requires special `asyncWebAssembly` webpack config to load our
- * Wasm file if we don't do this.
- *
- * In the future, we hope to do away with this workaround when all bundlers
- * properly support consistent asset bundling techniques.
- */
-
-const wasmBase64 = "data:application/wasm;base64,AGFzbQEAAAABFQNgA39/fwBgBH9/f38Bf2ACf38BfwMJCAABAAACAgICBAUBcAEICAcsCQEwAAABMQABATIAAgEzAAMBNAAEATUABQE2AAYBNwAHCCRpbXBvcnRzAQAKawgNACAAIAEgAkEAEQAACw8AIAAgASACIANBAREBAAsNACAAIAEgAkECEQAACw0AIAAgASACQQMRAAALCwAgACABQQQRAgALCwAgACABQQURAgALCwAgACABQQYRAgALCwAgACABQQcRAgALAC8JcHJvZHVjZXJzAQxwcm9jZXNzZWQtYnkBDXdpdC1jb21wb25lbnQHMC4yNTEuMA==";
-/**
- * Returns a WebAssembly.Module for an Arcjet Wasm binary, decoded from a base64
- * Data URL.
- */
-// TODO: Switch back to top-level await when our platforms all support it
-async function wasm() {
-  // This uses fetch to decode the wasm data url, but disabling cache so files
-  // larger than 2mb don't fail to parse in the Next.js App Router
-  const wasmDecode = await fetch(wasmBase64, { cache: "no-store" });
-  const buf = await wasmDecode.arrayBuffer();
-  // And then we return it as a WebAssembly.Module
-  return WebAssembly.compile(buf);
-}
-
-export { wasm };

_virtual/arcjet_analyze_js_req.component.core3.js

-// @generated by wasm2module - DO NOT EDIT
-/* eslint-disable */
-// @ts-nocheck
-
-/**
- * This file contains an Arcjet Wasm binary inlined as a base64
- * [Data URL](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs)
- * with the application/wasm MIME type.
- *
- * This was chosen to save on storage space over inlining the file directly as
- * a Uint8Array, which would take up ~3x the space of the Wasm file. See
- * https://blobfolio.com/2019/better-binary-batter-mixing-base64-and-uint8array/
- * for more details.
- *
- * It is then decoded into an ArrayBuffer to be used directly via WebAssembly's
- * `compile()` function in our entry point file.
- *
- * This is all done to avoid trying to read or bundle the Wasm asset in various
- * ways based on the platform or bundler a user is targeting. One example being
- * that Next.js requires special `asyncWebAssembly` webpack config to load our
- * Wasm file if we don't do this.
- *
- * In the future, we hope to do away with this workaround when all bundlers
- * properly support consistent asset bundling techniques.
- */
-
-const wasmBase64 = "data:application/wasm;base64,AGFzbQEAAAABFQNgA39/fwBgBH9/f38Bf2ACf38BfwI4CQABMAAAAAExAAEAATIAAAABMwAAAAE0AAIAATUAAgABNgACAAE3AAIACCRpbXBvcnRzAXABCAgJDgEAQQALCAABAgMEBQYHAC8JcHJvZHVjZXJzAQxwcm9jZXNzZWQtYnkBDXdpdC1jb21wb25lbnQHMC4yNTEuMA==";
-/**
- * Returns a WebAssembly.Module for an Arcjet Wasm binary, decoded from a base64
- * Data URL.
- */
-// TODO: Switch back to top-level await when our platforms all support it
-async function wasm() {
-  // This uses fetch to decode the wasm data url, but disabling cache so files
-  // larger than 2mb don't fail to parse in the Next.js App Router
-  const wasmDecode = await fetch(wasmBase64, { cache: "no-store" });
-  const buf = await wasmDecode.arrayBuffer();
-  // And then we return it as a WebAssembly.Module
-  return WebAssembly.compile(buf);
-}
-
-export { wasm };

edge-light.d.ts

-import type { ImportObject } from "./wasm/arcjet_analyze_js_req.component.js";
-/**
- * Initialize the generated WebAssembly component.
- *
- * @param coreImports
- *   Things, typically functions, to pass into the component.
- * @returns
- *   Promise that resolves to the initialized component.
- */
-export declare function initializeWasm(coreImports: ImportObject): Promise<import("./wasm/arcjet_analyze_js_req.component.js").Root | undefined>;
-export type { BotConfig, BotResult, DetectSensitiveInfoFunction, DetectedSensitiveInfoEntity, EmailValidationConfig, EmailValidationResult, ImportObject, FilterResult, SensitiveInfoEntities, SensitiveInfoEntity, SensitiveInfoResult, } from "./types.js";

edge-light.js

-import { instantiate } from './wasm/arcjet_analyze_js_req.component.js';
-import componentCoreWasm from './wasm/arcjet_analyze_js_req.component.core.wasm?module';
-import componentCore2Wasm from './wasm/arcjet_analyze_js_req.component.core2.wasm?module';
-import componentCore3Wasm from './wasm/arcjet_analyze_js_req.component.core3.wasm?module';
-
-async function moduleFromPath(path) {
-    if (path === "arcjet_analyze_js_req.component.core.wasm") {
-        return componentCoreWasm;
-    }
-    if (path === "arcjet_analyze_js_req.component.core2.wasm") {
-        return componentCore2Wasm;
-    }
-    if (path === "arcjet_analyze_js_req.component.core3.wasm") {
-        return componentCore3Wasm;
-    }
-    throw new Error(`Unknown path: ${path}`);
-}
-/**
- * Initialize the generated WebAssembly component.
- *
- * @param coreImports
- *   Things, typically functions, to pass into the component.
- * @returns
- *   Promise that resolves to the initialized component.
- */
-async function initializeWasm(coreImports) {
-    try {
-        return instantiate(moduleFromPath, coreImports);
-    }
-    catch {
-        return undefined;
-    }
-}
-
-export { initializeWasm };

index.d.ts

-import type { ImportObject } from "./wasm/arcjet_analyze_js_req.component.js";
-/**
- * Initialize the generated WebAssembly component.
- *
- * @param coreImports
- *   Things, typically functions, to pass into the component.
- * @returns
- *   Promise that resolves to the initialized component.
- */
-export declare function initializeWasm(coreImports: ImportObject): Promise<import("./wasm/arcjet_analyze_js_req.component.js").Root | undefined>;
-export type { BotConfig, BotResult, DetectSensitiveInfoFunction, DetectedSensitiveInfoEntity, EmailValidationConfig, EmailValidationResult, ImportObject, FilterResult, SensitiveInfoEntities, SensitiveInfoEntity, SensitiveInfoResult, } from "./types.js";

index.js

-import { instantiate } from './wasm/arcjet_analyze_js_req.component.js';
-import { wasm } from './_virtual/arcjet_analyze_js_req.component.core.js';
-import { wasm as wasm$1 } from './_virtual/arcjet_analyze_js_req.component.core2.js';
-import { wasm as wasm$2 } from './_virtual/arcjet_analyze_js_req.component.core3.js';
-
-// Support `?js` and such:
-//
-/// <reference types="./wasm.js" />
-const componentCoreWasmPromise = wasm();
-const componentCore2WasmPromise = wasm$1();
-const componentCore3WasmPromise = wasm$2();
-async function moduleFromPath(path) {
-    if (path === "arcjet_analyze_js_req.component.core.wasm") {
-        return componentCoreWasmPromise;
-    }
-    if (path === "arcjet_analyze_js_req.component.core2.wasm") {
-        return componentCore2WasmPromise;
-    }
-    if (path === "arcjet_analyze_js_req.component.core3.wasm") {
-        return componentCore3WasmPromise;
-    }
-    // TODO(@wooorm-arcjet): figure out a test case that makes this throw.
-    throw new Error(`Unknown path: ${path}`);
-}
-/**
- * Initialize the generated WebAssembly component.
- *
- * @param coreImports
- *   Things, typically functions, to pass into the component.
- * @returns
- *   Promise that resolves to the initialized component.
- */
-async function initializeWasm(coreImports) {
-    try {
-        // Await the instantiation to catch the failure
-        return instantiate(moduleFromPath, coreImports);
-    }
-    catch {
-        return undefined;
-    }
-}
-
-export { initializeWasm };

types.d.ts

-import type { BotConfig as GeneratedBotConfig, BotResult as GeneratedBotResult, DetectedSensitiveInfoEntity as GeneratedDetectedSensitiveInfoEntity, EmailValidationConfig as GeneratedEmailValidationConfig, EmailValidationResult as GeneratedEmailValidationResult, ImportObject as GeneratedImportObject, FilterResult as GeneratedFilterResult, SensitiveInfoEntities as GeneratedSensitiveInfoEntities, SensitiveInfoEntity as GeneratedSensitiveInfoEntity, SensitiveInfoResult as GeneratedSensitiveInfoResult } from "./wasm/arcjet_analyze_js_req.component.js";
-import type { ArcjetJsReqSensitiveInformationIdentifier } from "./wasm/interfaces/arcjet-js-req-sensitive-information-identifier.js";
-/**
- * Configuration for bot detection.
- * Generated from the WebAssembly component.
- */
-export type BotConfig = GeneratedBotConfig;
-/**
- * Result of bot detection.
- * Generated from the WebAssembly component.
- */
-export type BotResult = GeneratedBotResult;
-/**
- * Function signature for custom entity detection from JavaScript.
- *
- * Generated from the WebAssembly component.
- *
- * This signature corresponds to similar functions from `@arcjet/redact-wasm`
- * and `@arcjet/redact`.
- *
- * @param tokens
- *   Tokens to detect in.
- * @returns
- *   Array of `undefined` for tokens that are not sensitive or a `string` used as
- *   a label for sensitive info.
- */
-export type DetectSensitiveInfoFunction = typeof ArcjetJsReqSensitiveInformationIdentifier.detect;
-/**
- * Span of sensitive info,
- * with `start` and `end` fields relating to the input value,
- * and an `identifiedType` tag for its kind.
- * Generated from the WebAssembly component.
- */
-export type DetectedSensitiveInfoEntity = GeneratedDetectedSensitiveInfoEntity;
-/**
- * Configuration for email validation.
- * Generated from the WebAssembly component.
- */
-export type EmailValidationConfig = GeneratedEmailValidationConfig;
-/**
- * Result of email validation.
- * Generated from the WebAssembly component.
- */
-export type EmailValidationResult = GeneratedEmailValidationResult;
-/**
- * Result of a filter call.
- * Generated from the WebAssembly component.
- */
-export type FilterResult = GeneratedFilterResult;
-/**
- * Object representing the import structure.
- * These are things that can be passed *into* the WebAssembly.
- * Generated from the WebAssembly component.
- */
-export type ImportObject = GeneratedImportObject;
-/**
- * Configuration for sensitive info detection.
- * Generated from the WebAssembly component.
- */
-export type SensitiveInfoEntities = GeneratedSensitiveInfoEntities;
-/**
- * Kind of sensitive info.
- * Consists of each of the tags that can detect be detected natively
- * and a custom tag for values detected from JavaScript.
- * Generated from the WebAssembly component.
- */
-export type SensitiveInfoEntity = GeneratedSensitiveInfoEntity;
-/**
- * Result of sensitive info detection.
- * Generated from the WebAssembly component.
- */
-export type SensitiveInfoResult = GeneratedSensitiveInfoResult;
-export {};

types.js

-

wasm/arcjet_analyze_js_req.component.d.ts

-import type { SensitiveInfoEntity } from './interfaces/arcjet-js-req-sensitive-information-identifier.js';
-export { SensitiveInfoEntity };
-import type { BotEntity } from './interfaces/arcjet-js-req-bot-identifier.js';
-export { BotEntity };
-/**
-* # Variants
-* 
-* ## `"valid"`
-* 
-* ## `"invalid"`
-*/
-export type EmailValidity = 'valid' | 'invalid';
-export interface EmailValidationResult {
-  validity: EmailValidity,
-  blocked: Array<string>,
-}
-export interface AllowEmailValidationConfig {
-  requireTopLevelDomain: boolean,
-  allowDomainLiteral: boolean,
-  allow: Array<string>,
-}
-export interface DenyEmailValidationConfig {
-  requireTopLevelDomain: boolean,
-  allowDomainLiteral: boolean,
-  deny: Array<string>,
-}
-export type EmailValidationConfig = EmailValidationConfigAllowEmailValidationConfig | EmailValidationConfigDenyEmailValidationConfig;
-export interface EmailValidationConfigAllowEmailValidationConfig {
-  tag: 'allow-email-validation-config',
-  val: AllowEmailValidationConfig,
-}
-export interface EmailValidationConfigDenyEmailValidationConfig {
-  tag: 'deny-email-validation-config',
-  val: DenyEmailValidationConfig,
-}
-export type SensitiveInfoEntities = SensitiveInfoEntitiesAllow | SensitiveInfoEntitiesDeny;
-export interface SensitiveInfoEntitiesAllow {
-  tag: 'allow',
-  val: Array<SensitiveInfoEntity>,
-}
-export interface SensitiveInfoEntitiesDeny {
-  tag: 'deny',
-  val: Array<SensitiveInfoEntity>,
-}
-export interface SensitiveInfoConfig {
-  entities: SensitiveInfoEntities,
-  contextWindowSize?: number,
-  skipCustomDetect: boolean,
-}
-export interface DetectedSensitiveInfoEntity {
-  start: number,
-  end: number,
-  identifiedType: SensitiveInfoEntity,
-}
-export interface SensitiveInfoResult {
-  allowed: Array<DetectedSensitiveInfoEntity>,
-  denied: Array<DetectedSensitiveInfoEntity>,
-}
-export interface AllowedBotConfig {
-  entities: Array<BotEntity>,
-  skipCustomDetect: boolean,
-}
-export interface DeniedBotConfig {
-  entities: Array<BotEntity>,
-  skipCustomDetect: boolean,
-}
-export type BotConfig = BotConfigAllowedBotConfig | BotConfigDeniedBotConfig;
-export interface BotConfigAllowedBotConfig {
-  tag: 'allowed-bot-config',
-  val: AllowedBotConfig,
-}
-export interface BotConfigDeniedBotConfig {
-  tag: 'denied-bot-config',
-  val: DeniedBotConfig,
-}
-export interface BotResult {
-  allowed: Array<BotEntity>,
-  denied: Array<BotEntity>,
-  verified: boolean,
-  spoofed: boolean,
-}
-export interface FilterResult {
-  allowed: boolean,
-  matchedExpressions: Array<string>,
-  undeterminedExpressions: Array<string>,
-}
-import { ArcjetJsReqBotIdentifier } from './interfaces/arcjet-js-req-bot-identifier.js';
-import { ArcjetJsReqEmailValidatorOverrides } from './interfaces/arcjet-js-req-email-validator-overrides.js';
-import { ArcjetJsReqFilterOverrides } from './interfaces/arcjet-js-req-filter-overrides.js';
-import { ArcjetJsReqSensitiveInformationIdentifier } from './interfaces/arcjet-js-req-sensitive-information-identifier.js';
-import { ArcjetJsReqVerifyBot } from './interfaces/arcjet-js-req-verify-bot.js';
-export interface ImportObject {
-  'arcjet:js-req/bot-identifier': typeof ArcjetJsReqBotIdentifier,
-  'arcjet:js-req/email-validator-overrides': typeof ArcjetJsReqEmailValidatorOverrides,
-  'arcjet:js-req/filter-overrides': typeof ArcjetJsReqFilterOverrides,
-  'arcjet:js-req/sensitive-information-identifier': typeof ArcjetJsReqSensitiveInformationIdentifier,
-  'arcjet:js-req/verify-bot': typeof ArcjetJsReqVerifyBot,
-}
-export interface Root {
-  detectBot(request: string, options: BotConfig): BotResult,
-  matchFilters(request: string, localFields: string, expressions: Array<string>, allowIfMatch: boolean): FilterResult,
-  generateFingerprint(request: string, characteristics: Array<string>): string,
-  validateCharacteristics(request: string, characteristics: Array<string>): void,
-  isValidEmail(candidate: string, options: EmailValidationConfig): EmailValidationResult,
-  detectSensitiveInfo(content: string, options: SensitiveInfoConfig): SensitiveInfoResult,
-}
-
-/**
-* 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.
-*/
-export function instantiate(
-getCoreModule: (path: string) => WebAssembly.Module,
-imports: ImportObject,
-instantiateCore?: (module: WebAssembly.Module, imports: Record<string, any>) => WebAssembly.Instance
-): Root;
-export 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>;
-

wasm/arcjet_analyze_js_req.component.js

-function instantiate(getCoreModule, imports, instantiateCore = WebAssembly.instantiate) {
-  
-  class ComponentError extends Error {
-    constructor (value) {
-      const enumerable = typeof value !== 'string';
-      super(enumerable ? `${String(value)} (see error.payload)` : value);
-      Object.defineProperty(this, 'payload', { value, enumerable });
-    }
-  }
-  
-  let dv = new DataView(new ArrayBuffer());
-  const dataView = mem => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
-  
-  function throwInvalidBool() {
-    throw new TypeError('invalid variant discriminant for bool');
-  }
-  
-  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_js_req.component.core.wasm');
-  const module1 = getCoreModule('arcjet_analyze_js_req.component.core2.wasm');
-  const module2 = getCoreModule('arcjet_analyze_js_req.component.core3.wasm');
-  
-  const { detect } = imports['arcjet:js-req/bot-identifier'];
-  const { hasGravatar, hasMxRecords, isDisposableEmail, isFreeEmail } = imports['arcjet:js-req/email-validator-overrides'];
-  const { ipLookup } = imports['arcjet:js-req/filter-overrides'];
-  const { detect: detect$1 } = imports['arcjet:js-req/sensitive-information-identifier'];
-  const { verify } = imports['arcjet:js-req/verify-bot'];
-  let gen = (function* init () {
-    let exports0;
-    let exports1;
-    let memory0;
-    let realloc0;
-    
-    function trampoline0(arg0, arg1, arg2) {
-      var ptr0 = arg0;
-      var len0 = arg1;
-      var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
-      const ret = detect(result0);
-      var vec2 = ret;
-      var len2 = vec2.length;
-      var result2 = realloc0(0, 0, 4, len2 * 8);
-      for (let i = 0; i < vec2.length; i++) {
-        const e = vec2[i];
-        const base = result2 + i * 8;var ptr1 = utf8Encode(e, realloc0, memory0);
-        var len1 = utf8EncodedLen;
-        dataView(memory0).setInt32(base + 4, len1, true);
-        dataView(memory0).setInt32(base + 0, ptr1, true);
-      }
-      dataView(memory0).setInt32(arg2 + 4, len2, true);
-      dataView(memory0).setInt32(arg2 + 0, result2, true);
-    }
-    
-    function trampoline1(arg0, arg1, arg2, arg3) {
-      var ptr0 = arg0;
-      var len0 = arg1;
-      var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
-      var ptr1 = arg2;
-      var len1 = arg3;
-      var result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
-      const ret = verify(result0, result1);
-      var val2 = ret;
-      let enum2;
-      switch (val2) {
-        case 'verified': {
-          enum2 = 0;
-          break;
-        }
-        case 'spoofed': {
-          enum2 = 1;
-          break;
-        }
-        case 'unverifiable': {
-          enum2 = 2;
-          break;
-        }
-        default: {
-          if ((ret) instanceof Error) {
-            console.error(ret);
-          }
-          
-          throw new TypeError(`"${val2}" is not one of the cases of validator-response`);
-        }
-      }
-      return enum2;
-    }
-    
-    function trampoline2(arg0, arg1, arg2) {
-      var ptr0 = arg0;
-      var len0 = arg1;
-      var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
-      const ret = ipLookup(result0);
-      var variant2 = ret;
-      if (variant2 === null || variant2=== undefined) {
-        dataView(memory0).setInt8(arg2 + 0, 0, true);
-      } else {
-        const e = variant2;
-        dataView(memory0).setInt8(arg2 + 0, 1, true);
-        var ptr1 = utf8Encode(e, realloc0, memory0);
-        var len1 = utf8EncodedLen;
-        dataView(memory0).setInt32(arg2 + 8, len1, true);
-        dataView(memory0).setInt32(arg2 + 4, ptr1, true);
-      }
-    }
-    
-    function trampoline3(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);
-      }
-      const ret = detect$1(result1);
-      var vec5 = ret;
-      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=== undefined) {
-          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 trampoline4(arg0, arg1) {
-      var ptr0 = arg0;
-      var len0 = arg1;
-      var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
-      const ret = isFreeEmail(result0);
-      var val1 = ret;
-      let enum1;
-      switch (val1) {
-        case 'yes': {
-          enum1 = 0;
-          break;
-        }
-        case 'no': {
-          enum1 = 1;
-          break;
-        }
-        case 'unknown': {
-          enum1 = 2;
-          break;
-        }
-        default: {
-          if ((ret) instanceof Error) {
-            console.error(ret);
-          }
-          
-          throw new TypeError(`"${val1}" is not one of the cases of validator-response`);
-        }
-      }
-      return enum1;
-    }
-    
-    function trampoline5(arg0, arg1) {
-      var ptr0 = arg0;
-      var len0 = arg1;
-      var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
-      const ret = isDisposableEmail(result0);
-      var val1 = ret;
-      let enum1;
-      switch (val1) {
-        case 'yes': {
-          enum1 = 0;
-          break;
-        }
-        case 'no': {
-          enum1 = 1;
-          break;
-        }
-        case 'unknown': {
-          enum1 = 2;
-          break;
-        }
-        default: {
-          if ((ret) instanceof Error) {
-            console.error(ret);
-          }
-          
-          throw new TypeError(`"${val1}" is not one of the cases of validator-response`);
-        }
-      }
-      return enum1;
-    }
-    
-    function trampoline6(arg0, arg1) {
-      var ptr0 = arg0;
-      var len0 = arg1;
-      var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
-      const ret = hasMxRecords(result0);
-      var val1 = ret;
-      let enum1;
-      switch (val1) {
-        case 'yes': {
-          enum1 = 0;
-          break;
-        }
-        case 'no': {
-          enum1 = 1;
-          break;
-        }
-        case 'unknown': {
-          enum1 = 2;
-          break;
-        }
-        default: {
-          if ((ret) instanceof Error) {
-            console.error(ret);
-          }
-          
-          throw new TypeError(`"${val1}" is not one of the cases of validator-response`);
-        }
-      }
-      return enum1;
-    }
-    
-    function trampoline7(arg0, arg1) {
-      var ptr0 = arg0;
-      var len0 = arg1;
-      var result0 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr0, len0));
-      const ret = hasGravatar(result0);
-      var val1 = ret;
-      let enum1;
-      switch (val1) {
-        case 'yes': {
-          enum1 = 0;
-          break;
-        }
-        case 'no': {
-          enum1 = 1;
-          break;
-        }
-        case 'unknown': {
-          enum1 = 2;
-          break;
-        }
-        default: {
-          if ((ret) instanceof Error) {
-            console.error(ret);
-          }
-          
-          throw new TypeError(`"${val1}" is not one of the cases of validator-response`);
-        }
-      }
-      return enum1;
-    }
-    let exports2;
-    let postReturn0;
-    let postReturn1;
-    let postReturn2;
-    let postReturn3;
-    let postReturn4;
-    let postReturn5;
-    Promise.all([module0, module1, module2]).catch(() => {});
-    ({ exports: exports0 } = yield instantiateCore(yield module1));
-    ({ exports: exports1 } = yield instantiateCore(yield module0, {
-      'arcjet:js-req/bot-identifier': {
-        detect: exports0['0'],
-      },
-      'arcjet:js-req/email-validator-overrides': {
-        'has-gravatar': exports0['7'],
-        'has-mx-records': exports0['6'],
-        'is-disposable-email': exports0['5'],
-        'is-free-email': exports0['4'],
-      },
-      'arcjet:js-req/filter-overrides': {
-        'ip-lookup': exports0['2'],
-      },
-      'arcjet:js-req/sensitive-information-identifier': {
-        detect: exports0['3'],
-      },
-      'arcjet:js-req/verify-bot': {
-        verify: exports0['1'],
-      },
-    }));
-    memory0 = exports1.memory;
-    realloc0 = exports1.cabi_realloc;
-    ({ exports: exports2 } = yield instantiateCore(yield module2, {
-      '': {
-        $imports: exports0.$imports,
-        '0': trampoline0,
-        '1': trampoline1,
-        '2': trampoline2,
-        '3': trampoline3,
-        '4': trampoline4,
-        '5': trampoline5,
-        '6': trampoline6,
-        '7': trampoline7,
-      },
-    }));
-    postReturn0 = exports1['cabi_post_detect-bot'];
-    postReturn1 = exports1['cabi_post_match-filters'];
-    postReturn2 = exports1['cabi_post_generate-fingerprint'];
-    postReturn3 = exports1['cabi_post_validate-characteristics'];
-    postReturn4 = exports1['cabi_post_is-valid-email'];
-    postReturn5 = exports1['cabi_post_detect-sensitive-info'];
-    
-    function detectBot(arg0, arg1) {
-      var ptr0 = utf8Encode(arg0, realloc0, memory0);
-      var len0 = utf8EncodedLen;
-      var variant7 = arg1;
-      let variant7_0;
-      let variant7_1;
-      let variant7_2;
-      let variant7_3;
-      switch (variant7.tag) {
-        case 'allowed-bot-config': {
-          const e = variant7.val;
-          var {entities: v1_0, skipCustomDetect: v1_1 } = e;
-          var vec3 = v1_0;
-          var len3 = vec3.length;
-          var result3 = realloc0(0, 0, 4, len3 * 8);
-          for (let i = 0; i < vec3.length; i++) {
-            const e = vec3[i];
-            const base = result3 + i * 8;var ptr2 = utf8Encode(e, realloc0, memory0);
-            var len2 = utf8EncodedLen;
-            dataView(memory0).setInt32(base + 4, len2, true);
-            dataView(memory0).setInt32(base + 0, ptr2, true);
-          }
-          variant7_0 = 0;
-          variant7_1 = result3;
-          variant7_2 = len3;
-          variant7_3 = v1_1 ? 1 : 0;
-          break;
-        }
-        case 'denied-bot-config': {
-          const e = variant7.val;
-          var {entities: v4_0, skipCustomDetect: v4_1 } = e;
-          var vec6 = v4_0;
-          var len6 = vec6.length;
-          var result6 = realloc0(0, 0, 4, len6 * 8);
-          for (let i = 0; i < vec6.length; i++) {
-            const e = vec6[i];
-            const base = result6 + i * 8;var ptr5 = utf8Encode(e, realloc0, memory0);
-            var len5 = utf8EncodedLen;
-            dataView(memory0).setInt32(base + 4, len5, true);
-            dataView(memory0).setInt32(base + 0, ptr5, true);
-          }
-          variant7_0 = 1;
-          variant7_1 = result6;
-          variant7_2 = len6;
-          variant7_3 = v4_1 ? 1 : 0;
-          break;
-        }
-        default: {
-          throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant7.tag)}\` (received \`${variant7}\`) specified for \`BotConfig\``);
-        }
-      }
-      const ret = exports1['detect-bot'](ptr0, len0, variant7_0, variant7_1, variant7_2, variant7_3);
-      let variant15;
-      switch (dataView(memory0).getUint8(ret + 0, true)) {
-        case 0: {
-          var len9 = dataView(memory0).getInt32(ret + 8, true);
-          var base9 = dataView(memory0).getInt32(ret + 4, true);
-          var result9 = [];
-          for (let i = 0; i < len9; i++) {
-            const base = base9 + i * 8;
-            var ptr8 = dataView(memory0).getInt32(base + 0, true);
-            var len8 = dataView(memory0).getInt32(base + 4, true);
-            var result8 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr8, len8));
-            result9.push(result8);
-          }
-          var len11 = dataView(memory0).getInt32(ret + 16, true);
-          var base11 = dataView(memory0).getInt32(ret + 12, true);
-          var result11 = [];
-          for (let i = 0; i < len11; i++) {
-            const base = base11 + i * 8;
-            var ptr10 = dataView(memory0).getInt32(base + 0, true);
-            var len10 = dataView(memory0).getInt32(base + 4, true);
-            var result10 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr10, len10));
-            result11.push(result10);
-          }
-          var bool12 = dataView(memory0).getUint8(ret + 20, true);
-          var bool13 = dataView(memory0).getUint8(ret + 21, true);
-          variant15= {
-            tag: 'ok',
-            val: {
-              allowed: result9,
-              denied: result11,
-              verified: bool12 == 0 ? false : (bool12 == 1 ? true : throwInvalidBool()),
-              spoofed: bool13 == 0 ? false : (bool13 == 1 ? true : throwInvalidBool()),
-            }
-          };
-          break;
-        }
-        case 1: {
-          var ptr14 = dataView(memory0).getInt32(ret + 4, true);
-          var len14 = dataView(memory0).getInt32(ret + 8, true);
-          var result14 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr14, len14));
-          variant15= {
-            tag: 'err',
-            val: result14
-          };
-          break;
-        }
-        default: {
-          throw new TypeError('invalid variant discriminant for expected');
-        }
-      }
-      const retVal = variant15;
-      postReturn0(ret);
-      if (typeof retVal === 'object' && retVal.tag === 'err') {
-        throw new ComponentError(retVal.val);
-      }
-      return retVal.val;
-    }
-    
-    function matchFilters(arg0, arg1, arg2, arg3) {
-      var ptr0 = utf8Encode(arg0, realloc0, memory0);
-      var len0 = utf8EncodedLen;
-      var ptr1 = utf8Encode(arg1, realloc0, memory0);
-      var len1 = utf8EncodedLen;
-      var vec3 = arg2;
-      var len3 = vec3.length;
-      var result3 = realloc0(0, 0, 4, len3 * 8);
-      for (let i = 0; i < vec3.length; i++) {
-        const e = vec3[i];
-        const base = result3 + i * 8;var ptr2 = utf8Encode(e, realloc0, memory0);
-        var len2 = utf8EncodedLen;
-        dataView(memory0).setInt32(base + 4, len2, true);
-        dataView(memory0).setInt32(base + 0, ptr2, true);
-      }
-      const ret = exports1['match-filters'](ptr0, len0, ptr1, len1, result3, len3, arg3 ? 1 : 0);
-      let variant10;
-      switch (dataView(memory0).getUint8(ret + 0, true)) {
-        case 0: {
-          var bool4 = dataView(memory0).getUint8(ret + 4, true);
-          var len6 = dataView(memory0).getInt32(ret + 12, true);
-          var base6 = dataView(memory0).getInt32(ret + 8, true);
-          var result6 = [];
-          for (let i = 0; i < len6; i++) {
-            const base = base6 + i * 8;
-            var ptr5 = dataView(memory0).getInt32(base + 0, true);
-            var len5 = dataView(memory0).getInt32(base + 4, true);
-            var result5 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr5, len5));
-            result6.push(result5);
-          }
-          var len8 = dataView(memory0).getInt32(ret + 20, true);
-          var base8 = dataView(memory0).getInt32(ret + 16, true);
-          var result8 = [];
-          for (let i = 0; i < len8; i++) {
-            const base = base8 + i * 8;
-            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));
-            result8.push(result7);
-          }
-          variant10= {
-            tag: 'ok',
-            val: {
-              allowed: bool4 == 0 ? false : (bool4 == 1 ? true : throwInvalidBool()),
-              matchedExpressions: result6,
-              undeterminedExpressions: result8,
-            }
-          };
-          break;
-        }
-        case 1: {
-          var ptr9 = dataView(memory0).getInt32(ret + 4, true);
-          var len9 = dataView(memory0).getInt32(ret + 8, true);
-          var result9 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr9, len9));
-          variant10= {
-            tag: 'err',
-            val: result9
-          };
-          break;
-        }
-        default: {
-          throw new TypeError('invalid variant discriminant for expected');
-        }
-      }
-      const retVal = variant10;
-      postReturn1(ret);
-      if (typeof retVal === 'object' && retVal.tag === 'err') {
-        throw new ComponentError(retVal.val);
-      }
-      return retVal.val;
-    }
-    
-    function generateFingerprint(arg0, arg1) {
-      var ptr0 = utf8Encode(arg0, realloc0, memory0);
-      var len0 = utf8EncodedLen;
-      var vec2 = arg1;
-      var len2 = vec2.length;
-      var result2 = realloc0(0, 0, 4, len2 * 8);
-      for (let i = 0; i < vec2.length; i++) {
-        const e = vec2[i];
-        const base = result2 + i * 8;var ptr1 = utf8Encode(e, realloc0, memory0);
-        var len1 = utf8EncodedLen;
-        dataView(memory0).setInt32(base + 4, len1, true);
-        dataView(memory0).setInt32(base + 0, ptr1, true);
-      }
-      const ret = exports1['generate-fingerprint'](ptr0, len0, result2, len2);
-      let variant5;
-      switch (dataView(memory0).getUint8(ret + 0, true)) {
-        case 0: {
-          var ptr3 = dataView(memory0).getInt32(ret + 4, true);
-          var len3 = dataView(memory0).getInt32(ret + 8, true);
-          var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
-          variant5= {
-            tag: 'ok',
-            val: result3
-          };
-          break;
-        }
-        case 1: {
-          var ptr4 = dataView(memory0).getInt32(ret + 4, true);
-          var len4 = dataView(memory0).getInt32(ret + 8, true);
-          var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
-          variant5= {
-            tag: 'err',
-            val: result4
-          };
-          break;
-        }
-        default: {
-          throw new TypeError('invalid variant discriminant for expected');
-        }
-      }
-      const retVal = variant5;
-      postReturn2(ret);
-      if (typeof retVal === 'object' && retVal.tag === 'err') {
-        throw new ComponentError(retVal.val);
-      }
-      return retVal.val;
-    }
-    
-    function validateCharacteristics(arg0, arg1) {
-      var ptr0 = utf8Encode(arg0, realloc0, memory0);
-      var len0 = utf8EncodedLen;
-      var vec2 = arg1;
-      var len2 = vec2.length;
-      var result2 = realloc0(0, 0, 4, len2 * 8);
-      for (let i = 0; i < vec2.length; i++) {
-        const e = vec2[i];
-        const base = result2 + i * 8;var ptr1 = utf8Encode(e, realloc0, memory0);
-        var len1 = utf8EncodedLen;
-        dataView(memory0).setInt32(base + 4, len1, true);
-        dataView(memory0).setInt32(base + 0, ptr1, true);
-      }
-      const ret = exports1['validate-characteristics'](ptr0, len0, result2, len2);
-      let variant4;
-      switch (dataView(memory0).getUint8(ret + 0, true)) {
-        case 0: {
-          variant4= {
-            tag: 'ok',
-            val: undefined
-          };
-          break;
-        }
-        case 1: {
-          var ptr3 = dataView(memory0).getInt32(ret + 4, true);
-          var len3 = dataView(memory0).getInt32(ret + 8, true);
-          var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
-          variant4= {
-            tag: 'err',
-            val: result3
-          };
-          break;
-        }
-        default: {
-          throw new TypeError('invalid variant discriminant for expected');
-        }
-      }
-      const retVal = variant4;
-      postReturn3(ret);
-      if (typeof retVal === 'object' && retVal.tag === 'err') {
-        throw new ComponentError(retVal.val);
-      }
-      return retVal.val;
-    }
-    
-    function isValidEmail(arg0, arg1) {
-      var ptr0 = utf8Encode(arg0, realloc0, memory0);
-      var len0 = utf8EncodedLen;
-      var variant7 = arg1;
-      let variant7_0;
-      let variant7_1;
-      let variant7_2;
-      let variant7_3;
-      let variant7_4;
-      switch (variant7.tag) {
-        case 'allow-email-validation-config': {
-          const e = variant7.val;
-          var {requireTopLevelDomain: v1_0, allowDomainLiteral: v1_1, allow: v1_2 } = e;
-          var vec3 = v1_2;
-          var len3 = vec3.length;
-          var result3 = realloc0(0, 0, 4, len3 * 8);
-          for (let i = 0; i < vec3.length; i++) {
-            const e = vec3[i];
-            const base = result3 + i * 8;var ptr2 = utf8Encode(e, realloc0, memory0);
-            var len2 = utf8EncodedLen;
-            dataView(memory0).setInt32(base + 4, len2, true);
-            dataView(memory0).setInt32(base + 0, ptr2, true);
-          }
-          variant7_0 = 0;
-          variant7_1 = v1_0 ? 1 : 0;
-          variant7_2 = v1_1 ? 1 : 0;
-          variant7_3 = result3;
-          variant7_4 = len3;
-          break;
-        }
-        case 'deny-email-validation-config': {
-          const e = variant7.val;
-          var {requireTopLevelDomain: v4_0, allowDomainLiteral: v4_1, deny: v4_2 } = e;
-          var vec6 = v4_2;
-          var len6 = vec6.length;
-          var result6 = realloc0(0, 0, 4, len6 * 8);
-          for (let i = 0; i < vec6.length; i++) {
-            const e = vec6[i];
-            const base = result6 + i * 8;var ptr5 = utf8Encode(e, realloc0, memory0);
-            var len5 = utf8EncodedLen;
-            dataView(memory0).setInt32(base + 4, len5, true);
-            dataView(memory0).setInt32(base + 0, ptr5, true);
-          }
-          variant7_0 = 1;
-          variant7_1 = v4_0 ? 1 : 0;
-          variant7_2 = v4_1 ? 1 : 0;
-          variant7_3 = result6;
-          variant7_4 = len6;
-          break;
-        }
-        default: {
-          throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant7.tag)}\` (received \`${variant7}\`) specified for \`EmailValidationConfig\``);
-        }
-      }
-      const ret = exports1['is-valid-email'](ptr0, len0, variant7_0, variant7_1, variant7_2, variant7_3, variant7_4);
-      let variant12;
-      switch (dataView(memory0).getUint8(ret + 0, true)) {
-        case 0: {
-          let enum8;
-          switch (dataView(memory0).getUint8(ret + 4, true)) {
-            case 0: {
-              enum8 = 'valid';
-              break;
-            }
-            case 1: {
-              enum8 = 'invalid';
-              break;
-            }
-            default: {
-              throw new TypeError('invalid discriminant specified for EmailValidity');
-            }
-          }
-          var len10 = dataView(memory0).getInt32(ret + 12, true);
-          var base10 = dataView(memory0).getInt32(ret + 8, true);
-          var result10 = [];
-          for (let i = 0; i < len10; i++) {
-            const base = base10 + i * 8;
-            var ptr9 = dataView(memory0).getInt32(base + 0, true);
-            var len9 = dataView(memory0).getInt32(base + 4, true);
-            var result9 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr9, len9));
-            result10.push(result9);
-          }
-          variant12= {
-            tag: 'ok',
-            val: {
-              validity: enum8,
-              blocked: result10,
-            }
-          };
-          break;
-        }
-        case 1: {
-          var ptr11 = dataView(memory0).getInt32(ret + 4, true);
-          var len11 = dataView(memory0).getInt32(ret + 8, true);
-          var result11 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr11, len11));
-          variant12= {
-            tag: 'err',
-            val: result11
-          };
-          break;
-        }
-        default: {
-          throw new TypeError('invalid variant discriminant for expected');
-        }
-      }
-      const retVal = variant12;
-      postReturn4(ret);
-      if (typeof retVal === 'object' && retVal.tag === 'err') {
-        throw new ComponentError(retVal.val);
-      }
-      return retVal.val;
-    }
-    
-    function detectSensitiveInfo(arg0, arg1) {
-      var ptr0 = utf8Encode(arg0, realloc0, memory0);
-      var len0 = utf8EncodedLen;
-      var {entities: v1_0, contextWindowSize: v1_1, skipCustomDetect: v1_2 } = arg1;
-      var variant8 = v1_0;
-      let variant8_0;
-      let variant8_1;
-      let variant8_2;
-      switch (variant8.tag) {
-        case 'allow': {
-          const e = variant8.val;
-          var vec4 = e;
-          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\``);
-              }
-            }
-          }
-          variant8_0 = 0;
-          variant8_1 = result4;
-          variant8_2 = len4;
-          break;
-        }
-        case 'deny': {
-          const e = variant8.val;
-          var vec7 = e;
-          var len7 = vec7.length;
-          var result7 = realloc0(0, 0, 4, len7 * 12);
-          for (let i = 0; i < vec7.length; i++) {
-            const e = vec7[i];
-            const base = result7 + i * 12;var variant6 = e;
-            switch (variant6.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 = variant6.val;
-                dataView(memory0).setInt8(base + 0, 4, true);
-                var ptr5 = utf8Encode(e, realloc0, memory0);
-                var len5 = utf8EncodedLen;
-                dataView(memory0).setInt32(base + 8, len5, true);
-                dataView(memory0).setInt32(base + 4, ptr5, true);
-                break;
-              }
-              default: {
-                throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant6.tag)}\` (received \`${variant6}\`) specified for \`SensitiveInfoEntity\``);
-              }
-            }
-          }
-          variant8_0 = 1;
-          variant8_1 = result7;
-          variant8_2 = len7;
-          break;
-        }
-        default: {
-          throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant8.tag)}\` (received \`${variant8}\`) specified for \`SensitiveInfoEntities\``);
-        }
-      }
-      var variant9 = v1_1;
-      let variant9_0;
-      let variant9_1;
-      if (variant9 === null || variant9=== undefined) {
-        variant9_0 = 0;
-        variant9_1 = 0;
-      } else {
-        const e = variant9;
-        variant9_0 = 1;
-        variant9_1 = toUint32(e);
-      }
-      const ret = exports1['detect-sensitive-info'](ptr0, len0, variant8_0, variant8_1, variant8_2, variant9_0, variant9_1, v1_2 ? 1 : 0);
-      var len12 = dataView(memory0).getInt32(ret + 4, true);
-      var base12 = dataView(memory0).getInt32(ret + 0, true);
-      var result12 = [];
-      for (let i = 0; i < len12; i++) {
-        const base = base12 + i * 20;
-        let variant11;
-        switch (dataView(memory0).getUint8(base + 8, true)) {
-          case 0: {
-            variant11= {
-              tag: 'email',
-            };
-            break;
-          }
-          case 1: {
-            variant11= {
-              tag: 'phone-number',
-            };
-            break;
-          }
-          case 2: {
-            variant11= {
-              tag: 'ip-address',
-            };
-            break;
-          }
-          case 3: {
-            variant11= {
-              tag: 'credit-card-number',
-            };
-            break;
-          }
-          case 4: {
-            var ptr10 = dataView(memory0).getInt32(base + 12, true);
-            var len10 = dataView(memory0).getInt32(base + 16, true);
-            var result10 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr10, len10));
-            variant11= {
-              tag: 'custom',
-              val: result10
-            };
-            break;
-          }
-          default: {
-            throw new TypeError('invalid variant discriminant for SensitiveInfoEntity');
-          }
-        }
-        result12.push({
-          start: dataView(memory0).getInt32(base + 0, true) >>> 0,
-          end: dataView(memory0).getInt32(base + 4, true) >>> 0,
-          identifiedType: variant11,
-        });
-      }
-      var len15 = dataView(memory0).getInt32(ret + 12, true);
-      var base15 = dataView(memory0).getInt32(ret + 8, true);
-      var result15 = [];
-      for (let i = 0; i < len15; i++) {
-        const base = base15 + i * 20;
-        let variant14;
-        switch (dataView(memory0).getUint8(base + 8, true)) {
-          case 0: {
-            variant14= {
-              tag: 'email',
-            };
-            break;
-          }
-          case 1: {
-            variant14= {
-              tag: 'phone-number',
-            };
-            break;
-          }
-          case 2: {
-            variant14= {
-              tag: 'ip-address',
-            };
-            break;
-          }
-          case 3: {
-            variant14= {
-              tag: 'credit-card-number',
-            };
-            break;
-          }
-          case 4: {
-            var ptr13 = dataView(memory0).getInt32(base + 12, true);
-            var len13 = dataView(memory0).getInt32(base + 16, true);
-            var result13 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr13, len13));
-            variant14= {
-              tag: 'custom',
-              val: result13
-            };
-            break;
-          }
-          default: {
-            throw new TypeError('invalid variant discriminant for SensitiveInfoEntity');
-          }
-        }
-        result15.push({
-          start: dataView(memory0).getInt32(base + 0, true) >>> 0,
-          end: dataView(memory0).getInt32(base + 4, true) >>> 0,
-          identifiedType: variant14,
-        });
-      }
-      const retVal = {
-        allowed: result12,
-        denied: result15,
-      };
-      postReturn5(ret);
-      return retVal;
-    }
-    
-    return { detectBot, detectSensitiveInfo, generateFingerprint, isValidEmail, matchFilters, validateCharacteristics,  };
-  })();
-  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;
-}
-
-export { instantiate };

wasm/interfaces/arcjet-js-req-bot-identifier.d.ts

-export namespace ArcjetJsReqBotIdentifier {
-  export function detect(request: string): Array<BotEntity>;
-}
-export type BotEntity = string;

wasm/interfaces/arcjet-js-req-email-validator-overrides.d.ts

-export namespace ArcjetJsReqEmailValidatorOverrides {
-  export function isFreeEmail(domain: string): ValidatorResponse;
-  export function isDisposableEmail(domain: string): ValidatorResponse;
-  export function hasMxRecords(domain: string): ValidatorResponse;
-  export function hasGravatar(email: string): ValidatorResponse;
-}
-/**
- * # Variants
- * 
- * ## `"yes"`
- * 
- * ## `"no"`
- * 
- * ## `"unknown"`
- */
-export type ValidatorResponse = 'yes' | 'no' | 'unknown';

wasm/interfaces/arcjet-js-req-filter-overrides.d.ts

-export namespace ArcjetJsReqFilterOverrides {
-  export function ipLookup(ip: string): string | undefined;
-}

wasm/interfaces/arcjet-js-req-logger.d.ts

-export namespace ArcjetJsReqLogger {
-  export function debug(msg: string): void;
-  export function error(msg: string): void;
-}

wasm/interfaces/ar...q-sensitive-information-identifier.d.ts

-export namespace ArcjetJsReqSensitiveInformationIdentifier {
-  export function detect(tokens: Array<string>): Array<SensitiveInfoEntity | undefined>;
-}
-export type SensitiveInfoEntity = SensitiveInfoEntityEmail | SensitiveInfoEntityPhoneNumber | SensitiveInfoEntityIpAddress | SensitiveInfoEntityCreditCardNumber | SensitiveInfoEntityCustom;
-export interface SensitiveInfoEntityEmail {
-  tag: 'email',
-}
-export interface SensitiveInfoEntityPhoneNumber {
-  tag: 'phone-number',
-}
-export interface SensitiveInfoEntityIpAddress {
-  tag: 'ip-address',
-}
-export interface SensitiveInfoEntityCreditCardNumber {
-  tag: 'credit-card-number',
-}
-export interface SensitiveInfoEntityCustom {
-  tag: 'custom',
-  val: string,
-}

wasm/interfaces/arcjet-js-req-verify-bot.d.ts

-export namespace ArcjetJsReqVerifyBot {
-  export function verify(botId: string, ip: string): ValidatorResponse;
-}
-/**
- * # Variants
- * 
- * ## `"verified"`
- * 
- * ## `"spoofed"`
- * 
- * ## `"unverifiable"`
- */
-export type ValidatorResponse = 'verified' | 'spoofed' | 'unverifiable';

workerd.d.ts

-import type { ImportObject } from "./wasm/arcjet_analyze_js_req.component.js";
-/**
- * Initialize the generated WebAssembly component.
- *
- * @param coreImports
- *   Things, typically functions, to pass into the component.
- * @returns
- *   Promise that resolves to the initialized component.
- */
-export declare function initializeWasm(coreImports: ImportObject): Promise<import("./wasm/arcjet_analyze_js_req.component.js").Root | undefined>;
-export type { BotConfig, BotResult, DetectSensitiveInfoFunction, DetectedSensitiveInfoEntity, EmailValidationConfig, EmailValidationResult, ImportObject, FilterResult, SensitiveInfoEntities, SensitiveInfoEntity, SensitiveInfoResult, } from "./types.js";

workerd.js

-import { instantiate } from './wasm/arcjet_analyze_js_req.component.js';
-import componentCoreWasm from './wasm/arcjet_analyze_js_req.component.core.wasm';
-import componentCore2Wasm from './wasm/arcjet_analyze_js_req.component.core2.wasm';
-import componentCore3Wasm from './wasm/arcjet_analyze_js_req.component.core3.wasm';
-
-async function moduleFromPath(path) {
-    if (path === "arcjet_analyze_js_req.component.core.wasm") {
-        return componentCoreWasm;
-    }
-    if (path === "arcjet_analyze_js_req.component.core2.wasm") {
-        return componentCore2Wasm;
-    }
-    if (path === "arcjet_analyze_js_req.component.core3.wasm") {
-        return componentCore3Wasm;
-    }
-    throw new Error(`Unknown path: ${path}`);
-}
-/**
- * Initialize the generated WebAssembly component.
- *
- * @param coreImports
- *   Things, typically functions, to pass into the component.
- * @returns
- *   Promise that resolves to the initialized component.
- */
-async function initializeWasm(coreImports) {
-    try {
-        // Await the instantiation to catch the failure
-        return instantiate(moduleFromPath, coreImports);
-    }
-    catch {
-        return undefined;
-    }
-}
-
-export { initializeWasm };

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Improved metrics

Dev dependency count

4

-42.86%

Worsened metrics

Total package byte prevSize

4893885

-29.84%

Number of package files

25

-3.85%

Lines of code

12094

-1.43%

Number of low quality alerts

1

Infinity%

Number of medium supply chain risk alerts

3

50%

No dependency changes