zapo-js 0.1.0

package/dist/util/base64.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bytesToBase64UrlSafe = exports.bytesToBase64 = void 0;
+exports.base64ToBytes = base64ToBytes;
+exports.decodeProtoBytes = decodeProtoBytes;
+const bytes_1 = require("./bytes");
+Object.defineProperty(exports, "bytesToBase64", { enumerable: true, get: function () { return bytes_1.bytesToBase64; } });
+Object.defineProperty(exports, "bytesToBase64UrlSafe", { enumerable: true, get: function () { return bytes_1.bytesToBase64UrlSafe; } });
+function base64ToBytes(value, field, requireNonEmpty = true) {
+    const out = (0, bytes_1.base64ToBytes)(value);
+    if (requireNonEmpty && out.length === 0) {
+        throw new Error(`invalid base64 payload for ${field}`);
+    }
+    return out;
+}
+function decodeProtoBytes(value, field) {
+    if (value === null || value === undefined) {
+        throw new Error(`missing protobuf bytes field ${field}`);
+    }
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    return (0, bytes_1.base64ToBytes)(value);
+}

package/dist/util/bytes.js

@@ -0,0 +1,291 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY_BYTES = exports.TEXT_DECODER = exports.TEXT_ENCODER = void 0;
+exports.bytesToHex = bytesToHex;
+exports.hexToBytes = hexToBytes;
+exports.bytesToBase64 = bytesToBase64;
+exports.base64ToBytes = base64ToBytes;
+exports.bytesToBase64UrlSafe = bytesToBase64UrlSafe;
+exports.concatBytes = concatBytes;
+exports.toBytesView = toBytesView;
+exports.toChunkBytes = toChunkBytes;
+exports.uint8TimingSafeEqual = uint8TimingSafeEqual;
+exports.uint8Equal = uint8Equal;
+exports.removeAt = removeAt;
+exports.intToBytes = intToBytes;
+exports.readAllBytes = readAllBytes;
+const node_crypto_1 = require("node:crypto");
+exports.TEXT_ENCODER = new TextEncoder();
+exports.TEXT_DECODER = new TextDecoder();
+exports.EMPTY_BYTES = Object.freeze(new Uint8Array(0));
+const HEX_CHARS = '0123456789abcdef';
+const HEX_TABLE = /* @__PURE__ */ (() => {
+    const table = new Array(256);
+    for (let i = 0; i < 256; i += 1) {
+        table[i] = HEX_CHARS[i >> 4] + HEX_CHARS[i & 0x0f];
+    }
+    return table;
+})();
+const HEX_LOOKUP = /* @__PURE__ */ (() => {
+    const table = new Int8Array(128).fill(-1);
+    for (let i = 0x30; i <= 0x39; i += 1)
+        table[i] = i - 0x30;
+    for (let i = 0x41; i <= 0x46; i += 1)
+        table[i] = i - 0x41 + 10;
+    for (let i = 0x61; i <= 0x66; i += 1)
+        table[i] = i - 0x61 + 10;
+    return table;
+})();
+const BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const BASE64URL_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+const BASE64_LOOKUP = /* @__PURE__ */ (() => {
+    const table = new Uint8Array(128).fill(0xff);
+    for (let i = 0; i < BASE64_CHARS.length; i += 1) {
+        table[BASE64_CHARS.charCodeAt(i)] = i;
+    }
+    table[0x3d] = 0; // '='
+    return table;
+})();
+/**
+ * Encodes a Uint8Array to a hex string
+ */
+function bytesToHex(value) {
+    let out = '';
+    for (let i = 0; i < value.length; i += 1) {
+        out += HEX_TABLE[value[i]];
+    }
+    return out;
+}
+/**
+ * Decodes a hex string to a Uint8Array
+ */
+function hexToBytes(value) {
+    const len = value.length;
+    if (len & 1) {
+        throw new Error('hex string must have even length');
+    }
+    const out = new Uint8Array(len >> 1);
+    for (let i = 0; i < len; i += 2) {
+        const hiCode = value.charCodeAt(i);
+        const loCode = value.charCodeAt(i + 1);
+        const hi = hiCode < 128 ? HEX_LOOKUP[hiCode] : -1;
+        const lo = loCode < 128 ? HEX_LOOKUP[loCode] : -1;
+        if ((hi | lo) < 0) {
+            throw new Error('invalid hex character');
+        }
+        out[i >> 1] = (hi << 4) | lo;
+    }
+    return out;
+}
+function bytesToBase64(value) {
+    return encodeBase64(value, BASE64_CHARS, true);
+}
+function base64ToBytes(value) {
+    const len = value.length;
+    if (len === 0)
+        return exports.EMPTY_BYTES;
+    if ((len & 3) !== 0) {
+        throw new Error('base64 string length must be multiple of 4');
+    }
+    let padding = 0;
+    if (value.charCodeAt(len - 1) === 0x3d)
+        padding += 1;
+    if (value.charCodeAt(len - 2) === 0x3d)
+        padding += 1;
+    const outLen = ((len * 3) >> 2) - padding;
+    const out = new Uint8Array(outLen);
+    let j = 0;
+    const mainLen = len - 4;
+    let i = 0;
+    for (; i < mainLen; i += 4) {
+        const a = lookupBase64(value.charCodeAt(i));
+        const b = lookupBase64(value.charCodeAt(i + 1));
+        const c = lookupBase64(value.charCodeAt(i + 2));
+        const d = lookupBase64(value.charCodeAt(i + 3));
+        out[j++] = (a << 2) | (b >> 4);
+        out[j++] = ((b & 0x0f) << 4) | (c >> 2);
+        out[j++] = ((c & 0x03) << 6) | d;
+    }
+    if (padding === 0) {
+        const a = lookupBase64(value.charCodeAt(i));
+        const b = lookupBase64(value.charCodeAt(i + 1));
+        const c = lookupBase64(value.charCodeAt(i + 2));
+        const d = lookupBase64(value.charCodeAt(i + 3));
+        out[j++] = (a << 2) | (b >> 4);
+        out[j++] = ((b & 0x0f) << 4) | (c >> 2);
+        out[j++] = ((c & 0x03) << 6) | d;
+    }
+    else if (padding === 1) {
+        const a = lookupBase64(value.charCodeAt(i));
+        const b = lookupBase64(value.charCodeAt(i + 1));
+        const c = lookupBase64(value.charCodeAt(i + 2));
+        out[j++] = (a << 2) | (b >> 4);
+        out[j++] = ((b & 0x0f) << 4) | (c >> 2);
+    }
+    else {
+        const a = lookupBase64(value.charCodeAt(i));
+        const b = lookupBase64(value.charCodeAt(i + 1));
+        out[j++] = (a << 2) | (b >> 4);
+    }
+    return out;
+}
+function lookupBase64(code) {
+    if (code > 127) {
+        throw new Error('invalid base64 character');
+    }
+    const v = BASE64_LOOKUP[code];
+    if (v === 0xff) {
+        throw new Error('invalid base64 character');
+    }
+    return v;
+}
+/**
+ * Encodes a Uint8Array to a base64url string (URL-safe, no padding)
+ */
+function bytesToBase64UrlSafe(value) {
+    return encodeBase64(value, BASE64URL_CHARS, false);
+}
+function encodeBase64(value, alphabet, pad) {
+    const len = value.length;
+    if (len === 0)
+        return '';
+    const remainder = len % 3;
+    const mainLen = len - remainder;
+    const chunks = Math.ceil(len / 3);
+    const out = new Array(pad ? chunks * 4 : Math.ceil((len * 4) / 3));
+    let k = 0;
+    for (let i = 0; i < mainLen; i += 3) {
+        const a = value[i];
+        const b = value[i + 1];
+        const c = value[i + 2];
+        out[k++] = alphabet[a >> 2];
+        out[k++] = alphabet[((a & 0x03) << 4) | (b >> 4)];
+        out[k++] = alphabet[((b & 0x0f) << 2) | (c >> 6)];
+        out[k++] = alphabet[c & 0x3f];
+    }
+    if (remainder === 1) {
+        const a = value[mainLen];
+        out[k++] = alphabet[a >> 2];
+        out[k++] = alphabet[(a & 0x03) << 4];
+        if (pad) {
+            out[k++] = '=';
+            out[k++] = '=';
+        }
+    }
+    else if (remainder === 2) {
+        const a = value[mainLen];
+        const b = value[mainLen + 1];
+        out[k++] = alphabet[a >> 2];
+        out[k++] = alphabet[((a & 0x03) << 4) | (b >> 4)];
+        out[k++] = alphabet[(b & 0x0f) << 2];
+        if (pad) {
+            out[k++] = '=';
+        }
+    }
+    return out.join('');
+}
+function concatBytes(parts) {
+    const total = parts.reduce((sum, current) => sum + current.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.length;
+    }
+    return out;
+}
+function toBytesView(value) {
+    if (value instanceof Uint8Array) {
+        if (value.constructor === Uint8Array) {
+            return value;
+        }
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    }
+    if (ArrayBuffer.isView(value)) {
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    }
+    return new Uint8Array(value);
+}
+function toChunkBytes(chunk) {
+    if (chunk instanceof Uint8Array) {
+        return chunk;
+    }
+    if (chunk instanceof ArrayBuffer) {
+        return new Uint8Array(chunk);
+    }
+    if (typeof chunk === 'string') {
+        return exports.TEXT_ENCODER.encode(chunk);
+    }
+    if (ArrayBuffer.isView(chunk)) {
+        return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+    }
+    throw new Error(`unsupported stream chunk type: ${typeof chunk}`);
+}
+function uint8TimingSafeEqual(left, right) {
+    if (left.byteLength !== right.byteLength) {
+        return false;
+    }
+    return (0, node_crypto_1.timingSafeEqual)(left, right);
+}
+function uint8Equal(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    let diff = 0;
+    for (let i = 0; i < a.length; i += 1) {
+        diff |= a[i] ^ b[i];
+    }
+    return diff === 0;
+}
+function removeAt(items, index) {
+    const out = [];
+    for (let i = 0; i < items.length; i += 1) {
+        if (i !== index) {
+            out.push(items[i]);
+        }
+    }
+    return out;
+}
+function intToBytes(byteLength, value) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`invalid integer value: ${value}`);
+    }
+    const out = new Uint8Array(byteLength);
+    let current = value;
+    for (let i = byteLength - 1; i >= 0; i -= 1) {
+        out[i] = current & 0xff;
+        current = Math.floor(current / 256);
+    }
+    return out;
+}
+async function readAllBytes(stream, options = {}) {
+    const maxBytes = options.maxBytes;
+    if (maxBytes !== undefined && (!Number.isSafeInteger(maxBytes) || maxBytes < 0)) {
+        throw new Error(`invalid max bytes limit: ${maxBytes}`);
+    }
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of stream) {
+        const bytes = toChunkBytes(chunk);
+        chunks.push(bytes);
+        total += bytes.byteLength;
+        if (maxBytes !== undefined && total > maxBytes) {
+            const error = new Error(`stream exceeded max bytes limit (${maxBytes})`);
+            stream.destroy(error);
+            throw error;
+        }
+    }
+    if (total === 0) {
+        return exports.EMPTY_BYTES;
+    }
+    if (chunks.length === 1) {
+        return chunks[0];
+    }
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        merged.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return merged;
+}

package/dist/util/coercion.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asNumber = asNumber;
+exports.asOptionalNumber = asOptionalNumber;
+exports.asString = asString;
+exports.asOptionalString = asOptionalString;
+exports.asBytes = asBytes;
+exports.asOptionalBytes = asOptionalBytes;
+exports.toBoolOrUndef = toBoolOrUndef;
+exports.resolvePositive = resolvePositive;
+const bytes_1 = require("./bytes");
+const primitives_1 = require("./primitives");
+function asNumber(value, field) {
+    if (typeof value === 'bigint') {
+        return (0, primitives_1.toSafeNumber)(Number(value), field);
+    }
+    if (typeof value === 'number') {
+        return (0, primitives_1.toSafeNumber)(value, field);
+    }
+    throw new Error(`invalid number value for ${field}`);
+}
+function asOptionalNumber(value, field = 'optional number') {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    return asNumber(value, field);
+}
+function asString(value, field) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    throw new Error(`invalid string value for ${field}`);
+}
+function asOptionalString(value, field = 'optional string') {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    return asString(value, field);
+}
+function asBytes(value, field) {
+    if (value instanceof Uint8Array || value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+        return (0, bytes_1.toBytesView)(value);
+    }
+    throw new Error(`invalid bytes value for ${field}`);
+}
+function asOptionalBytes(value, field = 'optional bytes') {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    return asBytes(value, field);
+}
+function toBoolOrUndef(value) {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    return Boolean(value);
+}
+function resolvePositive(value, fallback, name) {
+    if (value === undefined) {
+        return fallback;
+    }
+    if (Number.isSafeInteger(value) && value > 0) {
+        return value;
+    }
+    throw new Error(`${name} must be a positive safe integer`);
+}

package/dist/util/collections.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCleanupIntervalMs = resolveCleanupIntervalMs;
+exports.normalizeQueryLimit = normalizeQueryLimit;
+exports.setBoundedMapEntry = setBoundedMapEntry;
+function resolveCleanupIntervalMs(ttlMs, maxIntervalMs = 60000) {
+    if (ttlMs <= 1000) {
+        return ttlMs;
+    }
+    return Math.min(maxIntervalMs, Math.floor(ttlMs / 2));
+}
+function normalizeQueryLimit(limit, defaultLimit) {
+    if (limit === undefined) {
+        return defaultLimit;
+    }
+    if (!Number.isSafeInteger(limit) || limit <= 0) {
+        throw new Error(`invalid query limit: ${limit}`);
+    }
+    return limit;
+}
+function setBoundedMapEntry(map, key, value, maxEntries, onEvict) {
+    map.delete(key);
+    map.set(key, value);
+    while (map.size > maxEntries) {
+        const oldest = map.entries().next().value;
+        if (!oldest) {
+            break;
+        }
+        map.delete(oldest[0]);
+        onEvict?.(oldest[0], oldest[1]);
+    }
+}

package/dist/util/primitives.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toError = toError;
+exports.toSafeNumber = toSafeNumber;
+exports.longToNumber = longToNumber;
+function toError(value) {
+    if (value instanceof Error) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return new Error(value);
+    }
+    return new Error('unknown error');
+}
+function assertSafeInteger(value, field, nullishBehavior) {
+    if (!Number.isFinite(value) || !Number.isSafeInteger(value)) {
+        const prefix = nullishBehavior === 'throw' ? `invalid ${field}` : 'invalid long numeric value';
+        throw new Error(`${prefix}: ${value}`);
+    }
+    return value;
+}
+function toSafeNumber(value, field) {
+    if (value === null || value === undefined) {
+        throw new Error(`missing ${field}`);
+    }
+    const numeric = typeof value === 'number' ? value : value.toNumber?.();
+    if (typeof numeric !== 'number') {
+        throw new Error(`invalid ${field}`);
+    }
+    return assertSafeInteger(numeric, field, 'throw');
+}
+function longToNumber(value) {
+    if (value === null || value === undefined) {
+        return 0;
+    }
+    return assertSafeInteger(typeof value === 'number' ? value : value.toNumber(), '', 'zero');
+}

package/dist/util/runtime.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRuntimeOsDisplayName = getRuntimeOsDisplayName;
+exports.isBunRuntime = isBunRuntime;
+function getRuntimeOsDisplayName() {
+    switch (process.platform) {
+        case 'win32':
+            return 'Windows';
+        case 'darwin':
+            return 'Mac OS';
+        case 'linux':
+            return 'Linux';
+        default:
+            return process.platform;
+    }
+}
+function isBunRuntime() {
+    return typeof globalThis.Bun !== 'undefined';
+}

package/dist/util/signal-address.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signalAddressKey = signalAddressKey;
+const constants_1 = require("../protocol/constants");
+function signalAddressKey(address) {
+    const server = address.server ?? constants_1.WA_DEFAULTS.HOST_DOMAIN;
+    return `${address.user}|${server}|${address.device}`;
+}

package/package.json

@@ -0,0 +1,150 @@
+{
+    "name": "zapo-js",
+    "version": "0.1.0",
+    "description": "High-performance WhatsApp Web TypeScript library",
+    "main": "dist/index.js",
+    "module": "dist/esm/index.js",
+    "types": "dist/types/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/types/index.d.ts",
+            "require": "./dist/index.js",
+            "import": "./dist/esm/index.js",
+            "default": "./dist/index.js"
+        },
+        "./client": {
+            "types": "./dist/types/client/index.d.ts",
+            "require": "./dist/client/index.js",
+            "import": "./dist/esm/client/index.js",
+            "default": "./dist/client/index.js"
+        },
+        "./appstate": {
+            "types": "./dist/types/appstate/index.d.ts",
+            "require": "./dist/appstate/index.js",
+            "import": "./dist/esm/appstate/index.js",
+            "default": "./dist/appstate/index.js"
+        },
+        "./auth": {
+            "types": "./dist/types/auth/index.d.ts",
+            "require": "./dist/auth/index.js",
+            "import": "./dist/esm/auth/index.js",
+            "default": "./dist/auth/index.js"
+        },
+        "./crypto": {
+            "types": "./dist/types/crypto/index.d.ts",
+            "require": "./dist/crypto/index.js",
+            "import": "./dist/esm/crypto/index.js",
+            "default": "./dist/crypto/index.js"
+        },
+        "./media": {
+            "types": "./dist/types/media/index.d.ts",
+            "require": "./dist/media/index.js",
+            "import": "./dist/esm/media/index.js",
+            "default": "./dist/media/index.js"
+        },
+        "./message": {
+            "types": "./dist/types/message/index.d.ts",
+            "require": "./dist/message/index.js",
+            "import": "./dist/esm/message/index.js",
+            "default": "./dist/message/index.js"
+        },
+        "./signal": {
+            "types": "./dist/types/signal/index.d.ts",
+            "require": "./dist/signal/index.js",
+            "import": "./dist/esm/signal/index.js",
+            "default": "./dist/signal/index.js"
+        },
+        "./store": {
+            "types": "./dist/types/store/index.d.ts",
+            "require": "./dist/store/index.js",
+            "import": "./dist/esm/store/index.js",
+            "default": "./dist/store/index.js"
+        },
+        "./transport": {
+            "types": "./dist/types/transport/index.d.ts",
+            "require": "./dist/transport/index.js",
+            "import": "./dist/esm/transport/index.js",
+            "default": "./dist/transport/index.js"
+        },
+        "./proto": {
+            "types": "./dist/types/proto.d.ts",
+            "require": "./dist/proto.js",
+            "import": "./dist/esm/proto.js",
+            "default": "./dist/proto.js"
+        },
+        "./package.json": "./package.json"
+    },
+    "files": [
+        "dist",
+        "proto/index.js",
+        "proto/index.d.ts",
+        "scripts/check-node-version.cjs"
+    ],
+    "engines": {
+        "node": ">=20.9.0"
+    },
+    "scripts": {
+        "preinstall": "node ./scripts/check-node-version.cjs",
+        "changeset": "changeset",
+        "changeset:status": "changeset status --verbose",
+        "version:packages": "changeset version",
+        "release:publish": "npm run build && changeset publish",
+        "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+        "build:cjs": "tsc -p tsconfig.build.cjs.json && tsc-alias -p tsconfig.build.cjs.json",
+        "build:esm": "tsc -p tsconfig.build.esm.json && tsc-alias -p tsconfig.build.esm.json",
+        "build:types": "tsc -p tsconfig.build.types.json && tsc-alias -p tsconfig.build.types.json",
+        "build:esm:finalize": "node ./scripts/finalize-esm-build.cjs",
+        "build": "npm run clean && npm run build:cjs && npm run build:esm && npm run build:types && npm run build:esm:finalize",
+        "proto:generate": "node ./scripts/generate-proto.cjs",
+        "example": "tsx examples/example.ts",
+        "test:structure": "node ./scripts/check-tests-structure.cjs",
+        "test": "npm run test:structure && node --import tsx --test --test-skip-pattern \"\\\\[flow\\\\]\" \"src/**/__tests__/**/*.test.ts\"",
+        "test:watch": "node --import tsx --test --watch --test-skip-pattern \"\\\\[flow\\\\]\" \"src/**/__tests__/**/*.test.ts\"",
+        "test:flow": "node --import tsx --test --test-concurrency=1 \"src/**/__tests__/**/*.flow.test.ts\"",
+        "test:flow:watch": "node --import tsx --test --watch --test-concurrency=1 \"src/**/__tests__/**/*.flow.test.ts\"",
+        "test:coverage": "npm run test:structure && c8 --all --include \"src/**/*.ts\" --exclude \"src/**/*.d.ts\" --exclude \"src/**/__tests__/**\" --exclude \"src/**/types.ts\" --exclude \"src/store/contracts/**/*.ts\" --reporter text --reporter html --reporter lcov node --import tsx --test --test-skip-pattern \"\\\\[flow\\\\]\" \"src/**/__tests__/**/*.test.ts\"",
+        "test:coverage:open": "node -e \"require('node:child_process').execSync(process.platform === 'win32' ? 'start coverage\\\\index.html' : process.platform === 'darwin' ? 'open coverage/index.html' : 'xdg-open coverage/index.html', { stdio: 'inherit' })\"",
+        "typecheck": "tsc -p tsconfig.json --noEmit",
+        "lint": "eslint \"src/**/*.{ts,js}\"",
+        "lint:fix": "eslint \"src/**/*.{ts,js}\" --fix",
+        "format": "prettier . --write",
+        "format:check": "prettier . --check"
+    },
+    "dependencies": {
+        "protobufjs": "^7.5.4"
+    },
+    "peerDependencies": {
+        "better-sqlite3": "^11.9.1",
+        "pino": "^9.0.0",
+        "pino-pretty": "^13.0.0"
+    },
+    "peerDependenciesMeta": {
+        "better-sqlite3": {
+            "optional": true
+        },
+        "pino": {
+            "optional": true
+        },
+        "pino-pretty": {
+            "optional": true
+        }
+    },
+    "devDependencies": {
+        "@changesets/cli": "^2.30.0",
+        "@types/node": "^22.13.14",
+        "@typescript-eslint/parser": "^8.56.1",
+        "@vinikjkkj/eslint-config": "^1.0.0",
+        "better-sqlite3": "^12.6.2",
+        "c8": "^11.0.0",
+        "eslint": "^9.39.4",
+        "eslint-plugin-import": "^2.32.0",
+        "pino": "^10.3.1",
+        "pino-pretty": "^13.1.3",
+        "prettier": "^3.8.1",
+        "tsc-alias": "^1.8.16",
+        "tsx": "^4.20.6",
+        "typescript": "^5.7.3",
+        "typescript-eslint": "^8.56.1"
+    }
+}
+