@stll/stdnum-wasm 0.0.0 → 2.1.2

package/dist/index.d.ts

@@ -0,0 +1,95 @@
+//#region ../stdnum/dist/types.d.ts
+//#region src/types.d.ts
+type CountryCode = "AD" | "AE" | "AI" | "AL" | "AM" | "AR" | "AT" | "AU" | "AZ" | "BA" | "BD" | "BE" | "BG" | "BH" | "BR" | "BY" | "BZ" | "CA" | "CH" | "CL" | "CN" | "CO" | "CR" | "CU" | "CY" | "CZ" | "DE" | "DK" | "DO" | "EC" | "EE" | "EG" | "ES" | "FI" | "FR" | "GB" | "GE" | "GH" | "GR" | "GT" | "HK" | "HR" | "HU" | "ID" | "IE" | "IL" | "IN" | "IQ" | "IR" | "IS" | "IT" | "JP" | "KR" | "KW" | "KZ" | "LI" | "LK" | "LT" | "LU" | "LV" | "MA" | "MC" | "MD" | "ME" | "MK" | "MT" | "MU" | "MX" | "MY" | "NG" | "NI" | "NL" | "NO" | "NZ" | "PA" | "PE" | "PH" | "PK" | "PL" | "PT" | "RO" | "RS" | "RU" | "SE" | "SG" | "SI" | "SK" | "TH" | "TR" | "TW" | "UA" | "US" | "UY" | "VE" | "VN" | "ZA";
+type ErrorCode = "INVALID_FORMAT" | "INVALID_LENGTH" | "INVALID_CHECKSUM" | "INVALID_COMPONENT";
+type CardNetwork = "visa" | "mastercard" | "amex" | "discover" | "diners" | "jcb" | "unionpay" | "maestro";
+//#endregion
+//#region ../stdnum/dist/native.d.ts
+//#region src/native.d.ts
+type NativeValidationError = {
+  code: ErrorCode;
+  message: string;
+};
+type NativeValidateResult = {
+  valid: true;
+  compact: string;
+  error?: null;
+} | {
+  valid: false;
+  compact?: null;
+  error: NativeValidationError;
+};
+type NativeParsedIdentifier = {
+  birthYear: number;
+  birthMonth: number;
+  birthDay: number;
+  gender?: "male" | "female" | null;
+};
+type ValidatorMetadata = {
+  id: string;
+  name: string;
+  localName: string;
+  abbreviation: string;
+  description: string | null;
+  aliases: readonly string[];
+  candidatePattern: string | null;
+  scope: "country" | "global";
+  country: CountryCode | null;
+  entityType: "person" | "company" | "any";
+  sourceUrl: string | null;
+  lengths: readonly number[];
+  examples: readonly string[];
+  canGenerate: boolean;
+  canParse: boolean;
+};
+type NativeStdnumBinding = {
+  validatorIds(): string[];
+  validators(): ValidatorMetadata[];
+  validatorMetadata(id: string): ValidatorMetadata;
+  validate(id: string, value: string): NativeValidateResult;
+  validateIndex?(this: void, index: number, value: string): NativeValidateResult;
+  validateManyIndex?(this: void, index: number, values: readonly string[]): NativeValidateResult[];
+  areAllCanonicalValidIndex?(this: void, index: number, values: readonly string[]): boolean;
+  validateFastIndex?(this: void, index: number, value: string): number | NativeValidationError;
+  isValidCanonicalIndex?(this: void, index: number, value: string): boolean;
+  supportsCanonicalValidationIndex?(this: void, index: number): boolean;
+  compact(id: string, value: string): string;
+  compactIndex?(this: void, index: number, value: string): string;
+  format(id: string, value: string): string;
+  formatIndex?(this: void, index: number, value: string): string;
+  generate(id: string): string | null;
+  generateIndex?(this: void, index: number): string | null;
+  luhnGenerate(length?: number): string;
+  parse(id: string, value: string): NativeParsedIdentifier | null;
+  parseIndex?(this: void, index: number, value: string): NativeParsedIdentifier | null;
+  detectNetwork(value: string): CardNetwork | null;
+  beNnChecksum(value: string): number | null;
+  esVatCifChecksum(digits: string): number;
+  eeIkTwoPassCheck(digits: string): number;
+  gbNhsCalcCheckDigit(value: string): number | null;
+  gbSedolCalcCheckDigit(value: string): string;
+  hasValidEip55Checksum(value: string): boolean;
+  decodeBase58(value: string): Uint8Array | null;
+  convertBits(values: readonly number[], fromBits: number, toBits: number): number[] | null;
+  polymod(values: readonly number[]): number;
+  validateBech32(value: string): {
+    valid: true;
+  } | {
+    valid: false;
+    code: "format" | "checksum" | "component";
+  };
+};
+//#endregion
+//#region src/index.d.ts
+declare const getBinding: () => Promise<NativeStdnumBinding>;
+declare const validatorIds: () => Promise<string[]>;
+declare const validators: () => Promise<ValidatorMetadata[]>;
+declare const validatorMetadata: (id: string) => Promise<ValidatorMetadata>;
+declare const validate: (id: string, value: string) => Promise<NativeValidateResult>;
+declare const compact: (id: string, value: string) => Promise<string>;
+declare const format: (id: string, value: string) => Promise<string>;
+declare const generate: (id: string) => Promise<string | null>;
+declare const parse: (id: string, value: string) => Promise<NativeParsedIdentifier | null>;
+//#endregion
+export { type NativeParsedIdentifier, type NativeStdnumBinding, type NativeValidateResult, type ValidatorMetadata, compact, format, generate, getBinding, parse, validate, validatorIds, validatorMetadata, validators };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,53 @@
+//#region ../stdnum/dist/native.js
+const isObject = (value) => typeof value === "object" && value !== null || typeof value === "function";
+const asNativeBinding = (value) => {
+	const direct = nativeBindingCandidate(value);
+	if (direct !== null) return direct;
+	return isObject(value) ? nativeBindingCandidate(value["default"]) : null;
+};
+const nativeBindingCandidate = (candidate) => {
+	if (!isObject(candidate)) return null;
+	return [
+		"validatorIds",
+		"validators",
+		"validatorMetadata",
+		"validate",
+		"compact",
+		"format",
+		"generate",
+		"parse"
+	].every((name) => typeof candidate[name] === "function") ? candidate : null;
+};
+//#endregion
+//#region src/index.ts
+let bindingPromise;
+const getBinding = () => {
+	bindingPromise ??= loadBinding();
+	return bindingPromise;
+};
+const loadBinding = async () => {
+	const glueUrl = new URL("../native/stella_stdnum_wasm.js", import.meta.url);
+	const wasmUrl = new URL("../native/stella_stdnum_wasm_bg.wasm", import.meta.url);
+	const loaded = await import(
+		/* @vite-ignore */
+		glueUrl.href
+);
+	if (!isWasmGlue(loaded)) throw new Error("stdnum WASM glue has an invalid shape");
+	await loaded.default({ module_or_path: wasmUrl });
+	const binding = asNativeBinding(loaded);
+	if (binding === null) throw new Error("stdnum WASM exports do not match the binding contract");
+	return binding;
+};
+const isWasmGlue = (value) => typeof value === "object" && value !== null && "default" in value && typeof value.default === "function";
+const validatorIds = async () => (await getBinding()).validatorIds();
+const validators = async () => (await getBinding()).validators();
+const validatorMetadata = async (id) => (await getBinding()).validatorMetadata(id);
+const validate = async (id, value) => (await getBinding()).validate(id, value);
+const compact = async (id, value) => (await getBinding()).compact(id, value);
+const format = async (id, value) => (await getBinding()).format(id, value);
+const generate = async (id) => (await getBinding()).generate(id);
+const parse = async (id, value) => (await getBinding()).parse(id, value);
+//#endregion
+export { compact, format, generate, getBinding, parse, validate, validatorIds, validatorMetadata, validators };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../stdnum/dist/native.js","../src/index.ts"],"sourcesContent":["//#region src/native.ts\nconst isObject = (value) => typeof value === \"object\" && value !== null || typeof value === \"function\";\nconst asNativeBinding = (value) => {\n\tconst direct = nativeBindingCandidate(value);\n\tif (direct !== null) return direct;\n\treturn isObject(value) ? nativeBindingCandidate(value[\"default\"]) : null;\n};\nconst nativeBindingCandidate = (candidate) => {\n\tif (!isObject(candidate)) return null;\n\treturn [\n\t\t\"validatorIds\",\n\t\t\"validators\",\n\t\t\"validatorMetadata\",\n\t\t\"validate\",\n\t\t\"compact\",\n\t\t\"format\",\n\t\t\"generate\",\n\t\t\"parse\"\n\t].every((name) => typeof candidate[name] === \"function\") ? candidate : null;\n};\n//#endregion\nexport { asNativeBinding };\n\n//# sourceMappingURL=native.js.map","import {\n  asNativeBinding,\n  type NativeStdnumBinding,\n  type NativeValidateResult,\n  type ValidatorMetadata,\n} from \"@stll/stdnum/native\";\n\ntype WasmGlue = Record<string, unknown> & {\n  default: (moduleOrPath?: unknown) => Promise<unknown>;\n};\n\nlet bindingPromise:\n  | Promise<NativeStdnumBinding>\n  | undefined;\n\nexport const getBinding =\n  (): Promise<NativeStdnumBinding> => {\n    bindingPromise ??= loadBinding();\n    return bindingPromise;\n  };\n\nconst loadBinding =\n  async (): Promise<NativeStdnumBinding> => {\n    const glueUrl = new URL(\n      \"../native/stella_stdnum_wasm.js\",\n      import.meta.url,\n    );\n    const wasmUrl = new URL(\n      \"../native/stella_stdnum_wasm_bg.wasm\",\n      import.meta.url,\n    );\n    const loaded: unknown = await import(\n      /* @vite-ignore */ glueUrl.href\n    );\n    if (!isWasmGlue(loaded))\n      throw new Error(\n        \"stdnum WASM glue has an invalid shape\",\n      );\n    await loaded.default({ module_or_path: wasmUrl });\n    const binding = asNativeBinding(loaded);\n    if (binding === null)\n      throw new Error(\n        \"stdnum WASM exports do not match the binding contract\",\n      );\n    return binding;\n  };\n\nconst isWasmGlue = (value: unknown): value is WasmGlue =>\n  typeof value === \"object\" &&\n  value !== null &&\n  \"default\" in value &&\n  typeof value.default === \"function\";\n\nexport const validatorIds = async (): Promise<string[]> =>\n  (await getBinding()).validatorIds();\nexport const validators = async (): Promise<\n  ValidatorMetadata[]\n> => (await getBinding()).validators();\nexport const validatorMetadata = async (\n  id: string,\n): Promise<ValidatorMetadata> =>\n  (await getBinding()).validatorMetadata(id);\nexport const validate = async (\n  id: string,\n  value: string,\n): Promise<NativeValidateResult> =>\n  (await getBinding()).validate(id, value);\nexport const compact = async (\n  id: string,\n  value: string,\n): Promise<string> =>\n  (await getBinding()).compact(id, value);\nexport const format = async (\n  id: string,\n  value: string,\n): Promise<string> =>\n  (await getBinding()).format(id, value);\nexport const generate = async (\n  id: string,\n): Promise<string | null> =>\n  (await getBinding()).generate(id);\nexport const parse = async (id: string, value: string) =>\n  (await getBinding()).parse(id, value);\n\nexport type {\n  NativeParsedIdentifier,\n  NativeStdnumBinding,\n  NativeValidateResult,\n  ValidatorMetadata,\n} from \"@stll/stdnum/native\";\n"],"mappings":";AACA,MAAM,YAAY,UAAU,OAAO,UAAU,YAAY,UAAU,QAAQ,OAAO,UAAU;AAC5F,MAAM,mBAAmB,UAAU;CAClC,MAAM,SAAS,uBAAuB,KAAK;CAC3C,IAAI,WAAW,MAAM,OAAO;CAC5B,OAAO,SAAS,KAAK,IAAI,uBAAuB,MAAM,UAAU,IAAI;AACrE;AACA,MAAM,0BAA0B,cAAc;CAC7C,IAAI,CAAC,SAAS,SAAS,GAAG,OAAO;CACjC,OAAO;EACN;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACD,CAAC,CAAC,OAAO,SAAS,OAAO,UAAU,UAAU,UAAU,IAAI,YAAY;AACxE;;;ACRA,IAAI;AAIJ,MAAa,mBACyB;CAClC,mBAAmB,YAAY;CAC/B,OAAO;AACT;AAEF,MAAM,cACJ,YAA0C;CACxC,MAAM,UAAU,IAAI,IAClB,mCACA,OAAO,KAAK,GACd;CACA,MAAM,UAAU,IAAI,IAClB,wCACA,OAAO,KAAK,GACd;CACA,MAAM,SAAkB,MAAM;;EACT,QAAQ;;CAE7B,IAAI,CAAC,WAAW,MAAM,GACpB,MAAM,IAAI,MACR,uCACF;CACF,MAAM,OAAO,QAAQ,EAAE,gBAAgB,QAAQ,CAAC;CAChD,MAAM,UAAU,gBAAgB,MAAM;CACtC,IAAI,YAAY,MACd,MAAM,IAAI,MACR,uDACF;CACF,OAAO;AACT;AAEF,MAAM,cAAc,UAClB,OAAO,UAAU,YACjB,UAAU,QACV,aAAa,SACb,OAAO,MAAM,YAAY;AAE3B,MAAa,eAAe,aACzB,MAAM,WAAW,EAAA,CAAG,aAAa;AACpC,MAAa,aAAa,aAEpB,MAAM,WAAW,EAAA,CAAG,WAAW;AACrC,MAAa,oBAAoB,OAC/B,QAEC,MAAM,WAAW,EAAA,CAAG,kBAAkB,EAAE;AAC3C,MAAa,WAAW,OACtB,IACA,WAEC,MAAM,WAAW,EAAA,CAAG,SAAS,IAAI,KAAK;AACzC,MAAa,UAAU,OACrB,IACA,WAEC,MAAM,WAAW,EAAA,CAAG,QAAQ,IAAI,KAAK;AACxC,MAAa,SAAS,OACpB,IACA,WAEC,MAAM,WAAW,EAAA,CAAG,OAAO,IAAI,KAAK;AACvC,MAAa,WAAW,OACtB,QAEC,MAAM,WAAW,EAAA,CAAG,SAAS,EAAE;AAClC,MAAa,QAAQ,OAAO,IAAY,WACrC,MAAM,WAAW,EAAA,CAAG,MAAM,IAAI,KAAK"}

package/native/stella_stdnum_wasm.d.ts

@@ -0,0 +1,104 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export function beNnChecksum(value: string): number | undefined;
+
+export function compact(id: string, value: string): string;
+
+export function convertBits(values: Uint32Array, from_bits: number, to_bits: number): Uint32Array | undefined;
+
+export function decodeBase58(value: string): Uint8Array | undefined;
+
+export function detectNetwork(value: string): string | undefined;
+
+export function eeIkTwoPassCheck(value: string): number | undefined;
+
+export function esVatCifChecksum(value: string): number | undefined;
+
+export function format(id: string, value: string): string;
+
+export function gbNhsCalcCheckDigit(value: string): number | undefined;
+
+export function gbSedolCalcCheckDigit(value: string): number | undefined;
+
+export function generate(id: string): string | undefined;
+
+export function hasValidEip55Checksum(value: string): boolean;
+
+export function initialize_runtime_date(): void;
+
+export function luhnGenerate(length?: number | null): string;
+
+export function parse(id: string, value: string): any;
+
+export function polymod(values: Uint32Array): number;
+
+export function validate(id: string, value: string): any;
+
+export function validateBech32(value: string): any;
+
+export function validateId(validator: string, value: string, input?: string | null): boolean;
+
+export function validateNamedId(validator: string, value: string): boolean;
+
+export function validatorIds(): any;
+
+export function validatorMetadata(id: string): any;
+
+export function validators(): any;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly beNnChecksum: (a: number, b: number) => number;
+    readonly compact: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly convertBits: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly decodeBase58: (a: number, b: number, c: number) => void;
+    readonly detectNetwork: (a: number, b: number, c: number) => void;
+    readonly eeIkTwoPassCheck: (a: number, b: number) => number;
+    readonly esVatCifChecksum: (a: number, b: number) => number;
+    readonly format: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly gbNhsCalcCheckDigit: (a: number, b: number) => number;
+    readonly gbSedolCalcCheckDigit: (a: number, b: number) => number;
+    readonly generate: (a: number, b: number, c: number) => void;
+    readonly hasValidEip55Checksum: (a: number, b: number) => number;
+    readonly luhnGenerate: (a: number, b: number) => void;
+    readonly parse: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly polymod: (a: number, b: number) => number;
+    readonly validate: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly validateBech32: (a: number, b: number, c: number) => void;
+    readonly validateId: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly validateNamedId: (a: number, b: number, c: number, d: number) => number;
+    readonly validatorIds: (a: number) => void;
+    readonly validatorMetadata: (a: number, b: number, c: number) => void;
+    readonly validators: (a: number) => void;
+    readonly initialize_runtime_date: () => void;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    readonly __wbindgen_export3: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/native/stella_stdnum_wasm.js

@@ -0,0 +1,746 @@
+/* @ts-self-types="./stella_stdnum_wasm.d.ts" */
+
+/**
+ * @param {string} value
+ * @returns {number | undefined}
+ */
+export function beNnChecksum(value) {
+    const ptr0 = passStringToWasm0(value, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.beNnChecksum(ptr0, len0);
+    return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+}
+
+/**
+ * @param {string} id
+ * @param {string} value
+ * @returns {string}
+ */
+export function compact(id, value) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.compact(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export3(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * @param {Uint32Array} values
+ * @param {number} from_bits
+ * @param {number} to_bits
+ * @returns {Uint32Array | undefined}
+ */
+export function convertBits(values, from_bits, to_bits) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray32ToWasm0(values, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.convertBits(retptr, ptr0, len0, from_bits, to_bits);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        let v2;
+        if (r0 !== 0) {
+            v2 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export3(r0, r1 * 4, 4);
+        }
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * @param {string} value
+ * @returns {Uint8Array | undefined}
+ */
+export function decodeBase58(value) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(value, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.decodeBase58(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        let v2;
+        if (r0 !== 0) {
+            v2 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export3(r0, r1 * 1, 1);
+        }
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * @param {string} value
+ * @returns {string | undefined}
+ */
+export function detectNetwork(value) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(value, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.detectNetwork(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        let v2;
+        if (r0 !== 0) {
+            v2 = getStringFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export3(r0, r1 * 1, 1);
+        }
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * @param {string} value
+ * @returns {number | undefined}
+ */
+export function eeIkTwoPassCheck(value) {
+    const ptr0 = passStringToWasm0(value, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.eeIkTwoPassCheck(ptr0, len0);
+    return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+}
+
+/**
+ * @param {string} value
+ * @returns {number | undefined}
+ */
+export function esVatCifChecksum(value) {
+    const ptr0 = passStringToWasm0(value, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.esVatCifChecksum(ptr0, len0);
+    return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+}
+
+/**
+ * @param {string} id
+ * @param {string} value
+ * @returns {string}
+ */
+export function format(id, value) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.format(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export3(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * @param {string} value
+ * @returns {number | undefined}
+ */
+export function gbNhsCalcCheckDigit(value) {
+    const ptr0 = passStringToWasm0(value, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.gbNhsCalcCheckDigit(ptr0, len0);
+    return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+}
+
+/**
+ * @param {string} value
+ * @returns {number | undefined}
+ */
+export function gbSedolCalcCheckDigit(value) {
+    const ptr0 = passStringToWasm0(value, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.gbSedolCalcCheckDigit(ptr0, len0);
+    return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+}
+
+/**
+ * @param {string} id
+ * @returns {string | undefined}
+ */
+export function generate(id) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.generate(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        let v2;
+        if (r0 !== 0) {
+            v2 = getStringFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export3(r0, r1 * 1, 1);
+        }
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * @param {string} value
+ * @returns {boolean}
+ */
+export function hasValidEip55Checksum(value) {
+    const ptr0 = passStringToWasm0(value, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.hasValidEip55Checksum(ptr0, len0);
+    return ret !== 0;
+}
+
+export function initialize_runtime_date() {
+    wasm.initialize_runtime_date();
+}
+
+/**
+ * @param {number | null} [length]
+ * @returns {string}
+ */
+export function luhnGenerate(length) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.luhnGenerate(retptr, isLikeNone(length) ? Number.MAX_SAFE_INTEGER : (length) >>> 0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred1_0 = r0;
+        deferred1_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export3(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {string} id
+ * @param {string} value
+ * @returns {any}
+ */
+export function parse(id, value) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.parse(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * @param {Uint32Array} values
+ * @returns {number}
+ */
+export function polymod(values) {
+    const ptr0 = passArray32ToWasm0(values, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.polymod(ptr0, len0);
+    return ret >>> 0;
+}
+
+/**
+ * @param {string} id
+ * @param {string} value
+ * @returns {any}
+ */
+export function validate(id, value) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.validate(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * @param {string} value
+ * @returns {any}
+ */
+export function validateBech32(value) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(value, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.validateBech32(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * @param {string} validator
+ * @param {string} value
+ * @param {string | null} [input]
+ * @returns {boolean}
+ */
+export function validateId(validator, value, input) {
+    const ptr0 = passStringToWasm0(validator, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(value, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(input) ? 0 : passStringToWasm0(input, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    var len2 = WASM_VECTOR_LEN;
+    const ret = wasm.validateId(ptr0, len0, ptr1, len1, ptr2, len2);
+    return ret !== 0;
+}
+
+/**
+ * @param {string} validator
+ * @param {string} value
+ * @returns {boolean}
+ */
+export function validateNamedId(validator, value) {
+    const ptr0 = passStringToWasm0(validator, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(value, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.validateNamedId(ptr0, len0, ptr1, len1);
+    return ret !== 0;
+}
+
+/**
+ * @returns {any}
+ */
+export function validatorIds() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.validatorIds(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * @param {string} id
+ * @returns {any}
+ */
+export function validatorMetadata(id) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.validatorMetadata(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * @returns {any}
+ */
+export function validators() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.validators(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_Error_92b29b0548f8b746: function(arg0, arg1) {
+            const ret = Error(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_String_8564e559799eccda: function(arg0, arg1) {
+            const ret = String(getObject(arg1));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_getUTCDate_652a2ad7beebbadf: function(arg0) {
+            const ret = getObject(arg0).getUTCDate();
+            return ret;
+        },
+        __wbg_getUTCFullYear_5af8ca4e2020c06e: function(arg0) {
+            const ret = getObject(arg0).getUTCFullYear();
+            return ret;
+        },
+        __wbg_getUTCMonth_773ed3c34515d086: function(arg0) {
+            const ret = getObject(arg0).getUTCMonth();
+            return ret;
+        },
+        __wbg_new_0_3da9e97f24fc69be: function() {
+            const ret = new Date();
+            return addHeapObject(ret);
+        },
+        __wbg_new_32b398fb48b6d94a: function() {
+            const ret = new Array();
+            return addHeapObject(ret);
+        },
+        __wbg_new_da52cf8fe3429cb2: function() {
+            const ret = new Object();
+            return addHeapObject(ret);
+        },
+        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
+            getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+        },
+        __wbg_set_8a16b38e4805b298: function(arg0, arg1, arg2) {
+            getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+        },
+        __wbindgen_cast_0000000000000001: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000003: function(arg0) {
+            // Cast intrinsic for `U64 -> Externref`.
+            const ret = BigInt.asUintN(64, arg0);
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_clone_ref: function(arg0) {
+            const ret = getObject(arg0);
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_drop_ref: function(arg0) {
+            takeObject(arg0);
+        },
+    };
+    return {
+        __proto__: null,
+        "./stella_stdnum_wasm_bg.js": import0,
+    };
+}
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function dropObject(idx) {
+    if (idx < 1028) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+let heap = new Array(1024).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('stella_stdnum_wasm_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };

package/native/stella_stdnum_wasm_bg.wasm.d.ts

@@ -0,0 +1,31 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const beNnChecksum: (a: number, b: number) => number;
+export const compact: (a: number, b: number, c: number, d: number, e: number) => void;
+export const convertBits: (a: number, b: number, c: number, d: number, e: number) => void;
+export const decodeBase58: (a: number, b: number, c: number) => void;
+export const detectNetwork: (a: number, b: number, c: number) => void;
+export const eeIkTwoPassCheck: (a: number, b: number) => number;
+export const esVatCifChecksum: (a: number, b: number) => number;
+export const format: (a: number, b: number, c: number, d: number, e: number) => void;
+export const gbNhsCalcCheckDigit: (a: number, b: number) => number;
+export const gbSedolCalcCheckDigit: (a: number, b: number) => number;
+export const generate: (a: number, b: number, c: number) => void;
+export const hasValidEip55Checksum: (a: number, b: number) => number;
+export const luhnGenerate: (a: number, b: number) => void;
+export const parse: (a: number, b: number, c: number, d: number, e: number) => void;
+export const polymod: (a: number, b: number) => number;
+export const validate: (a: number, b: number, c: number, d: number, e: number) => void;
+export const validateBech32: (a: number, b: number, c: number) => void;
+export const validateId: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+export const validateNamedId: (a: number, b: number, c: number, d: number) => number;
+export const validatorIds: (a: number) => void;
+export const validatorMetadata: (a: number, b: number, c: number) => void;
+export const validators: (a: number) => void;
+export const initialize_runtime_date: () => void;
+export const __wbindgen_export: (a: number, b: number) => number;
+export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_export3: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;

package/package.json

@@ -1,16 +1,37 @@
 {
   "name": "@stll/stdnum-wasm",
-  "version": "0.0.0",
-  "description": "Bootstrap placeholder for the Rust-backed @stll/stdnum distribution",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "author": "",
+  "version": "2.1.2",
+  "description": "Standard identifier validation for browsers via WebAssembly",
+  "homepage": "https://github.com/stella/stdnum",
   "license": "MIT",
-  "type": "commonjs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stella/stdnum.git"
+  },
+  "files": [
+    "dist",
+    "native"
+  ],
+  "type": "module",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "build": "node ../../scripts/build-wasm.mjs && tsdown",
+    "build:js": "tsdown",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "devDependencies": {
+    "@stll/stdnum": "workspace:*",
+    "tsdown": "0.22.9",
+    "typescript": "7.0.2"
   }
 }