@reallyme/codec 0.1.9

package/dist/wasmProvider.d.ts

@@ -0,0 +1,67 @@
+type BytesToStringFn = (bytes: Uint8Array) => unknown;
+type StringToBytesFn = (text: string) => unknown;
+type StringToStringFn = (text: string) => unknown;
+type StringToObjectFn = (text: string) => unknown;
+type BytesToObjectFn = (bytes: Uint8Array) => unknown;
+type BytesToBytesFn = (bytes: Uint8Array) => unknown;
+type StringBytesToStringFn = (text: string, bytes: Uint8Array) => unknown;
+type StringToBooleanFn = (text: string) => unknown;
+type StringStringToBooleanFn = (left: string, right: string) => unknown;
+type ValidateKeyBindingFn = (bindingType: string, algorithm: string | undefined, multikey: string) => unknown;
+type PemDecodeFn = (input: string, optionsJson: string) => unknown;
+type PemEncodeFn = (label: string, der: Uint8Array, optionsJson: string) => unknown;
+type Function0 = () => unknown;
+type StringToObjectOutputFn = (text: string) => unknown;
+type BytesToObjectOutputFn = (bytes: Uint8Array) => unknown;
+type StringBytesToObjectOutputFn = (text: string, bytes: Uint8Array) => unknown;
+type PemDecodeObjectOutputFn = (input: string, optionsJson: string) => unknown;
+export declare const REALLYME_CODEC_WASM_EXPORTS: readonly ["base64Decode", "base64Encode", "base64urlDecode", "base64urlEncode", "bytesToLowerHex", "lowerHexToBytes", "base58btcDecode", "base58btcEncode", "multibaseBase58btcEncode", "multibaseBase64urlEncode", "multibaseDecode", "multicodecLookupPrefix", "multicodecLookupPrefixProto", "multicodecLookupPrefixProtoResult", "multicodecPrefixForName", "multicodecPrefixForNameProto", "multicodecPrefixForNameProtoResult", "multicodecStripPrefix", "multicodecTable", "multicodecTableProto", "multicodecTableProtoResult", "multikeyEncode", "multikeyParse", "multikeyParseProto", "multikeyParseProtoResult", "bindingTypeMatchesCodec", "validateKeyBinding", "requireSupportedMulticodec", "dagCborCodecCode", "dagCborComputeCid", "dagCborDecode", "dagCborEncode", "dagCborMultihash", "dagCborSha256ContentHash", "dagCborVerifyCid", "dagCborVerifyCidProto", "dagCborVerifyCidProtoResult", "isValidCidString", "tryParseCid", "canonicalizeJson", "pemDecode", "pemDecodeProto", "pemDecodeProtoResult", "pemEncode"];
+export type ReallyMeCodecWasmProvider = Readonly<{
+    base64Decode: StringToBytesFn;
+    base64Encode: BytesToStringFn;
+    base64urlDecode: StringToBytesFn;
+    base64urlEncode: BytesToStringFn;
+    bytesToLowerHex: BytesToStringFn;
+    lowerHexToBytes: StringToBytesFn;
+    base58btcDecode: StringToBytesFn;
+    base58btcEncode: BytesToStringFn;
+    multibaseBase58btcEncode: BytesToStringFn;
+    multibaseBase64urlEncode: BytesToStringFn;
+    multibaseDecode: StringToBytesFn;
+    multicodecLookupPrefix: BytesToObjectFn;
+    multicodecLookupPrefixProto: BytesToBytesFn;
+    multicodecLookupPrefixProtoResult: BytesToObjectOutputFn;
+    multicodecPrefixForName: StringToObjectFn;
+    multicodecPrefixForNameProto: StringToBytesFn;
+    multicodecPrefixForNameProtoResult: StringToObjectOutputFn;
+    multicodecStripPrefix: BytesToBytesFn;
+    multicodecTable: Function0;
+    multicodecTableProto: Function0;
+    multicodecTableProtoResult: Function0;
+    multikeyEncode: StringBytesToStringFn;
+    multikeyParse: StringToObjectFn;
+    multikeyParseProto: StringToBytesFn;
+    multikeyParseProtoResult: StringToObjectOutputFn;
+    bindingTypeMatchesCodec: StringStringToBooleanFn;
+    validateKeyBinding: ValidateKeyBindingFn;
+    requireSupportedMulticodec: StringToStringFn;
+    dagCborCodecCode: Function0;
+    dagCborComputeCid: BytesToStringFn;
+    dagCborDecode: BytesToStringFn;
+    dagCborEncode: StringToBytesFn;
+    dagCborMultihash: BytesToBytesFn;
+    dagCborSha256ContentHash: BytesToBytesFn;
+    dagCborVerifyCid: StringBytesToStringFn;
+    dagCborVerifyCidProto: StringBytesToStringFn;
+    dagCborVerifyCidProtoResult: StringBytesToObjectOutputFn;
+    isValidCidString: StringToBooleanFn;
+    tryParseCid: StringToObjectFn;
+    canonicalizeJson: StringToStringFn;
+    pemDecode: PemDecodeFn;
+    pemDecodeProto: PemDecodeFn;
+    pemDecodeProtoResult: PemDecodeObjectOutputFn;
+    pemEncode: PemEncodeFn;
+}>;
+export declare const installReallyMeCodecWasmProvider: (module: unknown) => void;
+export declare const requireReallyMeCodecWasmProvider: () => ReallyMeCodecWasmProvider;
+export {};

package/dist/wasmProvider.js

@@ -0,0 +1,178 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { ReallyMeCodecError } from "./errors.js";
+export const REALLYME_CODEC_WASM_EXPORTS = [
+    "base64Decode",
+    "base64Encode",
+    "base64urlDecode",
+    "base64urlEncode",
+    "bytesToLowerHex",
+    "lowerHexToBytes",
+    "base58btcDecode",
+    "base58btcEncode",
+    "multibaseBase58btcEncode",
+    "multibaseBase64urlEncode",
+    "multibaseDecode",
+    "multicodecLookupPrefix",
+    "multicodecLookupPrefixProto",
+    "multicodecLookupPrefixProtoResult",
+    "multicodecPrefixForName",
+    "multicodecPrefixForNameProto",
+    "multicodecPrefixForNameProtoResult",
+    "multicodecStripPrefix",
+    "multicodecTable",
+    "multicodecTableProto",
+    "multicodecTableProtoResult",
+    "multikeyEncode",
+    "multikeyParse",
+    "multikeyParseProto",
+    "multikeyParseProtoResult",
+    "bindingTypeMatchesCodec",
+    "validateKeyBinding",
+    "requireSupportedMulticodec",
+    "dagCborCodecCode",
+    "dagCborComputeCid",
+    "dagCborDecode",
+    "dagCborEncode",
+    "dagCborMultihash",
+    "dagCborSha256ContentHash",
+    "dagCborVerifyCid",
+    "dagCborVerifyCidProto",
+    "dagCborVerifyCidProtoResult",
+    "isValidCidString",
+    "tryParseCid",
+    "canonicalizeJson",
+    "pemDecode",
+    "pemDecodeProto",
+    "pemDecodeProtoResult",
+    "pemEncode",
+];
+let installedProvider;
+const wasmErrorCode = (error) => {
+    switch (error) {
+        case "invalid-input":
+            return "invalid-input";
+        case "non-canonical":
+            return "non-canonical";
+        case "unsupported-codec":
+            return "unsupported-codec";
+        case "provider-failure":
+        default:
+            return "provider-failure";
+    }
+};
+const requireObject = (module) => {
+    if (typeof module !== "object" || module === null) {
+        throw new ReallyMeCodecError("provider-failure");
+    }
+    return module;
+};
+const requireFunction = (module, name) => {
+    const candidate = Reflect.get(module, name);
+    if (typeof candidate !== "function") {
+        throw new ReallyMeCodecError("provider-failure");
+    }
+    return (...args) => {
+        try {
+            return candidate(...args);
+        }
+        catch (error) {
+            throw new ReallyMeCodecError(wasmErrorCode(error));
+        }
+    };
+};
+const function0 = (module, name) => {
+    const callable = requireFunction(module, name);
+    return () => callable();
+};
+const stringFunction1 = (module, name) => {
+    const callable = requireFunction(module, name);
+    return (text) => callable(text);
+};
+const bytesFunction1 = (module, name) => {
+    const callable = requireFunction(module, name);
+    return (bytes) => callable(bytes);
+};
+const stringBytesFunction2 = (module, name) => {
+    const callable = requireFunction(module, name);
+    return (text, bytes) => callable(text, bytes);
+};
+const stringStringBooleanFunction = (module, name) => {
+    const callable = requireFunction(module, name);
+    return (left, right) => callable(left, right);
+};
+const stringBooleanFunction = (module, name) => {
+    const callable = requireFunction(module, name);
+    return (text) => callable(text);
+};
+const validateKeyBindingFunction = (module, name) => {
+    const callable = requireFunction(module, name);
+    return (bindingType, algorithm, multikey) => callable(bindingType, algorithm, multikey);
+};
+const pemDecodeFunction = (module, name) => {
+    const callable = requireFunction(module, name);
+    return (input, optionsJson) => callable(input, optionsJson);
+};
+const pemEncodeFunction = (module, name) => {
+    const callable = requireFunction(module, name);
+    return (label, der, optionsJson) => callable(label, der, optionsJson);
+};
+export const installReallyMeCodecWasmProvider = (module) => {
+    if (installedProvider !== undefined) {
+        throw new ReallyMeCodecError("provider-failure");
+    }
+    const providerModule = requireObject(module);
+    installedProvider = {
+        base64Decode: stringFunction1(providerModule, "base64Decode"),
+        base64Encode: bytesFunction1(providerModule, "base64Encode"),
+        base64urlDecode: stringFunction1(providerModule, "base64urlDecode"),
+        base64urlEncode: bytesFunction1(providerModule, "base64urlEncode"),
+        bytesToLowerHex: bytesFunction1(providerModule, "bytesToLowerHex"),
+        lowerHexToBytes: stringFunction1(providerModule, "lowerHexToBytes"),
+        base58btcDecode: stringFunction1(providerModule, "base58btcDecode"),
+        base58btcEncode: bytesFunction1(providerModule, "base58btcEncode"),
+        multibaseBase58btcEncode: bytesFunction1(providerModule, "multibaseBase58btcEncode"),
+        multibaseBase64urlEncode: bytesFunction1(providerModule, "multibaseBase64urlEncode"),
+        multibaseDecode: stringFunction1(providerModule, "multibaseDecode"),
+        multicodecLookupPrefix: bytesFunction1(providerModule, "multicodecLookupPrefix"),
+        multicodecLookupPrefixProto: bytesFunction1(providerModule, "multicodecLookupPrefixProto"),
+        multicodecLookupPrefixProtoResult: bytesFunction1(providerModule, "multicodecLookupPrefixProtoResult"),
+        multicodecPrefixForName: stringFunction1(providerModule, "multicodecPrefixForName"),
+        multicodecPrefixForNameProto: stringFunction1(providerModule, "multicodecPrefixForNameProto"),
+        multicodecPrefixForNameProtoResult: stringFunction1(providerModule, "multicodecPrefixForNameProtoResult"),
+        multicodecStripPrefix: bytesFunction1(providerModule, "multicodecStripPrefix"),
+        multicodecTable: function0(providerModule, "multicodecTable"),
+        multicodecTableProto: function0(providerModule, "multicodecTableProto"),
+        multicodecTableProtoResult: function0(providerModule, "multicodecTableProtoResult"),
+        multikeyEncode: stringBytesFunction2(providerModule, "multikeyEncode"),
+        multikeyParse: stringFunction1(providerModule, "multikeyParse"),
+        multikeyParseProto: stringFunction1(providerModule, "multikeyParseProto"),
+        multikeyParseProtoResult: stringFunction1(providerModule, "multikeyParseProtoResult"),
+        bindingTypeMatchesCodec: stringStringBooleanFunction(providerModule, "bindingTypeMatchesCodec"),
+        validateKeyBinding: validateKeyBindingFunction(providerModule, "validateKeyBinding"),
+        requireSupportedMulticodec: stringFunction1(providerModule, "requireSupportedMulticodec"),
+        dagCborCodecCode: function0(providerModule, "dagCborCodecCode"),
+        dagCborComputeCid: bytesFunction1(providerModule, "dagCborComputeCid"),
+        dagCborDecode: bytesFunction1(providerModule, "dagCborDecode"),
+        dagCborEncode: stringFunction1(providerModule, "dagCborEncode"),
+        dagCborMultihash: bytesFunction1(providerModule, "dagCborMultihash"),
+        dagCborSha256ContentHash: bytesFunction1(providerModule, "dagCborSha256ContentHash"),
+        dagCborVerifyCid: stringBytesFunction2(providerModule, "dagCborVerifyCid"),
+        dagCborVerifyCidProto: stringBytesFunction2(providerModule, "dagCborVerifyCidProto"),
+        dagCborVerifyCidProtoResult: stringBytesFunction2(providerModule, "dagCborVerifyCidProtoResult"),
+        isValidCidString: stringBooleanFunction(providerModule, "isValidCidString"),
+        tryParseCid: stringFunction1(providerModule, "tryParseCid"),
+        canonicalizeJson: stringFunction1(providerModule, "canonicalizeJson"),
+        pemDecode: pemDecodeFunction(providerModule, "pemDecode"),
+        pemDecodeProto: pemDecodeFunction(providerModule, "pemDecodeProto"),
+        pemDecodeProtoResult: pemDecodeFunction(providerModule, "pemDecodeProtoResult"),
+        pemEncode: pemEncodeFunction(providerModule, "pemEncode"),
+    };
+};
+export const requireReallyMeCodecWasmProvider = () => {
+    if (installedProvider === undefined) {
+        throw new ReallyMeCodecError("provider-failure");
+    }
+    return installedProvider;
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@reallyme/codec",
+  "version": "0.1.9",
+  "description": "TypeScript facade for the ReallyMe codec WASM package.",
+  "license": "Apache-2.0",
+  "sideEffects": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./proto": {
+      "types": "./dist/proto.d.ts",
+      "default": "./dist/proto.js"
+    },
+    "./wasm/reallyme_codec_wasm.js": {
+      "types": "./dist/wasm/reallyme_codec_wasm.d.ts",
+      "default": "./dist/wasm/reallyme_codec_wasm.js"
+    },
+    "./wasm/reallyme_codec_wasm_bg.wasm": {
+      "default": "./dist/wasm/reallyme_codec_wasm_bg.wasm"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "node scripts/clean-dist.mjs && npm run build:wasm && tsc",
+    "build:wasm": "node scripts/build-wasm.mjs",
+    "typecheck": "tsc --noEmit",
+    "test": "npm run build && node --test \"test/*.test.mjs\""
+  },
+  "dependencies": {
+    "@bufbuild/protobuf": "2.12.1"
+  },
+  "devDependencies": {
+    "typescript": "5.8.3"
+  },
+  "engines": {
+    "node": ">=20.19.0"
+  }
+}