@thezelijah/majik-message 1.0.0

package/dist/core/scanner/scanner-engine.js

@@ -0,0 +1,120 @@
+import { MessageEnvelope, MessageEnvelopeError, } from "../messages/message-envelope";
+/* -------------------------------
+ * ScannerEngine
+ * ------------------------------- */
+export class ScannerEngine {
+    observer;
+    contactDirectory;
+    envelopeCache;
+    onEnvelopeFound;
+    onUntrusted;
+    onError;
+    processedNodes = new WeakSet();
+    constructor(config) {
+        this.contactDirectory = config.contactDirectory;
+        this.envelopeCache = config.envelopeCache;
+        this.onEnvelopeFound = config.onEnvelopeFound;
+        this.onUntrusted = config.onUntrusted;
+        this.onError = config.onError;
+    }
+    /* -------------------------------
+     * Scan a single string
+     * ------------------------------- */
+    async scanText(text) {
+        if (!text || typeof text !== "string")
+            return;
+        const lines = text.split(/\s+/);
+        for (const line of lines) {
+            if (!MessageEnvelope.isEnvelopeCandidate(line))
+                continue;
+            try {
+                const envelope = MessageEnvelope.fromMatchedString(line);
+                // 1️⃣ Check cache first
+                if (this.envelopeCache && (await this.envelopeCache.has(envelope))) {
+                    continue; // already processed
+                }
+                // 2️⃣ Check contact trust
+                const isTrusted = this.contactDirectory.hasContactForEnvelope(envelope);
+                if (!isTrusted) {
+                    this.onUntrusted?.(line);
+                    continue;
+                }
+                // 3️⃣ Check if contact is blocked
+                const contact = this.contactDirectory.getContactByFingerprint(envelope.extractFingerprint());
+                if (contact?.isBlocked()) {
+                    this.onUntrusted?.(line);
+                    continue;
+                }
+                // 4️⃣ Call callback
+                this.onEnvelopeFound?.(envelope);
+                // 5️⃣ Store in cache
+                await this.envelopeCache?.set(envelope);
+            }
+            catch (err) {
+                if (err instanceof MessageEnvelopeError) {
+                    this.onUntrusted?.(err.raw ?? String(line));
+                }
+                else {
+                    this.onError?.(err, { raw: line });
+                }
+            }
+        }
+    }
+    /* -------------------------------
+     * Scan all text nodes under a DOM node
+     * ------------------------------- */
+    scanDOM(rootNode) {
+        const walker = document.createTreeWalker(rootNode, NodeFilter.SHOW_TEXT, null);
+        let node = walker.nextNode();
+        while (node) {
+            // Skip text nodes that belong to input-like elements to avoid collisions
+            const parent = node.parentElement;
+            const isInputLike = parent
+                ? ["INPUT", "TEXTAREA", "SELECT"].includes(parent.tagName) ||
+                    parent.isContentEditable
+                : false;
+            if (!isInputLike && !this.processedNodes.has(node)) {
+                this.scanText(node.textContent ?? "");
+                this.processedNodes.add(node);
+            }
+            node = walker.nextNode();
+        }
+    }
+    /* -------------------------------
+     * Observe DOM changes and scan dynamically
+     * ------------------------------- */
+    startDOMObserver(rootNode) {
+        if (this.observer)
+            return; // already observing
+        this.observer = new MutationObserver((mutations) => {
+            for (const mutation of mutations) {
+                if (mutation.type === "characterData" && mutation.target) {
+                    const targetNode = mutation.target;
+                    const parent = targetNode.parentElement || null;
+                    const isInputLike = parent
+                        ? ["INPUT", "TEXTAREA", "SELECT"].includes(parent.tagName) ||
+                            parent.isContentEditable
+                        : false;
+                    if (!isInputLike && !this.processedNodes.has(targetNode)) {
+                        this.scanText(targetNode.textContent ?? "");
+                        this.processedNodes.add(targetNode);
+                    }
+                }
+                else if (mutation.type === "childList") {
+                    mutation.addedNodes.forEach((node) => this.scanDOM(node));
+                }
+            }
+        });
+        this.observer.observe(rootNode, {
+            childList: true,
+            subtree: true,
+            characterData: true,
+        });
+        // Initial scan
+        this.scanDOM(rootNode);
+    }
+    stopDOMObserver() {
+        this.observer?.disconnect();
+        this.observer = undefined;
+    }
+}

package/dist/core/types.d.ts

@@ -0,0 +1,23 @@
+export type ISODateString = string;
+export interface MAJIK_API_RESPONSE {
+    success: boolean;
+    message: string;
+    code?: string;
+}
+export interface SingleRecipientPayload {
+    iv: string;
+    ciphertext: string;
+    ephemeralPublicKey: string;
+}
+export interface MultiRecipientPayload {
+    iv: string;
+    ciphertext: string;
+    ephemeralPublicKey: string;
+    keys: RecipientKeys[];
+}
+export interface RecipientKeys {
+    fingerprint: string;
+    ephemeralEncryptedKey: string;
+    nonce: string;
+}
+export type EnvelopePayload = SingleRecipientPayload | MultiRecipientPayload;

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/utils/APITranscoder.d.ts

@@ -0,0 +1,114 @@
+export interface EncryptedData {
+    rqc: Uint8Array;
+    iv: Uint8Array;
+    cipher: Uint8Array;
+}
+export interface SerializedEncryptedData {
+    rqc: string;
+    iv: string;
+    cipher: string;
+}
+declare class APITranscoder {
+    /**
+     * Generates a 32-byte cipher key encoded as a base64 string, suitable for use with Fernet encryption.
+     * @returns {string} The generated cipher key ("rqc") in base64 format.
+     */
+    static generateRQC(): string;
+    /**
+     * Generates a transformed version of the rqc by reversing and interleaving the bytes.
+     * If rqc is not provided, a new one will be generated automatically.
+     * @param {string} [rqc] - Optional. The original 32-byte cipher key in base64 format.
+     * @returns {string} The transformed key as a base64 string.
+     */
+    static generateRQX(rqc?: string | null): string;
+    /**
+     * Decodes the transformed rqx back to the original rqc base64 string.
+     * @param {string} rqx - The transformed key in base64 format.
+     * @returns {string} The original rqc in base64 format.
+     */
+    static decodeRQX(rqx: string): string;
+    static hashData(inputJson: Record<string, unknown>): string;
+    /**
+     * Generates a SHA-256 hash for a given string.
+     * Validates that the input is a non-empty string.
+     * @param {string} string - The string to hash.
+     * @returns {string} The hash of the string in hexadecimal format.
+     * @throws {Error} If the input is not a valid non-empty string.
+     */
+    static hashString(string: string): string;
+    /**
+     * Verifies that the hash of a decoded JSON object matches a provided hash.
+     * @param {Object} decodedJson - The JSON object to verify.
+     * @param {string} providedHash - The hash to compare against.
+     * @returns {boolean} True if the hashes match, false otherwise.
+     * @throws {Error} If inputs are invalid.
+     */
+    static verifyHashJSON(decodedJson: Record<string, unknown>, providedHash: string): boolean;
+    /**
+     * Verifies that the hash of a given string matches a provided hash.
+     * @param {string} string - The string to verify.
+     * @param {string} providedHash - The hash to compare against.
+     * @returns {boolean} True if the hashes match, false otherwise.
+     * @throws {Error} If inputs are invalid.
+     */
+    static verifyHashString(string: string, providedHash: string): boolean;
+    /**
+     * Decrypts an encrypted payload using AES-GCM encryption and returns the original JSON.
+     * @param {string} encrypted - The encrypted object data.
+     * @returns {Object} The decrypted and parsed JSON object.
+     * @throws {Error} Throws an error if decryption fails.
+     */
+    static decryptPayload(encrypted: SerializedEncryptedData): Record<string, unknown>;
+    /**
+     * Encrypts a JSON object using AES-GCM encryption with the provided cipher key.
+     * @param {Object} json - The JSON object to encrypt.
+     * @param {string} rqc - The 32-byte cipher key in base64 format.
+     * @returns {Object} An object containing the encrypted payload and the transformed key, potentially URL-encoded.
+     * @throws {Error} Throws an error if encryption fails.
+     */
+    static encryptPayload(json: Record<string, unknown>, rqc: string): SerializedEncryptedData;
+}
+export default APITranscoder;
+export declare function generateRQKey(auth: string): string;
+export declare function getAuthFromRQKey(rqkey: string): string;
+export declare function validateRQKey(rqkey: string): boolean;
+export declare function getDecodedRQKey(rqkey: string): string;
+export declare function getSecureKeyFromRQKey(rqkey: string): string | number | object;
+/**
+ * Converts input to a string and reverses it.
+ * If the input is a number, it is converted to a string.
+ * If the input is an object (JSON), it is stringified.
+ * If secure is true, it returns a Base64 encoded result.
+ * @param {any} input - The input to reverse.
+ * @param {boolean} secure - Whether to Base64 encode the result.
+ * @returns {string} - The reversed string, possibly encoded.
+ */
+export declare function secureReverse(input: string | object | number, secure?: boolean): string;
+/**
+ * Decodes the reversed string based on the mode provided.
+ * If secure is true, the reversed string is decoded from Base64 first.
+ * @param {string} reversedString - The reversed string (possibly Base64 encoded).
+ * @param {string|null} mode - The mode to decode ('json', 'number', or 'string').
+ * @param {boolean} secure - Whether the input is Base64 encoded.
+ * @returns {any} - The decoded result based on the mode.
+ */
+export declare function decodeReverse(reversedString: string, mode?: string, secure?: boolean): string | object | number;
+/**
+ * Converts a stringified JSON into a Uint8Array (UTF-8 bytes)
+ */
+export declare function jsonStringToBytes(jsonString: string): Uint8Array;
+/**
+ * Converts a Uint8Array (UTF-8 bytes) back into a stringified JSON
+ */
+export declare function bytesToJsonString(bytes: Uint8Array): string;
+/**
+ * Converts EncryptedData (Uint8Array fields) into base64 strings
+ * for safe transport / storage (JSON, URLs, APIs, etc.)
+ */
+export declare function encryptedDataToBase64(data: EncryptedData): SerializedEncryptedData;
+/**
+ * Converts SerializedEncryptedData (base64 fields)
+ * back into EncryptedData (Uint8Array fields)
+ */
+export declare function encryptedDataFromBase64(data: SerializedEncryptedData): EncryptedData;
+export declare function base64ToJson<T = unknown>(base64: string): T;

package/dist/core/utils/APITranscoder.js

@@ -0,0 +1,305 @@
+import { hash } from "@stablelib/sha256";
+import { AES } from "@stablelib/aes";
+import { GCM } from "@stablelib/gcm";
+import { randomBytes } from "@stablelib/random";
+import { arrayToBase64, base64ToUint8Array } from "./utilities";
+class APITranscoder {
+    /**
+     * Generates a 32-byte cipher key encoded as a base64 string, suitable for use with Fernet encryption.
+     * @returns {string} The generated cipher key ("rqc") in base64 format.
+     */
+    static generateRQC() {
+        const bytes = randomBytes(32); // 32 bytes = 256 bits
+        const fKey = arrayToBase64(bytes);
+        return fKey; // Converts the byte array to a base64 string
+    }
+    /**
+     * Generates a transformed version of the rqc by reversing and interleaving the bytes.
+     * If rqc is not provided, a new one will be generated automatically.
+     * @param {string} [rqc] - Optional. The original 32-byte cipher key in base64 format.
+     * @returns {string} The transformed key as a base64 string.
+     */
+    static generateRQX(rqc = null) {
+        // Auto-generate rqc if it's empty or null
+        if (!rqc) {
+            rqc = this.generateRQC();
+        }
+        // Decode the input rqc to bytes
+        const rqcBytes = Uint8Array.from(atob(rqc), (c) => c.charCodeAt(0)); // Decode base64 to byte array
+        const intArray = Array.from(rqcBytes);
+        // Reverse the array
+        const reversedArray = [...intArray].reverse();
+        // Interleave original and reversed arrays
+        const interleavedArray = [];
+        for (let i = 0; i < intArray.length; i++) {
+            interleavedArray.push(intArray[i], reversedArray[i]);
+        }
+        // Convert the interleaved array to a base64 string and return
+        return btoa(String.fromCharCode(...interleavedArray)); // Convert the byte array to base64 string
+    }
+    /**
+     * Decodes the transformed rqx back to the original rqc base64 string.
+     * @param {string} rqx - The transformed key in base64 format.
+     * @returns {string} The original rqc in base64 format.
+     */
+    static decodeRQX(rqx) {
+        const interleavedArray = Uint8Array.from(atob(rqx), (c) => c.charCodeAt(0)); // Decode base64 to byte array
+        // Separate the original and reversed arrays from the interleaved array
+        const originalArray = [];
+        const reversedArray = [];
+        for (let i = 0; i < interleavedArray.length; i += 2) {
+            originalArray.push(interleavedArray[i]);
+            reversedArray.push(interleavedArray[i + 1]);
+        }
+        // Verify reversedArray matches the reverse of originalArray (optional, for validation)
+        if (reversedArray.join() !== [...originalArray].reverse().join()) {
+            throw new Error("Decoded rqx does not match original rqc format.");
+        }
+        // Convert the original array back to a base64 string representing the original rqc
+        return btoa(String.fromCharCode(...originalArray)); // Convert to base64 string
+    }
+    static hashData(inputJson) {
+        const jsonString = JSON.stringify(inputJson, Object.keys(inputJson).sort());
+        const hashString = hash(jsonStringToBytes(jsonString));
+        return hashString.toString();
+    }
+    /**
+     * Generates a SHA-256 hash for a given string.
+     * Validates that the input is a non-empty string.
+     * @param {string} string - The string to hash.
+     * @returns {string} The hash of the string in hexadecimal format.
+     * @throws {Error} If the input is not a valid non-empty string.
+     */
+    static hashString(string) {
+        const hashed = hash(new TextEncoder().encode(string));
+        return hashed.toString();
+    }
+    /**
+     * Verifies that the hash of a decoded JSON object matches a provided hash.
+     * @param {Object} decodedJson - The JSON object to verify.
+     * @param {string} providedHash - The hash to compare against.
+     * @returns {boolean} True if the hashes match, false otherwise.
+     * @throws {Error} If inputs are invalid.
+     */
+    static verifyHashJSON(decodedJson, providedHash) {
+        const generatedHash = this.hashData(decodedJson);
+        return generatedHash === providedHash;
+    }
+    /**
+     * Verifies that the hash of a given string matches a provided hash.
+     * @param {string} string - The string to verify.
+     * @param {string} providedHash - The hash to compare against.
+     * @returns {boolean} True if the hashes match, false otherwise.
+     * @throws {Error} If inputs are invalid.
+     */
+    static verifyHashString(string, providedHash) {
+        if (typeof string !== "string" || string.trim() === "") {
+            throw new Error("Invalid input: 'string' must be a non-empty string.");
+        }
+        if (typeof providedHash !== "string" || providedHash.trim() === "") {
+            throw new Error("Invalid input: 'providedHash' must be a non-empty string.");
+        }
+        const generatedHash = this.hashString(string);
+        return generatedHash === providedHash;
+    }
+    /**
+     * Decrypts an encrypted payload using AES-GCM encryption and returns the original JSON.
+     * @param {string} encrypted - The encrypted object data.
+     * @returns {Object} The decrypted and parsed JSON object.
+     * @throws {Error} Throws an error if decryption fails.
+     */
+    static decryptPayload(encrypted) {
+        try {
+            const serialized = encryptedDataFromBase64(encrypted);
+            const { rqc, iv, cipher } = serialized;
+            const aes = new AES(rqc);
+            const gcm = new GCM(aes);
+            const decrypted = gcm.open(iv, cipher);
+            if (!decrypted) {
+                throw new Error("Decryption failed or payload was tampered.");
+            }
+            const base64String = arrayToBase64(decrypted);
+            const parsedData = base64ToJson(base64String);
+            return parsedData;
+        }
+        catch (error) {
+            throw new Error(`Decryption failed: ${error}`);
+        }
+    }
+    /**
+     * Encrypts a JSON object using AES-GCM encryption with the provided cipher key.
+     * @param {Object} json - The JSON object to encrypt.
+     * @param {string} rqc - The 32-byte cipher key in base64 format.
+     * @returns {Object} An object containing the encrypted payload and the transformed key, potentially URL-encoded.
+     * @throws {Error} Throws an error if encryption fails.
+     */
+    static encryptPayload(json, rqc) {
+        try {
+            const jsonString = JSON.stringify(json);
+            const data = jsonStringToBytes(jsonString);
+            const bufferRQC = base64ToUint8Array(rqc);
+            const iv = randomBytes(12);
+            const aes = new AES(bufferRQC);
+            const gcm = new GCM(aes);
+            const cipher = gcm.seal(iv, data);
+            const encrypted = { rqc: bufferRQC, iv, cipher };
+            const serialized = encryptedDataToBase64(encrypted);
+            return serialized;
+        }
+        catch (error) {
+            throw new Error(`Encryption failed: ${error}`);
+        }
+    }
+}
+export default APITranscoder;
+export function generateRQKey(auth) {
+    const now = Math.floor(Date.now() / 1000);
+    const appendedKey = now + ":" + auth + ":" + secureReverse(auth, true);
+    return btoa(appendedKey);
+}
+export function getAuthFromRQKey(rqkey) {
+    const decodedKey = getDecodedRQKey(rqkey);
+    const auth = decodedKey.split(":")[1];
+    return auth;
+}
+export function validateRQKey(rqkey) {
+    const auth = getAuthFromRQKey(rqkey);
+    const secureKey = getSecureKeyFromRQKey(rqkey);
+    if (auth !== secureKey) {
+        console.error("Access denied. This key is not valid.");
+        return false;
+    }
+    return true;
+}
+export function getDecodedRQKey(rqkey) {
+    return atob(rqkey);
+}
+export function getSecureKeyFromRQKey(rqkey) {
+    const decodedKey = getDecodedRQKey(rqkey);
+    const secureKey = decodeReverse(decodedKey.split(":")[2], "string", true);
+    return secureKey;
+}
+/**
+ * Converts input to a string and reverses it.
+ * If the input is a number, it is converted to a string.
+ * If the input is an object (JSON), it is stringified.
+ * If secure is true, it returns a Base64 encoded result.
+ * @param {any} input - The input to reverse.
+ * @param {boolean} secure - Whether to Base64 encode the result.
+ * @returns {string} - The reversed string, possibly encoded.
+ */
+export function secureReverse(input, secure = true) {
+    let str;
+    if (typeof input === "number") {
+        str = input.toString();
+    }
+    else if (typeof input === "object") {
+        str = JSON.stringify(input);
+    }
+    else {
+        str = input;
+    }
+    let reversedString = str.split("").reverse().join("");
+    if (secure) {
+        // reversedString = btoa(reversedString);
+        reversedString = Buffer.from(reversedString).toString("base64");
+    }
+    return reversedString;
+}
+/**
+ * Decodes the reversed string based on the mode provided.
+ * If secure is true, the reversed string is decoded from Base64 first.
+ * @param {string} reversedString - The reversed string (possibly Base64 encoded).
+ * @param {string|null} mode - The mode to decode ('json', 'number', or 'string').
+ * @param {boolean} secure - Whether the input is Base64 encoded.
+ * @returns {any} - The decoded result based on the mode.
+ */
+export function decodeReverse(reversedString, mode = "string", secure = true) {
+    // If secure is true, decode the reversed string from Base64
+    if (secure) {
+        reversedString = atob(reversedString);
+    }
+    const restoredString = reversedString.split("").reverse().join("");
+    if (mode === "json") {
+        try {
+            return JSON.parse(restoredString);
+        }
+        catch (error) {
+            throw new Error(`Invalid JSON format. ${error}`);
+        }
+    }
+    else if (mode === "number") {
+        const number = parseFloat(restoredString);
+        if (!number) {
+            throw new Error("Reversed string is not a valid number");
+        }
+        return number;
+    }
+    else {
+        return restoredString; // Treat as string if mode is 'string' or null
+    }
+}
+/* ---------------------------------
+ * JSON <-> Bytes Utilities
+ * --------------------------------- */
+/**
+ * Converts a stringified JSON into a Uint8Array (UTF-8 bytes)
+ */
+export function jsonStringToBytes(jsonString) {
+    return new TextEncoder().encode(jsonString);
+}
+/**
+ * Converts a Uint8Array (UTF-8 bytes) back into a stringified JSON
+ */
+export function bytesToJsonString(bytes) {
+    return new TextDecoder().decode(bytes);
+}
+/**
+ * Converts EncryptedData (Uint8Array fields) into base64 strings
+ * for safe transport / storage (JSON, URLs, APIs, etc.)
+ */
+export function encryptedDataToBase64(data) {
+    return {
+        rqc: arrayToBase64(data.rqc),
+        iv: arrayToBase64(data.iv),
+        cipher: arrayToBase64(data.cipher),
+    };
+}
+/**
+ * Converts SerializedEncryptedData (base64 fields)
+ * back into EncryptedData (Uint8Array fields)
+ */
+export function encryptedDataFromBase64(data) {
+    return {
+        rqc: base64ToUint8Array(data.rqc),
+        iv: base64ToUint8Array(data.iv),
+        cipher: base64ToUint8Array(data.cipher),
+    };
+}
+export function base64ToJson(base64) {
+    try {
+        // 🔹 Step 0: Clean the string (remove whitespace / newlines)
+        const cleanBase64 = base64.replace(/\s+/g, "");
+        let jsonString;
+        if (typeof atob === "function") {
+            // 🔹 Browser / Service Worker (atob is available globally)
+            jsonString = decodeURIComponent(atob(cleanBase64)
+                .split("")
+                .map((c) => `%${c.charCodeAt(0).toString(16).padStart(2, "0")}`)
+                .join(""));
+        }
+        else if (typeof Buffer !== "undefined") {
+            // 🔹 Node.js fallback (Buffer is available)
+            jsonString = Buffer.from(cleanBase64, "base64").toString("utf-8");
+        }
+        else {
+            throw new Error("No base64 decode available in this environment");
+        }
+        // 🔹 Parse JSON
+        return JSON.parse(jsonString);
+    }
+    catch (err) {
+        console.error("base64ToJson error:", err);
+        throw new Error("Failed to decode Base64 JSON");
+    }
+}

package/dist/core/utils/idb-majik-system.d.ts

@@ -0,0 +1,15 @@
+import { type IDBPDatabase } from "idb";
+export interface ZWorldIDBSaveData {
+    id: string;
+    data: Blob;
+    savedAt: number;
+}
+interface ZWorldAutosaveSchema {
+    majikdata: ZWorldIDBSaveData;
+}
+export declare function initDB(): Promise<IDBPDatabase<ZWorldAutosaveSchema>>;
+export declare function idbSaveBlob(id: string, data: Blob): Promise<void>;
+export declare function idbLoadBlob(id: string): Promise<ZWorldIDBSaveData | undefined>;
+export declare function deleteBlob(id: string): Promise<void>;
+export declare function clearAllBlobs(): Promise<void>;
+export {};

package/dist/core/utils/idb-majik-system.js

@@ -0,0 +1,37 @@
+// lib/indexedDB.ts
+import { openDB } from "idb";
+let dbPromise;
+export function initDB() {
+    if (!dbPromise) {
+        dbPromise = openDB("MajikAutosaveDB", 1, {
+            upgrade(db) {
+                if (!db.objectStoreNames.contains("majikdata")) {
+                    db.createObjectStore("majikdata", { keyPath: "id" });
+                }
+            },
+        });
+    }
+    return dbPromise;
+}
+export async function idbSaveBlob(id, data) {
+    const db = await initDB();
+    await db.put("majikdata", { id, data, savedAt: Date.now() });
+}
+export async function idbLoadBlob(id) {
+    try {
+        const db = await initDB();
+        return await db.get("majikdata", id);
+    }
+    catch (err) {
+        console.error(`Failed to load blob with id "${id}":`, err);
+        return undefined;
+    }
+}
+export async function deleteBlob(id) {
+    const db = await initDB();
+    return db.delete("majikdata", id);
+}
+export async function clearAllBlobs() {
+    const db = await initDB();
+    return db.clear("majikdata");
+}

package/dist/core/utils/majik-file-utils.d.ts

@@ -0,0 +1,16 @@
+interface MajikFileData {
+    /** JSON object */
+    j: unknown;
+    /** STX Timestamp */
+    s: string;
+    /** Version */
+    v: string;
+}
+export declare function importMajikFileData(file: File): Promise<MajikFileData>;
+export declare function loadSavedMajikFileData(file: Blob): Promise<MajikFileData>;
+export declare function autoSaveMajikFileData(json: unknown, version?: string): Blob;
+export declare function exportMajikFileData(json: unknown, name: string, version?: string): void;
+export declare function prepareToBlobFile(data: string): Blob;
+export declare function base64EncodeUtf8(str: string): string;
+export declare function base64DecodeUtf8(base64: string): string;
+export {};