@reallyme/codec 0.1.9

package/dist/index.js

@@ -0,0 +1,63 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+export { ReallyMeCodecError } from "./errors.js";
+export { base64Decode, base64Encode, base64urlDecode, base64urlDecodeBytes, base64urlEncode, bytesToLowerHex, lowerHexToBytes, } from "./baseEncoding.js";
+export { base58btcDecode, base58btcEncode, bindingTypeMatchesCodec, multibaseBase58btcEncode, multibaseBase64urlEncode, multibaseDecode, multicodecLookupPrefixProto, multicodecLookupPrefixProtoResult, multicodecLookupPrefix, multicodecPrefixForNameProto, multicodecPrefixForNameProtoResult, multicodecPrefixForName, multicodecStripPrefix, multicodecTable, multicodecTableProto, multicodecTableProtoResult, multikeyEncode, multikeyParse, multikeyParseProto, multikeyParseProtoResult, requireSupportedMulticodec, validateKeyBinding, } from "./multiformat.js";
+export { dagCborCodecCode, dagCborComputeCid, dagCborDecode, dagCborEncode, dagCborMultihash, dagCborSha256ContentHash, dagCborVerifyCid, dagCborVerifyCidProto, dagCborVerifyCidProtoResult, isValidCidString, tryParseCid, } from "./cbor.js";
+export { canonicalizeJson, canonicalizeJsonText } from "./jcs.js";
+export { decodePem, decodePemProto, decodePemProtoResult, encodePem } from "./pem.js";
+export { REALLYME_CODEC_WASM_EXPORTS, installReallyMeCodecWasmProvider, requireReallyMeCodecWasmProvider, } from "./wasmProvider.js";
+import { base64Decode, base64Encode, base64urlDecode, base64urlDecodeBytes, base64urlEncode, bytesToLowerHex, lowerHexToBytes, } from "./baseEncoding.js";
+import { dagCborCodecCode, dagCborComputeCid, dagCborDecode, dagCborEncode, dagCborMultihash, dagCborSha256ContentHash, dagCborVerifyCid, dagCborVerifyCidProto, dagCborVerifyCidProtoResult, isValidCidString, tryParseCid, } from "./cbor.js";
+import { canonicalizeJson, canonicalizeJsonText } from "./jcs.js";
+import { base58btcDecode, base58btcEncode, bindingTypeMatchesCodec, multibaseBase58btcEncode, multibaseBase64urlEncode, multibaseDecode, multicodecLookupPrefixProto, multicodecLookupPrefixProtoResult, multicodecLookupPrefix, multicodecPrefixForNameProto, multicodecPrefixForNameProtoResult, multicodecPrefixForName, multicodecStripPrefix, multicodecTable, multicodecTableProto, multicodecTableProtoResult, multikeyEncode, multikeyParse, multikeyParseProto, multikeyParseProtoResult, requireSupportedMulticodec, validateKeyBinding, } from "./multiformat.js";
+import { decodePem, decodePemProto, decodePemProtoResult, encodePem } from "./pem.js";
+export const ReallyMeCodec = {
+    base64Decode,
+    base64Encode,
+    base64urlDecode,
+    base64urlDecodeBytes,
+    base64urlEncode,
+    bytesToLowerHex,
+    lowerHexToBytes,
+    base58btcDecode,
+    base58btcEncode,
+    bindingTypeMatchesCodec,
+    multibaseBase58btcEncode,
+    multibaseBase64urlEncode,
+    multibaseDecode,
+    multicodecLookupPrefixProto,
+    multicodecLookupPrefixProtoResult,
+    multicodecLookupPrefix,
+    multicodecPrefixForNameProto,
+    multicodecPrefixForNameProtoResult,
+    multicodecPrefixForName,
+    multicodecStripPrefix,
+    multicodecTable,
+    multicodecTableProto,
+    multicodecTableProtoResult,
+    multikeyEncode,
+    multikeyParse,
+    multikeyParseProto,
+    multikeyParseProtoResult,
+    requireSupportedMulticodec,
+    validateKeyBinding,
+    dagCborCodecCode,
+    dagCborComputeCid,
+    dagCborDecode,
+    dagCborEncode,
+    dagCborMultihash,
+    dagCborSha256ContentHash,
+    dagCborVerifyCid,
+    dagCborVerifyCidProto,
+    dagCborVerifyCidProtoResult,
+    isValidCidString,
+    tryParseCid,
+    canonicalizeJson,
+    canonicalizeJsonText,
+    decodePem,
+    decodePemProto,
+    decodePemProtoResult,
+    encodePem,
+};

package/dist/jcs.d.ts

@@ -0,0 +1,2 @@
+export declare const canonicalizeJson: (value: unknown) => string;
+export declare const canonicalizeJsonText: (json: string) => string;

package/dist/jcs.js

@@ -0,0 +1,71 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { ReallyMeCodecError } from "./errors.js";
+import { readStringOutput } from "./readOutput.js";
+import { requireReallyMeCodecWasmProvider } from "./wasmProvider.js";
+const maxJsonContainerDepth = 128;
+const validateJsonCompatible = (value, depth = 0, seen = new WeakSet()) => {
+    if (value === null) {
+        return;
+    }
+    switch (typeof value) {
+        case "boolean":
+        case "string":
+            return;
+        case "number":
+            if (!Number.isFinite(value)) {
+                throw new ReallyMeCodecError("invalid-input");
+            }
+            return;
+        case "bigint":
+        case "function":
+        case "symbol":
+        case "undefined":
+            throw new ReallyMeCodecError("invalid-input");
+        case "object":
+            break;
+    }
+    if (seen.has(value)) {
+        throw new ReallyMeCodecError("invalid-input");
+    }
+    if (depth >= maxJsonContainerDepth) {
+        throw new ReallyMeCodecError("invalid-input");
+    }
+    if (typeof Reflect.get(value, "toJSON") === "function") {
+        throw new ReallyMeCodecError("invalid-input");
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null && !Array.isArray(value)) {
+        throw new ReallyMeCodecError("invalid-input");
+    }
+    seen.add(value);
+    try {
+        if (Array.isArray(value)) {
+            for (const entry of value) {
+                validateJsonCompatible(entry, depth + 1, seen);
+            }
+            return;
+        }
+        for (const key of Object.keys(value)) {
+            validateJsonCompatible(Reflect.get(value, key), depth + 1, seen);
+        }
+    }
+    finally {
+        seen.delete(value);
+    }
+};
+export const canonicalizeJson = (value) => {
+    validateJsonCompatible(value);
+    const encoded = JSON.stringify(value);
+    if (encoded === undefined) {
+        throw new ReallyMeCodecError("invalid-input");
+    }
+    return readStringOutput(requireReallyMeCodecWasmProvider().canonicalizeJson(encoded));
+};
+export const canonicalizeJsonText = (json) => {
+    if (typeof json !== "string" || json.length === 0) {
+        throw new ReallyMeCodecError("invalid-input");
+    }
+    return readStringOutput(requireReallyMeCodecWasmProvider().canonicalizeJson(json));
+};

package/dist/multiformat.d.ts

@@ -0,0 +1,40 @@
+import type { ReallyMeCodecProtoResult } from "./readOutput.js";
+export type ReallyMeMulticodecTag = "encryption" | "hash" | "key" | "multihash" | "multikey";
+export type ReallyMeKeyMaterialKind = "not-key" | "public-key" | "private-key" | "symmetric-key";
+export type ReallyMeMulticodecMetadata = Readonly<{
+    name: string;
+    alg: string;
+    tag: ReallyMeMulticodecTag;
+    keyMaterial: ReallyMeKeyMaterialKind;
+    prefix: Uint8Array;
+    expectedKeyLength?: number;
+}>;
+export type ReallyMeParsedMultikey = Readonly<{
+    codecName: string;
+    algorithmName: string;
+    publicKey: Uint8Array;
+    expectedPublicKeyLength?: number;
+}>;
+export declare const readMulticodecMetadata: (value: unknown) => ReallyMeMulticodecMetadata;
+export declare const base58btcEncode: (bytes: Uint8Array) => string;
+export declare const base58btcDecode: (encoded: string) => Uint8Array;
+export declare const multibaseBase64urlEncode: (bytes: Uint8Array) => string;
+export declare const multibaseBase58btcEncode: (bytes: Uint8Array) => string;
+export declare const multibaseDecode: (encoded: string) => Uint8Array;
+export declare const multicodecPrefixForName: (codecName: string) => ReallyMeMulticodecMetadata;
+export declare const multicodecPrefixForNameProto: (codecName: string) => Uint8Array;
+export declare const multicodecPrefixForNameProtoResult: (codecName: string) => ReallyMeCodecProtoResult;
+export declare const multicodecLookupPrefix: (bytes: Uint8Array) => ReallyMeMulticodecMetadata;
+export declare const multicodecLookupPrefixProto: (bytes: Uint8Array) => Uint8Array;
+export declare const multicodecLookupPrefixProtoResult: (bytes: Uint8Array) => ReallyMeCodecProtoResult;
+export declare const multicodecStripPrefix: (bytes: Uint8Array) => Uint8Array;
+export declare const multicodecTable: () => ReadonlyArray<ReallyMeMulticodecMetadata>;
+export declare const multicodecTableProto: () => Uint8Array;
+export declare const multicodecTableProtoResult: () => ReallyMeCodecProtoResult;
+export declare const multikeyEncode: (codecName: string, publicKey: Uint8Array) => string;
+export declare const multikeyParse: (multikey: string) => ReallyMeParsedMultikey;
+export declare const multikeyParseProto: (multikey: string) => Uint8Array;
+export declare const multikeyParseProtoResult: (multikey: string) => ReallyMeCodecProtoResult;
+export declare const bindingTypeMatchesCodec: (bindingType: string, codecName: string) => boolean;
+export declare const validateKeyBinding: (bindingType: string, algorithm: string | undefined, multikey: string) => void;
+export declare const requireSupportedMulticodec: (codecName: string) => void;

package/dist/multiformat.js

@@ -0,0 +1,169 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { ReallyMeCodecError } from "./errors.js";
+import { ensureBytesInput, ensureStringInput, readBooleanOutput, readBytesOutput, readBytesProperty, readObjectOutput, readProtoResultOutput, readOptionalLengthProperty, readStringOutput, readStringProperty, } from "./readOutput.js";
+import { requireReallyMeCodecWasmProvider } from "./wasmProvider.js";
+const validTags = new Set([
+    "encryption",
+    "hash",
+    "key",
+    "multihash",
+    "multikey",
+]);
+const validKeyMaterialKinds = new Set([
+    "not-key",
+    "public-key",
+    "private-key",
+    "symmetric-key",
+]);
+const readTag = (object) => {
+    const tag = readStringProperty(object, "tag");
+    if (!validTags.has(tag)) {
+        throw new ReallyMeCodecError("provider-failure");
+    }
+    switch (tag) {
+        case "encryption":
+        case "hash":
+        case "key":
+        case "multihash":
+        case "multikey":
+            return tag;
+        default:
+            throw new ReallyMeCodecError("provider-failure");
+    }
+};
+const readKeyMaterial = (object) => {
+    const keyMaterial = readStringProperty(object, "keyMaterial");
+    if (!validKeyMaterialKinds.has(keyMaterial)) {
+        throw new ReallyMeCodecError("provider-failure");
+    }
+    switch (keyMaterial) {
+        case "not-key":
+        case "public-key":
+        case "private-key":
+        case "symmetric-key":
+            return keyMaterial;
+        default:
+            throw new ReallyMeCodecError("provider-failure");
+    }
+};
+export const readMulticodecMetadata = (value) => {
+    const object = readObjectOutput(value);
+    const expectedKeyLength = readOptionalLengthProperty(object, "expectedKeyLength");
+    const metadata = {
+        name: readStringProperty(object, "name"),
+        alg: readStringProperty(object, "alg"),
+        tag: readTag(object),
+        keyMaterial: readKeyMaterial(object),
+        prefix: readBytesProperty(object, "prefix"),
+    };
+    if (expectedKeyLength === undefined) {
+        return metadata;
+    }
+    return { ...metadata, expectedKeyLength };
+};
+const readParsedMultikey = (value) => {
+    const object = readObjectOutput(value);
+    const expectedPublicKeyLength = readOptionalLengthProperty(object, "expectedPublicKeyLength");
+    const parsed = {
+        codecName: readStringProperty(object, "codecName"),
+        algorithmName: readStringProperty(object, "algorithmName"),
+        publicKey: readBytesProperty(object, "publicKey"),
+    };
+    if (expectedPublicKeyLength === undefined) {
+        return parsed;
+    }
+    return { ...parsed, expectedPublicKeyLength };
+};
+const readMulticodecTable = (value) => {
+    if (!Array.isArray(value)) {
+        throw new ReallyMeCodecError("provider-failure");
+    }
+    return value.map(readMulticodecMetadata);
+};
+export const base58btcEncode = (bytes) => {
+    ensureBytesInput(bytes);
+    return readStringOutput(requireReallyMeCodecWasmProvider().base58btcEncode(bytes));
+};
+export const base58btcDecode = (encoded) => {
+    ensureStringInput(encoded);
+    return readBytesOutput(requireReallyMeCodecWasmProvider().base58btcDecode(encoded));
+};
+export const multibaseBase64urlEncode = (bytes) => {
+    ensureBytesInput(bytes);
+    return readStringOutput(requireReallyMeCodecWasmProvider().multibaseBase64urlEncode(bytes));
+};
+export const multibaseBase58btcEncode = (bytes) => {
+    ensureBytesInput(bytes);
+    return readStringOutput(requireReallyMeCodecWasmProvider().multibaseBase58btcEncode(bytes));
+};
+export const multibaseDecode = (encoded) => {
+    ensureStringInput(encoded);
+    return readBytesOutput(requireReallyMeCodecWasmProvider().multibaseDecode(encoded));
+};
+export const multicodecPrefixForName = (codecName) => {
+    ensureStringInput(codecName);
+    return readMulticodecMetadata(requireReallyMeCodecWasmProvider().multicodecPrefixForName(codecName));
+};
+export const multicodecPrefixForNameProto = (codecName) => {
+    ensureStringInput(codecName);
+    return readBytesOutput(requireReallyMeCodecWasmProvider().multicodecPrefixForNameProto(codecName));
+};
+export const multicodecPrefixForNameProtoResult = (codecName) => {
+    ensureStringInput(codecName);
+    return readProtoResultOutput(requireReallyMeCodecWasmProvider().multicodecPrefixForNameProtoResult(codecName));
+};
+export const multicodecLookupPrefix = (bytes) => {
+    ensureBytesInput(bytes);
+    return readMulticodecMetadata(requireReallyMeCodecWasmProvider().multicodecLookupPrefix(bytes));
+};
+export const multicodecLookupPrefixProto = (bytes) => {
+    ensureBytesInput(bytes);
+    return readBytesOutput(requireReallyMeCodecWasmProvider().multicodecLookupPrefixProto(bytes));
+};
+export const multicodecLookupPrefixProtoResult = (bytes) => {
+    ensureBytesInput(bytes);
+    return readProtoResultOutput(requireReallyMeCodecWasmProvider().multicodecLookupPrefixProtoResult(bytes));
+};
+export const multicodecStripPrefix = (bytes) => {
+    ensureBytesInput(bytes);
+    return readBytesOutput(requireReallyMeCodecWasmProvider().multicodecStripPrefix(bytes));
+};
+export const multicodecTable = () => readMulticodecTable(requireReallyMeCodecWasmProvider().multicodecTable());
+export const multicodecTableProto = () => readBytesOutput(requireReallyMeCodecWasmProvider().multicodecTableProto());
+export const multicodecTableProtoResult = () => readProtoResultOutput(requireReallyMeCodecWasmProvider().multicodecTableProtoResult());
+export const multikeyEncode = (codecName, publicKey) => {
+    ensureStringInput(codecName);
+    ensureBytesInput(publicKey);
+    return readStringOutput(requireReallyMeCodecWasmProvider().multikeyEncode(codecName, publicKey));
+};
+export const multikeyParse = (multikey) => {
+    ensureStringInput(multikey);
+    return readParsedMultikey(requireReallyMeCodecWasmProvider().multikeyParse(multikey));
+};
+export const multikeyParseProto = (multikey) => {
+    ensureStringInput(multikey);
+    return readBytesOutput(requireReallyMeCodecWasmProvider().multikeyParseProto(multikey));
+};
+export const multikeyParseProtoResult = (multikey) => {
+    ensureStringInput(multikey);
+    return readProtoResultOutput(requireReallyMeCodecWasmProvider().multikeyParseProtoResult(multikey));
+};
+export const bindingTypeMatchesCodec = (bindingType, codecName) => {
+    ensureStringInput(bindingType);
+    ensureStringInput(codecName);
+    return readBooleanOutput(requireReallyMeCodecWasmProvider().bindingTypeMatchesCodec(bindingType, codecName));
+};
+export const validateKeyBinding = (bindingType, algorithm, multikey) => {
+    ensureStringInput(bindingType);
+    if (algorithm !== undefined) {
+        ensureStringInput(algorithm);
+    }
+    ensureStringInput(multikey);
+    requireReallyMeCodecWasmProvider().validateKeyBinding(bindingType, algorithm, multikey);
+};
+export const requireSupportedMulticodec = (codecName) => {
+    ensureStringInput(codecName);
+    requireReallyMeCodecWasmProvider().requireSupportedMulticodec(codecName);
+};

package/dist/pem.d.ts

@@ -0,0 +1,21 @@
+import type { ReallyMeCodecProtoResult } from "./readOutput.js";
+export type ReallyMePemLabel = "PRIVATE KEY" | "EC PRIVATE KEY" | "PUBLIC KEY";
+export type ReallyMePemLineEnding = "lf" | "crlf";
+export type ReallyMePemDecodePolicy = Readonly<{
+    allowedLabels?: ReadonlyArray<ReallyMePemLabel>;
+    maxInputLen?: number;
+    maxDerLen?: number;
+}>;
+export type ReallyMePemEncodeOptions = Readonly<{
+    maxDerLen?: number;
+    lineWidth?: number;
+    lineEnding?: ReallyMePemLineEnding;
+}>;
+export type ReallyMePemDocument = Readonly<{
+    label: ReallyMePemLabel;
+    der: Uint8Array;
+}>;
+export declare const decodePem: (input: string, policy?: ReallyMePemDecodePolicy) => ReallyMePemDocument;
+export declare const decodePemProto: (input: string, policy?: ReallyMePemDecodePolicy) => Uint8Array;
+export declare const decodePemProtoResult: (input: string, policy?: ReallyMePemDecodePolicy) => ReallyMeCodecProtoResult;
+export declare const encodePem: (label: ReallyMePemLabel, der: Uint8Array, options?: ReallyMePemEncodeOptions) => string;

package/dist/pem.js

@@ -0,0 +1,88 @@
+// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+//
+// SPDX-License-Identifier: Apache-2.0
+import { ReallyMeCodecError } from "./errors.js";
+import { ensureBytesInput, ensureStringInput, readBytesOutput, readBytesProperty, readObjectOutput, readProtoResultOutput, readStringOutput, readStringProperty, } from "./readOutput.js";
+import { requireReallyMeCodecWasmProvider } from "./wasmProvider.js";
+const validLabels = new Set([
+    "PRIVATE KEY",
+    "EC PRIVATE KEY",
+    "PUBLIC KEY",
+]);
+const requirePemLabel = (label) => {
+    if (!validLabels.has(label)) {
+        throw new ReallyMeCodecError("invalid-input");
+    }
+    switch (label) {
+        case "PRIVATE KEY":
+        case "EC PRIVATE KEY":
+        case "PUBLIC KEY":
+            return label;
+        default:
+            throw new ReallyMeCodecError("invalid-input");
+    }
+};
+const requirePositiveInteger = (value) => {
+    if (value !== undefined &&
+        (!Number.isSafeInteger(value) || value <= 0)) {
+        throw new ReallyMeCodecError("invalid-input");
+    }
+};
+const encodeOptions = (options) => {
+    if (options === undefined) {
+        return "";
+    }
+    return JSON.stringify(options);
+};
+const readPemDocument = (value) => {
+    const object = readObjectOutput(value);
+    return {
+        label: requirePemLabel(readStringProperty(object, "label")),
+        der: readBytesProperty(object, "der"),
+    };
+};
+export const decodePem = (input, policy) => {
+    ensureStringInput(input);
+    if (policy?.allowedLabels !== undefined) {
+        for (const label of policy.allowedLabels) {
+            requirePemLabel(label);
+        }
+    }
+    requirePositiveInteger(policy?.maxInputLen);
+    requirePositiveInteger(policy?.maxDerLen);
+    return readPemDocument(requireReallyMeCodecWasmProvider().pemDecode(input, encodeOptions(policy)));
+};
+export const decodePemProto = (input, policy) => {
+    ensureStringInput(input);
+    if (policy?.allowedLabels !== undefined) {
+        for (const label of policy.allowedLabels) {
+            requirePemLabel(label);
+        }
+    }
+    requirePositiveInteger(policy?.maxInputLen);
+    requirePositiveInteger(policy?.maxDerLen);
+    return readBytesOutput(requireReallyMeCodecWasmProvider().pemDecodeProto(input, encodeOptions(policy)));
+};
+export const decodePemProtoResult = (input, policy) => {
+    ensureStringInput(input);
+    if (policy?.allowedLabels !== undefined) {
+        for (const label of policy.allowedLabels) {
+            requirePemLabel(label);
+        }
+    }
+    requirePositiveInteger(policy?.maxInputLen);
+    requirePositiveInteger(policy?.maxDerLen);
+    return readProtoResultOutput(requireReallyMeCodecWasmProvider().pemDecodeProtoResult(input, encodeOptions(policy)));
+};
+export const encodePem = (label, der, options) => {
+    requirePemLabel(label);
+    ensureBytesInput(der);
+    requirePositiveInteger(options?.maxDerLen);
+    requirePositiveInteger(options?.lineWidth);
+    if (options?.lineEnding !== undefined &&
+        options.lineEnding !== "lf" &&
+        options.lineEnding !== "crlf") {
+        throw new ReallyMeCodecError("invalid-input");
+    }
+    return readStringOutput(requireReallyMeCodecWasmProvider().pemEncode(label, der, encodeOptions(options)));
+};