Initial commit: notification-elements-demo app

Interactive Angular 19 demo for @sda/notification-elements-ui with
6 sections: Bell & Feed, Notification Center, Inbox, Comments &
Threads, Mention Input, and Full-Featured layout. Includes mock
data, dark mode toggle, and real-time event log.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

node_modules/@jsonjoy.com/json-pack/lib/resp/RespDecoder.d.ts

@@ -0,0 +1,40 @@
+import type { IReader, IReaderResettable } from '@jsonjoy.com/buffers/lib';
+import type { BinaryJsonDecoder, PackValue } from '../types';
+export declare class RespDecoder<R extends IReader & IReaderResettable = IReader & IReaderResettable> implements BinaryJsonDecoder {
+    reader: R;
+    tryUtf8: boolean;
+    constructor(reader?: R);
+    read(uint8: Uint8Array): PackValue;
+    decode(uint8: Uint8Array): unknown;
+    val(): unknown;
+    readAny(): unknown;
+    protected readLength(): number;
+    readCmd(): [cmd: string, ...args: Uint8Array[]];
+    readBool(): boolean;
+    readInt(): number;
+    readFloat(): number;
+    readBigint(): bigint;
+    readStrSimple(): string;
+    readStrBulk(): Uint8Array | string | null;
+    readAsciiAsStrBulk(): string;
+    readStrVerbatim(): string | Uint8Array;
+    readErrSimple(): Error;
+    readErrBulk(): Error;
+    readArr(): unknown[] | null;
+    readSet(): Set<unknown>;
+    readObj(): Record<string, unknown>;
+    skipN(n: number): void;
+    skipAny(): void;
+    skipBool(): void;
+    skipInt(): void;
+    skipFloat(): void;
+    skipBigint(): void;
+    skipStrSimple(): void;
+    skipStrBulk(): void;
+    skipStrVerbatim(): void;
+    skipErrSimple(): void;
+    skipErrBulk(): void;
+    skipArr(): void;
+    skipSet(): void;
+    skipObj(): void;
+}

node_modules/@jsonjoy.com/json-pack/lib/resp/RespDecoder.js

@@ -0,0 +1,391 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RespDecoder = void 0;
+const Reader_1 = require("@jsonjoy.com/buffers/lib/Reader");
+const extensions_1 = require("./extensions");
+const isUtf8_1 = require("@jsonjoy.com/buffers/lib/utf8/isUtf8");
+class RespDecoder {
+    constructor(reader = new Reader_1.Reader()) {
+        this.reader = reader;
+        this.tryUtf8 = false;
+    }
+    read(uint8) {
+        this.reader.reset(uint8);
+        return this.readAny();
+    }
+    decode(uint8) {
+        this.reader.reset(uint8);
+        return this.readAny();
+    }
+    val() {
+        return this.readAny();
+    }
+    readAny() {
+        const reader = this.reader;
+        const type = reader.u8();
+        switch (type) {
+            case 58:
+                return this.readInt();
+            case 44:
+                return this.readFloat();
+            case 43:
+                return this.readStrSimple();
+            case 36:
+                return this.readStrBulk();
+            case 35:
+                return this.readBool();
+            case 95:
+                return reader.skip(2), null;
+            case 37:
+                return this.readObj();
+            case 42:
+                return this.readArr();
+            case 61:
+                return this.readStrVerbatim();
+            case 62:
+                return new extensions_1.RespPush(this.readArr() || []);
+            case 40:
+                return this.readBigint();
+            case 126:
+                return this.readSet();
+            case 45:
+                return this.readErrSimple();
+            case 33:
+                return this.readErrBulk();
+            case 124:
+                return new extensions_1.RespAttributes(this.readObj());
+        }
+        throw new Error('UNKNOWN_TYPE');
+    }
+    readLength() {
+        const reader = this.reader;
+        let number = 0;
+        while (true) {
+            const c = reader.u8();
+            if (c === 13)
+                return reader.skip(1), number;
+            number = number * 10 + (c - 48);
+        }
+    }
+    readCmd() {
+        const reader = this.reader;
+        const type = reader.u8();
+        if (type !== 42)
+            throw new Error('INVALID_COMMAND');
+        const c = reader.peak();
+        if (c === 45)
+            throw new Error('INVALID_COMMAND');
+        const length = this.readLength();
+        if (length === 0)
+            throw new Error('INVALID_COMMAND');
+        const cmd = this.readAsciiAsStrBulk().toUpperCase();
+        const args = [cmd];
+        this.tryUtf8 = false;
+        for (let i = 1; i < length; i++) {
+            const type = reader.u8();
+            if (type !== 36)
+                throw new Error('INVALID_COMMAND');
+            args.push(this.readStrBulk());
+        }
+        return args;
+    }
+    readBool() {
+        const reader = this.reader;
+        const c = reader.u8();
+        reader.skip(2);
+        return c === 116;
+    }
+    readInt() {
+        const reader = this.reader;
+        let negative = false;
+        let c = reader.u8();
+        let number = 0;
+        if (c === 45) {
+            negative = true;
+        }
+        else if (c !== 43)
+            number = c - 48;
+        while (true) {
+            c = reader.u8();
+            if (c === 13) {
+                reader.skip(1);
+                return negative ? -number : number;
+            }
+            number = number * 10 + (c - 48);
+        }
+    }
+    readFloat() {
+        const reader = this.reader;
+        const x = reader.x;
+        while (true) {
+            const c = reader.u8();
+            if (c !== 13)
+                continue;
+            const length = reader.x - x - 1;
+            reader.x = x;
+            const str = reader.ascii(length);
+            switch (length) {
+                case 3:
+                    switch (str) {
+                        case 'inf':
+                            return reader.skip(2), Infinity;
+                        case 'nan':
+                            return reader.skip(2), NaN;
+                    }
+                    break;
+                case 4:
+                    if (str === '-inf') {
+                        return reader.skip(2), -Infinity;
+                    }
+                    break;
+            }
+            reader.skip(2);
+            return Number(str);
+        }
+    }
+    readBigint() {
+        const reader = this.reader;
+        const x = reader.x;
+        while (true) {
+            const c = reader.u8();
+            if (c !== 13)
+                continue;
+            const length = reader.x - x;
+            reader.x = x;
+            const str = reader.ascii(length);
+            reader.skip(1);
+            return BigInt(str);
+        }
+    }
+    readStrSimple() {
+        const reader = this.reader;
+        const x = reader.x;
+        while (true) {
+            const c = reader.u8();
+            if (c !== 13)
+                continue;
+            const size = reader.x - x - 1;
+            reader.x = x;
+            const str = reader.utf8(size);
+            reader.skip(2);
+            return str;
+        }
+    }
+    readStrBulk() {
+        const reader = this.reader;
+        if (reader.peak() === 45) {
+            reader.skip(4);
+            return null;
+        }
+        const length = this.readLength();
+        let res;
+        if (this.tryUtf8 && (0, isUtf8_1.isUtf8)(reader.uint8, reader.x, length))
+            res = reader.utf8(length);
+        else
+            res = reader.buf(length);
+        reader.skip(2);
+        return res;
+    }
+    readAsciiAsStrBulk() {
+        const reader = this.reader;
+        reader.skip(1);
+        const length = this.readLength();
+        const buf = reader.ascii(length);
+        reader.skip(2);
+        return buf;
+    }
+    readStrVerbatim() {
+        const reader = this.reader;
+        const length = this.readLength();
+        const u32 = reader.u32();
+        const isTxt = u32 === 1954051130;
+        if (isTxt) {
+            const str = reader.utf8(length - 4);
+            reader.skip(2);
+            return str;
+        }
+        const buf = reader.buf(length - 4);
+        reader.skip(2);
+        return buf;
+    }
+    readErrSimple() {
+        const reader = this.reader;
+        const x = reader.x;
+        while (true) {
+            const c = reader.u8();
+            if (c !== 13)
+                continue;
+            const size = reader.x - x - 1;
+            reader.x = x;
+            const str = reader.utf8(size);
+            reader.skip(2);
+            return new Error(str);
+        }
+    }
+    readErrBulk() {
+        const reader = this.reader;
+        const length = this.readLength();
+        const message = reader.utf8(length);
+        reader.skip(2);
+        return new Error(message);
+    }
+    readArr() {
+        const reader = this.reader;
+        const c = reader.peak();
+        if (c === 45) {
+            reader.skip(4);
+            return null;
+        }
+        const length = this.readLength();
+        const arr = [];
+        for (let i = 0; i < length; i++)
+            arr.push(this.readAny());
+        return arr;
+    }
+    readSet() {
+        const length = this.readLength();
+        const set = new Set();
+        for (let i = 0; i < length; i++)
+            set.add(this.readAny());
+        return set;
+    }
+    readObj() {
+        const length = this.readLength();
+        const obj = {};
+        for (let i = 0; i < length; i++) {
+            const key = this.readAny() + '';
+            obj[key] = this.readAny();
+        }
+        return obj;
+    }
+    skipN(n) {
+        for (let i = 0; i < n; i++)
+            this.skipAny();
+    }
+    skipAny() {
+        const reader = this.reader;
+        const type = reader.u8();
+        switch (type) {
+            case 58:
+                return this.skipInt();
+            case 44:
+                return this.skipFloat();
+            case 43:
+                return this.skipStrSimple();
+            case 36:
+                return this.skipStrBulk();
+            case 35:
+                return this.skipBool();
+            case 95:
+                return reader.skip(2);
+            case 37:
+                return this.skipObj();
+            case 42:
+                return this.skipArr();
+            case 61:
+                return this.skipStrVerbatim();
+            case 62:
+                return this.skipArr();
+            case 40:
+                return this.skipBigint();
+            case 126:
+                return this.skipSet();
+            case 45:
+                return this.skipErrSimple();
+            case 33:
+                return this.skipErrBulk();
+            case 124:
+                return this.skipObj();
+        }
+        throw new Error('UNKNOWN_TYPE');
+    }
+    skipBool() {
+        this.reader.skip(3);
+    }
+    skipInt() {
+        const reader = this.reader;
+        while (true) {
+            if (reader.u8() !== 13)
+                continue;
+            reader.skip(1);
+            return;
+        }
+    }
+    skipFloat() {
+        const reader = this.reader;
+        while (true) {
+            if (reader.u8() !== 13)
+                continue;
+            reader.skip(1);
+            return;
+        }
+    }
+    skipBigint() {
+        const reader = this.reader;
+        while (true) {
+            if (reader.u8() !== 13)
+                continue;
+            reader.skip(1);
+            return;
+        }
+    }
+    skipStrSimple() {
+        const reader = this.reader;
+        while (true) {
+            if (reader.u8() !== 13)
+                continue;
+            reader.skip(1);
+            return;
+        }
+    }
+    skipStrBulk() {
+        const reader = this.reader;
+        if (reader.peak() === 45) {
+            reader.skip(4);
+            return;
+        }
+        reader.skip(this.readLength() + 2);
+    }
+    skipStrVerbatim() {
+        const length = this.readLength();
+        this.reader.skip(length + 2);
+    }
+    skipErrSimple() {
+        const reader = this.reader;
+        while (true) {
+            if (reader.u8() !== 13)
+                continue;
+            reader.skip(1);
+            return;
+        }
+    }
+    skipErrBulk() {
+        const length = this.readLength();
+        this.reader.skip(length + 2);
+    }
+    skipArr() {
+        const reader = this.reader;
+        const c = reader.peak();
+        if (c === 45) {
+            reader.skip(4);
+            return;
+        }
+        const length = this.readLength();
+        for (let i = 0; i < length; i++)
+            this.skipAny();
+    }
+    skipSet() {
+        const length = this.readLength();
+        for (let i = 0; i < length; i++)
+            this.skipAny();
+    }
+    skipObj() {
+        const length = this.readLength();
+        for (let i = 0; i < length; i++) {
+            this.skipAny();
+            this.skipAny();
+        }
+    }
+}
+exports.RespDecoder = RespDecoder;
+//# sourceMappingURL=RespDecoder.js.map

node_modules/@jsonjoy.com/json-pack/lib/resp/RespEncoder.d.ts

@@ -0,0 +1,60 @@
+import type { IWriter, IWriterGrowable } from '@jsonjoy.com/buffers/lib';
+import type { BinaryJsonEncoder, StreamingBinaryJsonEncoder, TlvBinaryJsonEncoder } from '../types';
+import type { Slice } from '@jsonjoy.com/buffers/lib/Slice';
+export declare class RespEncoder<W extends IWriter & IWriterGrowable = IWriter & IWriterGrowable> implements BinaryJsonEncoder, StreamingBinaryJsonEncoder, TlvBinaryJsonEncoder {
+    readonly writer: W;
+    constructor(writer?: W);
+    encode(value: unknown): Uint8Array;
+    encodeToSlice(value: unknown): Slice;
+    writeAny(value: unknown): void;
+    protected writeLength(length: number): void;
+    encodeCmd(args: unknown[]): Uint8Array;
+    writeCmd(args: unknown[]): void;
+    encodeCmdUtf8(args: unknown[]): Uint8Array;
+    writeCmdUtf8(args: unknown[]): void;
+    writeArgUtf8(arg: unknown): void;
+    writeNull(): void;
+    writeNullStr(): void;
+    writeNullArr(): void;
+    writeBoolean(bool: boolean): void;
+    writeNumber(num: number): void;
+    writeBigInt(int: bigint): void;
+    writeInteger(int: number): void;
+    writeUInteger(uint: number): void;
+    writeFloat(float: number): void;
+    writeBin(buf: Uint8Array): void;
+    writeBinHdr(length: number): void;
+    writeStr(str: string): void;
+    writeStrHdr(length: number): void;
+    writeSimpleStr(str: string): void;
+    writeSimpleStrAscii(str: string): void;
+    writeBulkStr(str: string): void;
+    writeBulkStrAscii(str: string): void;
+    writeAsciiStr(str: string): void;
+    writeVerbatimStr(encoding: string, str: string): void;
+    writeErr(str: string): void;
+    writeSimpleErr(str: string): void;
+    writeBulkErr(str: string): void;
+    writeArr(arr: unknown[]): void;
+    writeArrHdr(length: number): void;
+    writeObj(obj: Record<string, unknown>): void;
+    writeObjHdr(length: number): void;
+    writeAttr(obj: Record<string, unknown>): void;
+    writeSet(set: Set<unknown>): void;
+    writePush(elements: unknown[]): void;
+    writeUnknown(value: unknown): void;
+    writeUndef(): void;
+    protected writeRn(): void;
+    writeStartStr(): void;
+    writeStrChunk(str: string): void;
+    writeEndStr(): void;
+    writeStartBin(): void;
+    writeBinChunk(buf: Uint8Array): void;
+    writeEndBin(): void;
+    writeStartArr(): void;
+    writeArrChunk(item: unknown): void;
+    writeEndArr(): void;
+    writeStartObj(): void;
+    writeObjChunk(key: string, value: unknown): void;
+    writeEndObj(): void;
+}

node_modules/@jsonjoy.com/json-pack/lib/resp/RespEncoder.js

@@ -0,0 +1,424 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RespEncoder = void 0;
+const Writer_1 = require("@jsonjoy.com/buffers/lib/Writer");
+const utf8_1 = require("@jsonjoy.com/util/lib/strings/utf8");
+const extensions_1 = require("./extensions");
+const JsonPackExtension_1 = require("../JsonPackExtension");
+const REG_RN = /[\r\n]/;
+const isSafeInteger = Number.isSafeInteger;
+class RespEncoder {
+    constructor(writer = new Writer_1.Writer()) {
+        this.writer = writer;
+    }
+    encode(value) {
+        this.writeAny(value);
+        return this.writer.flush();
+    }
+    encodeToSlice(value) {
+        this.writeAny(value);
+        return this.writer.flushSlice();
+    }
+    writeAny(value) {
+        switch (typeof value) {
+            case 'number':
+                return this.writeNumber(value);
+            case 'string':
+                return this.writeStr(value);
+            case 'boolean':
+                return this.writeBoolean(value);
+            case 'object': {
+                if (!value)
+                    return this.writeNull();
+                if (value instanceof Array)
+                    return this.writeArr(value);
+                if (value instanceof Uint8Array)
+                    return this.writeBin(value);
+                if (value instanceof Error)
+                    return this.writeErr(value.message);
+                if (value instanceof Set)
+                    return this.writeSet(value);
+                if (value instanceof JsonPackExtension_1.JsonPackExtension) {
+                    if (value instanceof extensions_1.RespPush)
+                        return this.writePush(value.val);
+                    if (value instanceof extensions_1.RespVerbatimString)
+                        return this.writeVerbatimStr('txt', value.val);
+                    if (value instanceof extensions_1.RespAttributes)
+                        return this.writeAttr(value.val);
+                }
+                return this.writeObj(value);
+            }
+            case 'undefined':
+                return this.writeUndef();
+            case 'bigint':
+                return this.writeBigInt(value);
+            default:
+                return this.writeUnknown(value);
+        }
+    }
+    writeLength(length) {
+        const writer = this.writer;
+        if (length < 100) {
+            if (length < 10) {
+                writer.u8(length + 48);
+                return;
+            }
+            const octet1 = length % 10;
+            const octet2 = (length - octet1) / 10;
+            writer.u16(((octet2 + 48) << 8) + octet1 + 48);
+            return;
+        }
+        let digits = 1;
+        let pow = 10;
+        while (length >= pow) {
+            digits++;
+            pow *= 10;
+        }
+        writer.ensureCapacity(digits);
+        const uint8 = writer.uint8;
+        const x = writer.x;
+        const newX = x + digits;
+        let i = newX - 1;
+        while (i >= x) {
+            const remainder = length % 10;
+            uint8[i--] = remainder + 48;
+            length = (length - remainder) / 10;
+        }
+        writer.x = newX;
+    }
+    encodeCmd(args) {
+        this.writeCmd(args);
+        return this.writer.flush();
+    }
+    writeCmd(args) {
+        const length = args.length;
+        this.writeArrHdr(length);
+        for (let i = 0; i < length; i++) {
+            const arg = args[i];
+            if (arg instanceof Uint8Array)
+                this.writeBin(arg);
+            else
+                this.writeBulkStrAscii(arg + '');
+        }
+    }
+    encodeCmdUtf8(args) {
+        this.writeCmdUtf8(args);
+        return this.writer.flush();
+    }
+    writeCmdUtf8(args) {
+        const length = args.length;
+        this.writeArrHdr(length);
+        for (let i = 0; i < length; i++)
+            this.writeArgUtf8(args[i]);
+    }
+    writeArgUtf8(arg) {
+        if (arg instanceof Uint8Array)
+            return this.writeBin(arg);
+        else
+            this.writeBulkStr(arg + '');
+    }
+    writeNull() {
+        this.writer.u8u16(95, 3338);
+    }
+    writeNullStr() {
+        this.writer.u8u32(36, 45 * 0x1000000 +
+            49 * 0x10000 +
+            3338);
+    }
+    writeNullArr() {
+        this.writer.u8u32(42, 45 * 0x1000000 +
+            49 * 0x10000 +
+            3338);
+    }
+    writeBoolean(bool) {
+        this.writer.u32(bool
+            ? 35 * 0x1000000 +
+                116 * 0x10000 +
+                3338
+            : 35 * 0x1000000 +
+                102 * 0x10000 +
+                3338);
+    }
+    writeNumber(num) {
+        if (isSafeInteger(num))
+            this.writeInteger(num);
+        else if (typeof num === 'bigint')
+            this.writeBigInt(num);
+        else
+            this.writeFloat(num);
+    }
+    writeBigInt(int) {
+        const writer = this.writer;
+        writer.u8(40);
+        writer.ascii(int + '');
+        writer.u16(3338);
+    }
+    writeInteger(int) {
+        const writer = this.writer;
+        writer.u8(58);
+        writer.ascii(int + '');
+        writer.u16(3338);
+    }
+    writeUInteger(uint) {
+        this.writeInteger(uint);
+    }
+    writeFloat(float) {
+        const writer = this.writer;
+        writer.u8(44);
+        switch (float) {
+            case Infinity:
+                writer.u8u16(105, (110 << 8) |
+                    102);
+                break;
+            case -Infinity:
+                writer.u32((45 * 0x1000000 +
+                    105 * 0x10000 +
+                    (110 << 8)) |
+                    102);
+                break;
+            default:
+                if (float !== float)
+                    writer.u8u16(110, (97 << 8) |
+                        110);
+                else
+                    writer.ascii(float + '');
+                break;
+        }
+        writer.u16(3338);
+    }
+    writeBin(buf) {
+        const writer = this.writer;
+        const length = buf.length;
+        writer.u8(36);
+        this.writeLength(length);
+        writer.u16(3338);
+        writer.buf(buf, length);
+        writer.u16(3338);
+    }
+    writeBinHdr(length) {
+        throw new Error('Not implemented');
+    }
+    writeStr(str) {
+        const length = str.length;
+        if (length < 64 && !REG_RN.test(str))
+            this.writeSimpleStr(str);
+        else
+            this.writeVerbatimStr('txt', str);
+    }
+    writeStrHdr(length) {
+        throw new Error('Not implemented');
+    }
+    writeSimpleStr(str) {
+        const writer = this.writer;
+        writer.u8(43);
+        writer.ensureCapacity(str.length << 2);
+        writer.utf8(str);
+        writer.u16(3338);
+    }
+    writeSimpleStrAscii(str) {
+        const writer = this.writer;
+        writer.u8(43);
+        writer.ascii(str);
+        writer.u16(3338);
+    }
+    writeBulkStr(str) {
+        const writer = this.writer;
+        const size = (0, utf8_1.utf8Size)(str);
+        writer.u8(36);
+        this.writeLength(size);
+        writer.u16(3338);
+        writer.ensureCapacity(size);
+        writer.utf8(str);
+        writer.u16(3338);
+    }
+    writeBulkStrAscii(str) {
+        const writer = this.writer;
+        writer.u8(36);
+        this.writeLength(str.length);
+        writer.u16(3338);
+        writer.ascii(str);
+        writer.u16(3338);
+    }
+    writeAsciiStr(str) {
+        const isSimple = !REG_RN.test(str);
+        if (isSimple)
+            this.writeSimpleStr(str);
+        else
+            this.writeBulkStrAscii(str);
+    }
+    writeVerbatimStr(encoding, str) {
+        const writer = this.writer;
+        const size = (0, utf8_1.utf8Size)(str);
+        writer.u8(61);
+        this.writeLength(size + 4);
+        writer.u16(3338);
+        writer.u32(encoding.charCodeAt(0) * 0x1000000 +
+            (encoding.charCodeAt(1) << 16) +
+            (encoding.charCodeAt(2) << 8) +
+            58);
+        writer.ensureCapacity(size);
+        writer.utf8(str);
+        writer.u16(3338);
+    }
+    writeErr(str) {
+        if (str.length < 64 && !REG_RN.test(str))
+            this.writeSimpleErr(str);
+        else
+            this.writeBulkErr(str);
+    }
+    writeSimpleErr(str) {
+        const writer = this.writer;
+        writer.u8(45);
+        writer.ensureCapacity(str.length << 2);
+        writer.utf8(str);
+        writer.u16(3338);
+    }
+    writeBulkErr(str) {
+        const writer = this.writer;
+        const size = (0, utf8_1.utf8Size)(str);
+        writer.u8(33);
+        this.writeLength(size);
+        writer.u16(3338);
+        writer.ensureCapacity(size);
+        writer.utf8(str);
+        writer.u16(3338);
+    }
+    writeArr(arr) {
+        const writer = this.writer;
+        const length = arr.length;
+        writer.u8(42);
+        this.writeLength(length);
+        writer.u16(3338);
+        for (let i = 0; i < length; i++)
+            this.writeAny(arr[i]);
+    }
+    writeArrHdr(length) {
+        const writer = this.writer;
+        writer.u8(42);
+        this.writeLength(length);
+        writer.u16(3338);
+    }
+    writeObj(obj) {
+        const writer = this.writer;
+        const keys = Object.keys(obj);
+        const length = keys.length;
+        writer.u8(37);
+        this.writeLength(length);
+        writer.u16(3338);
+        for (let i = 0; i < length; i++) {
+            const key = keys[i];
+            this.writeStr(key);
+            this.writeAny(obj[key]);
+        }
+    }
+    writeObjHdr(length) {
+        const writer = this.writer;
+        writer.u8(37);
+        this.writeLength(length);
+        writer.u16(3338);
+    }
+    writeAttr(obj) {
+        const writer = this.writer;
+        const keys = Object.keys(obj);
+        const length = keys.length;
+        writer.u8(124);
+        this.writeLength(length);
+        writer.u16(3338);
+        for (let i = 0; i < length; i++) {
+            const key = keys[i];
+            this.writeStr(key);
+            this.writeAny(obj[key]);
+        }
+    }
+    writeSet(set) {
+        const writer = this.writer;
+        const length = set.size;
+        writer.u8(126);
+        this.writeLength(length);
+        writer.u16(3338);
+        for (let i = 0; i < length; i++)
+            set.forEach((value) => this.writeAny(value));
+    }
+    writePush(elements) {
+        const writer = this.writer;
+        const length = elements.length;
+        writer.u8(62);
+        this.writeLength(length);
+        writer.u16(3338);
+        for (let i = 0; i < length; i++)
+            this.writeAny(elements[i]);
+    }
+    writeUnknown(value) {
+        this.writeNull();
+    }
+    writeUndef() {
+        this.writeNull();
+    }
+    writeRn() {
+        this.writer.u16(3338);
+    }
+    writeStartStr() {
+        this.writer.u32(36 * 0x1000000 +
+            (63 << 16) +
+            3338);
+    }
+    writeStrChunk(str) {
+        const writer = this.writer;
+        writer.u8(59);
+        const size = (0, utf8_1.utf8Size)(str);
+        this.writeLength(size);
+        writer.u16(3338);
+        writer.ensureCapacity(size);
+        writer.utf8(str);
+        writer.u16(3338);
+    }
+    writeEndStr() {
+        this.writer.u32(59 * 0x1000000 +
+            (48 << 16) +
+            3338);
+    }
+    writeStartBin() {
+        this.writer.u32(36 * 0x1000000 +
+            (63 << 16) +
+            3338);
+    }
+    writeBinChunk(buf) {
+        const writer = this.writer;
+        const length = buf.length;
+        writer.u8(59);
+        this.writeLength(length);
+        writer.u16(3338);
+        writer.buf(buf, length);
+        writer.u16(3338);
+    }
+    writeEndBin() {
+        this.writer.u32(59 * 0x1000000 +
+            (48 << 16) +
+            3338);
+    }
+    writeStartArr() {
+        this.writer.u32(42 * 0x1000000 +
+            (63 << 16) +
+            3338);
+    }
+    writeArrChunk(item) {
+        this.writeAny(item);
+    }
+    writeEndArr() {
+        this.writer.u8u16(46, 3338);
+    }
+    writeStartObj() {
+        this.writer.u32(37 * 0x1000000 +
+            (63 << 16) +
+            3338);
+    }
+    writeObjChunk(key, value) {
+        this.writeStr(key);
+        this.writeAny(value);
+    }
+    writeEndObj() {
+        this.writer.u8u16(46, 3338);
+    }
+}
+exports.RespEncoder = RespEncoder;
+//# sourceMappingURL=RespEncoder.js.map

node_modules/@jsonjoy.com/json-pack/lib/resp/RespEncoderLegacy.d.ts

@@ -0,0 +1,12 @@
+import { RespEncoder } from './RespEncoder';
+import type { IWriter, IWriterGrowable } from '@jsonjoy.com/buffers/lib';
+export declare class RespEncoderLegacy<W extends IWriter & IWriterGrowable = IWriter & IWriterGrowable> extends RespEncoder<W> {
+    writeAny(value: unknown): void;
+    writeNumber(num: number): void;
+    writeStr(str: string): void;
+    writeNull(): void;
+    writeErr(str: string): void;
+    writeSet(set: Set<unknown>): void;
+    writeArr(arr: unknown[]): void;
+    writeObj(obj: Record<string, unknown>): void;
+}

node_modules/@jsonjoy.com/json-pack/lib/resp/RespEncoderLegacy.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RespEncoderLegacy = void 0;
+const extensions_1 = require("./extensions");
+const JsonPackExtension_1 = require("../JsonPackExtension");
+const RespEncoder_1 = require("./RespEncoder");
+const REG_RN = /[\r\n]/;
+const isSafeInteger = Number.isSafeInteger;
+class RespEncoderLegacy extends RespEncoder_1.RespEncoder {
+    writeAny(value) {
+        switch (typeof value) {
+            case 'number':
+                return this.writeNumber(value);
+            case 'string':
+                return this.writeStr(value);
+            case 'boolean':
+                return this.writeSimpleStr(value ? 'TRUE' : 'FALSE');
+            case 'object': {
+                if (!value)
+                    return this.writeNull();
+                if (value instanceof Array)
+                    return this.writeArr(value);
+                if (value instanceof Uint8Array)
+                    return this.writeBin(value);
+                if (value instanceof Error)
+                    return this.writeErr(value.message);
+                if (value instanceof Set)
+                    return this.writeSet(value);
+                if (value instanceof JsonPackExtension_1.JsonPackExtension) {
+                    if (value instanceof extensions_1.RespPush)
+                        return this.writeArr(value.val);
+                    if (value instanceof extensions_1.RespVerbatimString)
+                        return this.writeStr(value.val);
+                    if (value instanceof extensions_1.RespAttributes)
+                        return this.writeObj(value.val);
+                }
+                return this.writeObj(value);
+            }
+            case 'undefined':
+                return this.writeUndef();
+            case 'bigint':
+                return this.writeSimpleStrAscii(value + '');
+            default:
+                return this.writeUnknown(value);
+        }
+    }
+    writeNumber(num) {
+        if (isSafeInteger(num))
+            this.writeInteger(num);
+        else
+            this.writeSimpleStrAscii(num + '');
+    }
+    writeStr(str) {
+        const length = str.length;
+        if (length < 64 && !REG_RN.test(str))
+            this.writeSimpleStr(str);
+        else
+            this.writeBulkStr(str);
+    }
+    writeNull() {
+        this.writeNullArr();
+    }
+    writeErr(str) {
+        if (str.length < 64 && !REG_RN.test(str))
+            this.writeSimpleErr(str);
+        else
+            this.writeBulkStr(str);
+    }
+    writeSet(set) {
+        this.writeArr([...set]);
+    }
+    writeArr(arr) {
+        const writer = this.writer;
+        const length = arr.length;
+        writer.u8(42);
+        this.writeLength(length);
+        writer.u16(3338);
+        for (let i = 0; i < length; i++) {
+            const val = arr[i];
+            if (val === null)
+                this.writeNullStr();
+            else
+                this.writeAny(val);
+        }
+    }
+    writeObj(obj) {
+        const writer = this.writer;
+        const keys = Object.keys(obj);
+        const length = keys.length;
+        writer.u8(42);
+        this.writeLength(length << 1);
+        writer.u16(3338);
+        for (let i = 0; i < length; i++) {
+            const key = keys[i];
+            this.writeStr(key);
+            const val = obj[key];
+            if (val === null)
+                this.writeNullStr();
+            else
+                this.writeAny(val);
+        }
+    }
+}
+exports.RespEncoderLegacy = RespEncoderLegacy;
+//# sourceMappingURL=RespEncoderLegacy.js.map

node_modules/@jsonjoy.com/json-pack/lib/resp/RespEncoderLegacy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RespEncoderLegacy.js","sourceRoot":"","sources":["../../src/resp/RespEncoderLegacy.ts"],"names":[],"mappings":"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"}

node_modules/@jsonjoy.com/json-pack/lib/resp/RespStreamingDecoder.d.ts

@@ -0,0 +1,12 @@
+import { StreamingReader } from '@jsonjoy.com/buffers/lib/StreamingReader';
+import { RespDecoder } from './RespDecoder';
+export declare class RespStreamingDecoder {
+    protected readonly reader: StreamingReader;
+    protected readonly decoder: RespDecoder<StreamingReader>;
+    get tryUtf8(): boolean;
+    set tryUtf8(value: boolean);
+    push(uint8: Uint8Array): void;
+    read(): unknown | undefined;
+    readCmd(): [cmd: string, ...args: Uint8Array[]] | undefined;
+    skip(): null | undefined;
+}

node_modules/@jsonjoy.com/json-pack/lib/resp/RespStreamingDecoder.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RespStreamingDecoder = void 0;
+const StreamingReader_1 = require("@jsonjoy.com/buffers/lib/StreamingReader");
+const RespDecoder_1 = require("./RespDecoder");
+class RespStreamingDecoder {
+    constructor() {
+        this.reader = new StreamingReader_1.StreamingReader();
+        this.decoder = new RespDecoder_1.RespDecoder(this.reader);
+    }
+    get tryUtf8() {
+        return this.decoder.tryUtf8;
+    }
+    set tryUtf8(value) {
+        this.decoder.tryUtf8 = value;
+    }
+    push(uint8) {
+        this.reader.push(uint8);
+    }
+    read() {
+        const reader = this.reader;
+        if (reader.size() === 0)
+            return undefined;
+        const x = reader.x;
+        try {
+            const val = this.decoder.readAny();
+            reader.consume();
+            return val;
+        }
+        catch (error) {
+            if (error instanceof RangeError) {
+                reader.x = x;
+                return undefined;
+            }
+            else
+                throw error;
+        }
+    }
+    readCmd() {
+        const reader = this.reader;
+        if (reader.size() === 0)
+            return undefined;
+        const x = reader.x;
+        try {
+            const args = this.decoder.readCmd();
+            reader.consume();
+            return args;
+        }
+        catch (error) {
+            if (error instanceof RangeError) {
+                reader.x = x;
+                return undefined;
+            }
+            else
+                throw error;
+        }
+    }
+    skip() {
+        const reader = this.reader;
+        if (reader.size() === 0)
+            return undefined;
+        const x = reader.x;
+        try {
+            this.decoder.skipAny();
+            reader.consume();
+            return null;
+        }
+        catch (error) {
+            if (error instanceof RangeError) {
+                reader.x = x;
+                return undefined;
+            }
+            else
+                throw error;
+        }
+    }
+}
+exports.RespStreamingDecoder = RespStreamingDecoder;
+//# sourceMappingURL=RespStreamingDecoder.js.map

node_modules/@jsonjoy.com/json-pack/lib/resp/RespStreamingDecoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RespStreamingDecoder.js","sourceRoot":"","sources":["../../src/resp/RespStreamingDecoder.ts"],"names":[],"mappings":";;;AAAA,8EAAyE;AACzE,+CAA0C;AAmB1C,MAAa,oBAAoB;IAAjC;QACqB,WAAM,GAAG,IAAI,iCAAe,EAAE,CAAC;QAC/B,YAAO,GAAG,IAAI,yBAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IA2F5D,CAAC;IApFC,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;IAC9B,CAAC;IACD,IAAW,OAAO,CAAC,KAAc;QAC/B,IAAI,CAAC,OAAO,CAAC,OAAO,GAAG,KAAK,CAAC;IAC/B,CAAC;IAMM,IAAI,CAAC,KAAiB;QAC3B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1B,CAAC;IAWM,IAAI;QACT,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,IAAI,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QAC1C,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;QACnB,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YACnC,MAAM,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,GAAG,CAAC;QACb,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,YAAY,UAAU,EAAE,CAAC;gBAChC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC;gBACb,OAAO,SAAS,CAAC;YACnB,CAAC;;gBAAM,MAAM,KAAK,CAAC;QACrB,CAAC;IACH,CAAC;IASM,OAAO;QACZ,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,IAAI,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QAC1C,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;QACnB,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YACpC,MAAM,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,YAAY,UAAU,EAAE,CAAC;gBAChC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC;gBACb,OAAO,SAAS,CAAC;YACnB,CAAC;;gBAAM,MAAM,KAAK,CAAC;QACrB,CAAC;IACH,CAAC;IAQM,IAAI;QACT,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,IAAI,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QAC1C,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;QACnB,IAAI,CAAC;YACH,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YACvB,MAAM,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,YAAY,UAAU,EAAE,CAAC;gBAChC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC;gBACb,OAAO,SAAS,CAAC;YACnB,CAAC;;gBAAM,MAAM,KAAK,CAAC;QACrB,CAAC;IACH,CAAC;CACF;AA7FD,oDA6FC"}

node_modules/@jsonjoy.com/json-pack/lib/resp/constants.d.ts

@@ -0,0 +1,22 @@
+export declare const enum RESP {
+    R = 13,
+    N = 10,
+    RN = 3338,
+    NULL = 95,
+    BOOL = 35,
+    INT = 58,
+    BIG = 40,
+    FLOAT = 44,
+    STR_SIMPLE = 43,
+    STR_BULK = 36,
+    STR_VERBATIM = 61,
+    ERR_SIMPLE = 45,
+    ERR_BULK = 33,
+    ARR = 42,
+    SET = 126,
+    OBJ = 37,
+    PUSH = 62,
+    ATTR = 124,
+    PLUS = 43,
+    MINUS = 45
+}

node_modules/@jsonjoy.com/json-pack/lib/resp/constants.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=constants.js.map

node_modules/@jsonjoy.com/json-pack/lib/resp/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/resp/constants.ts"],"names":[],"mappings":""}

node_modules/@jsonjoy.com/json-pack/lib/resp/extensions.d.ts

@@ -0,0 +1,13 @@
+import { JsonPackExtension } from '../JsonPackExtension';
+export declare class RespPush extends JsonPackExtension<unknown[]> {
+    readonly val: unknown[];
+    constructor(val: unknown[]);
+}
+export declare class RespAttributes extends JsonPackExtension<Record<string, unknown>> {
+    readonly val: Record<string, unknown>;
+    constructor(val: Record<string, unknown>);
+}
+export declare class RespVerbatimString extends JsonPackExtension<string> {
+    readonly val: string;
+    constructor(val: string);
+}

node_modules/@jsonjoy.com/json-pack/lib/resp/extensions.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RespVerbatimString = exports.RespAttributes = exports.RespPush = void 0;
+const JsonPackExtension_1 = require("../JsonPackExtension");
+class RespPush extends JsonPackExtension_1.JsonPackExtension {
+    constructor(val) {
+        super(1, val);
+        this.val = val;
+    }
+}
+exports.RespPush = RespPush;
+class RespAttributes extends JsonPackExtension_1.JsonPackExtension {
+    constructor(val) {
+        super(2, val);
+        this.val = val;
+    }
+}
+exports.RespAttributes = RespAttributes;
+class RespVerbatimString extends JsonPackExtension_1.JsonPackExtension {
+    constructor(val) {
+        super(3, val);
+        this.val = val;
+    }
+}
+exports.RespVerbatimString = RespVerbatimString;
+//# sourceMappingURL=extensions.js.map

node_modules/@jsonjoy.com/json-pack/lib/resp/extensions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensions.js","sourceRoot":"","sources":["../../src/resp/extensions.ts"],"names":[],"mappings":";;;AAAA,4DAAuD;AAEvD,MAAa,QAAS,SAAQ,qCAA4B;IACxD,YAA4B,GAAc;QACxC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QADY,QAAG,GAAH,GAAG,CAAW;IAE1C,CAAC;CACF;AAJD,4BAIC;AAED,MAAa,cAAe,SAAQ,qCAA0C;IAC5E,YAA4B,GAA4B;QACtD,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QADY,QAAG,GAAH,GAAG,CAAyB;IAExD,CAAC;CACF;AAJD,wCAIC;AAED,MAAa,kBAAmB,SAAQ,qCAAyB;IAC/D,YAA4B,GAAW;QACrC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QADY,QAAG,GAAH,GAAG,CAAQ;IAEvC,CAAC;CACF;AAJD,gDAIC"}

node_modules/@jsonjoy.com/json-pack/lib/resp/index.d.ts

@@ -0,0 +1,6 @@
+export * from './constants';
+export * from './extensions';
+export * from './RespEncoder';
+export * from './RespEncoderLegacy';
+export * from './RespDecoder';
+export * from './RespStreamingDecoder';

node_modules/@jsonjoy.com/json-pack/lib/resp/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./constants"), exports);
+tslib_1.__exportStar(require("./extensions"), exports);
+tslib_1.__exportStar(require("./RespEncoder"), exports);
+tslib_1.__exportStar(require("./RespEncoderLegacy"), exports);
+tslib_1.__exportStar(require("./RespDecoder"), exports);
+tslib_1.__exportStar(require("./RespStreamingDecoder"), exports);
+//# sourceMappingURL=index.js.map

node_modules/@jsonjoy.com/json-pack/lib/resp/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/resp/index.ts"],"names":[],"mappings":";;;AAAA,sDAA4B;AAC5B,uDAA6B;AAC7B,wDAA8B;AAC9B,8DAAoC;AACpC,wDAA8B;AAC9B,iEAAuC"}