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/bson/BsonDecoder.d.ts

@@ -0,0 +1,22 @@
+import { BsonBinary, BsonDbPointer, BsonDecimal128, BsonJavascriptCodeWithScope, BsonObjectId, BsonTimestamp } from './values';
+import type { IReader, IReaderResettable } from '@jsonjoy.com/buffers/lib';
+import type { BinaryJsonDecoder } from '../types';
+export declare class BsonDecoder implements BinaryJsonDecoder {
+    reader: IReader & IReaderResettable;
+    constructor(reader?: IReader & IReaderResettable);
+    read(uint8: Uint8Array): unknown;
+    decode(uint8: Uint8Array): unknown;
+    readAny(): unknown;
+    readDocument(): Record<string, unknown>;
+    readCString(): string;
+    readString(): string;
+    readElementValue(type: number): unknown;
+    readArray(): unknown[];
+    readBinary(): BsonBinary | Uint8Array;
+    readObjectId(): BsonObjectId;
+    readRegex(): RegExp;
+    readDbPointer(): BsonDbPointer;
+    readCodeWithScope(): BsonJavascriptCodeWithScope;
+    readTimestamp(): BsonTimestamp;
+    readDecimal128(): BsonDecimal128;
+}

node_modules/@jsonjoy.com/json-pack/lib/bson/BsonDecoder.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BsonDecoder = void 0;
+const Reader_1 = require("@jsonjoy.com/buffers/lib/Reader");
+const values_1 = require("./values");
+class BsonDecoder {
+    constructor(reader = new Reader_1.Reader()) {
+        this.reader = reader;
+    }
+    read(uint8) {
+        this.reader.reset(uint8);
+        return this.readDocument();
+    }
+    decode(uint8) {
+        this.reader.reset(uint8);
+        return this.readDocument();
+    }
+    readAny() {
+        return this.readDocument();
+    }
+    readDocument() {
+        const reader = this.reader;
+        const documentSize = reader.view.getInt32(reader.x, true);
+        reader.x += 4;
+        const startPos = reader.x;
+        const endPos = startPos + documentSize - 4 - 1;
+        const obj = {};
+        while (reader.x < endPos) {
+            const elementType = reader.u8();
+            if (elementType === 0)
+                break;
+            const key = this.readCString();
+            const value = this.readElementValue(elementType);
+            obj[key] = value;
+        }
+        if (reader.x <= endPos) {
+            reader.x = startPos + documentSize - 4;
+        }
+        return obj;
+    }
+    readCString() {
+        const reader = this.reader;
+        const uint8 = reader.uint8;
+        const x = reader.x;
+        let length = 0;
+        while (uint8[x + length] !== 0) {
+            length++;
+        }
+        if (length === 0) {
+            reader.x++;
+            return '';
+        }
+        const str = reader.utf8(length);
+        reader.x++;
+        return str;
+    }
+    readString() {
+        const reader = this.reader;
+        const length = reader.view.getInt32(reader.x, true);
+        reader.x += 4;
+        if (length <= 0) {
+            throw new Error('Invalid string length');
+        }
+        const str = reader.utf8(length - 1);
+        reader.x++;
+        return str;
+    }
+    readElementValue(type) {
+        const reader = this.reader;
+        switch (type) {
+            case 0x01:
+                const doubleVal = reader.view.getFloat64(reader.x, true);
+                reader.x += 8;
+                return doubleVal;
+            case 0x02:
+                return this.readString();
+            case 0x03:
+                return this.readDocument();
+            case 0x04:
+                return this.readArray();
+            case 0x05:
+                return this.readBinary();
+            case 0x06:
+                return undefined;
+            case 0x07:
+                return this.readObjectId();
+            case 0x08:
+                return reader.u8() === 1;
+            case 0x09:
+                const dateVal = reader.view.getBigInt64(reader.x, true);
+                reader.x += 8;
+                return new Date(Number(dateVal));
+            case 0x0a:
+                return null;
+            case 0x0b:
+                return this.readRegex();
+            case 0x0c:
+                return this.readDbPointer();
+            case 0x0d:
+                return new values_1.BsonJavascriptCode(this.readString());
+            case 0x0e:
+                return Symbol(this.readString());
+            case 0x0f:
+                return this.readCodeWithScope();
+            case 0x10:
+                const int32Val = reader.view.getInt32(reader.x, true);
+                reader.x += 4;
+                return int32Val;
+            case 0x11:
+                return this.readTimestamp();
+            case 0x12:
+                const int64Val = reader.view.getBigInt64(reader.x, true);
+                reader.x += 8;
+                return Number(int64Val);
+            case 0x13:
+                return this.readDecimal128();
+            case 0xff:
+                return new values_1.BsonMinKey();
+            case 0x7f:
+                return new values_1.BsonMaxKey();
+            default:
+                throw new Error(`Unsupported BSON type: 0x${type.toString(16)}`);
+        }
+    }
+    readArray() {
+        const doc = this.readDocument();
+        const keys = Object.keys(doc).sort((a, b) => parseInt(a, 10) - parseInt(b, 10));
+        return keys.map((key) => doc[key]);
+    }
+    readBinary() {
+        const reader = this.reader;
+        const length = reader.view.getInt32(reader.x, true);
+        reader.x += 4;
+        const subtype = reader.u8();
+        const data = reader.buf(length);
+        if (subtype === 0) {
+            return data;
+        }
+        return new values_1.BsonBinary(subtype, data);
+    }
+    readObjectId() {
+        const reader = this.reader;
+        const uint8 = reader.uint8;
+        const x = reader.x;
+        const timestamp = (uint8[x] << 24) | (uint8[x + 1] << 16) | (uint8[x + 2] << 8) | uint8[x + 3];
+        const processLo = uint8[x + 4] | (uint8[x + 5] << 8) | (uint8[x + 6] << 16) | (uint8[x + 7] << 24);
+        const processHi = uint8[x + 8];
+        const processLoUnsigned = processLo >>> 0;
+        const process = processLoUnsigned + processHi * 0x100000000;
+        const counter = (uint8[x + 9] << 16) | (uint8[x + 10] << 8) | uint8[x + 11];
+        reader.x += 12;
+        return new values_1.BsonObjectId(timestamp, process, counter);
+    }
+    readRegex() {
+        const pattern = this.readCString();
+        const flags = this.readCString();
+        return new RegExp(pattern, flags);
+    }
+    readDbPointer() {
+        const name = this.readString();
+        const id = this.readObjectId();
+        return new values_1.BsonDbPointer(name, id);
+    }
+    readCodeWithScope() {
+        const reader = this.reader;
+        const totalLength = reader.view.getInt32(reader.x, true);
+        reader.x += 4;
+        const code = this.readString();
+        const scope = this.readDocument();
+        return new values_1.BsonJavascriptCodeWithScope(code, scope);
+    }
+    readTimestamp() {
+        const reader = this.reader;
+        const increment = reader.view.getInt32(reader.x, true);
+        reader.x += 4;
+        const timestamp = reader.view.getInt32(reader.x, true);
+        reader.x += 4;
+        return new values_1.BsonTimestamp(increment, timestamp);
+    }
+    readDecimal128() {
+        const reader = this.reader;
+        const data = reader.buf(16);
+        return new values_1.BsonDecimal128(data);
+    }
+}
+exports.BsonDecoder = BsonDecoder;
+//# sourceMappingURL=BsonDecoder.js.map

node_modules/@jsonjoy.com/json-pack/lib/bson/BsonEncoder.d.ts

@@ -0,0 +1,27 @@
+import { BsonObjectId } from './values';
+import type { IWriter, IWriterGrowable } from '@jsonjoy.com/buffers/lib';
+import type { BinaryJsonEncoder } from '../types';
+export declare class BsonEncoder implements BinaryJsonEncoder {
+    readonly writer: IWriter & IWriterGrowable;
+    constructor(writer: IWriter & IWriterGrowable);
+    encode(value: unknown): Uint8Array;
+    writeAny(value: unknown): void;
+    writeNull(): void;
+    writeUndef(): void;
+    writeBoolean(bool: boolean): void;
+    writeNumber(num: number): void;
+    writeInteger(int: number): void;
+    writeUInteger(uint: number): void;
+    writeInt32(int: number): void;
+    writeInt64(int: number | bigint): void;
+    writeFloat(float: number): void;
+    writeBigInt(int: bigint): void;
+    writeBin(buf: Uint8Array): void;
+    writeStr(str: string): void;
+    writeAsciiStr(str: string): void;
+    writeArr(arr: unknown[]): void;
+    writeObj(obj: Record<string, unknown>): void;
+    writeCString(str: string): void;
+    writeObjectId(id: BsonObjectId): void;
+    writeKey(key: string, value: unknown): void;
+}

node_modules/@jsonjoy.com/json-pack/lib/bson/BsonEncoder.js

@@ -0,0 +1,376 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BsonEncoder = void 0;
+const values_1 = require("./values");
+class BsonEncoder {
+    constructor(writer) {
+        this.writer = writer;
+    }
+    encode(value) {
+        const writer = this.writer;
+        writer.reset();
+        this.writeAny(value);
+        return writer.flush();
+    }
+    writeAny(value) {
+        switch (typeof value) {
+            case 'object': {
+                if (value === null)
+                    throw new Error('NOT_OBJ');
+                return this.writeObj(value);
+            }
+        }
+        throw new Error('NOT_OBJ');
+    }
+    writeNull() {
+        throw new Error('Use writeKey for BSON encoding');
+    }
+    writeUndef() {
+        throw new Error('Use writeKey for BSON encoding');
+    }
+    writeBoolean(bool) {
+        throw new Error('Use writeKey for BSON encoding');
+    }
+    writeNumber(num) {
+        throw new Error('Use writeKey for BSON encoding');
+    }
+    writeInteger(int) {
+        throw new Error('Use writeKey for BSON encoding');
+    }
+    writeUInteger(uint) {
+        throw new Error('Use writeKey for BSON encoding');
+    }
+    writeInt32(int) {
+        const writer = this.writer;
+        writer.ensureCapacity(4);
+        writer.view.setInt32(writer.x, int, true);
+        writer.x += 4;
+    }
+    writeInt64(int) {
+        const writer = this.writer;
+        writer.ensureCapacity(8);
+        writer.view.setBigInt64(writer.x, BigInt(int), true);
+        writer.x += 8;
+    }
+    writeFloat(float) {
+        const writer = this.writer;
+        writer.ensureCapacity(8);
+        writer.view.setFloat64(writer.x, float, true);
+        writer.x += 8;
+    }
+    writeBigInt(int) {
+        throw new Error('Use writeKey for BSON encoding');
+    }
+    writeBin(buf) {
+        const length = buf.length;
+        this.writeInt32(length);
+        const writer = this.writer;
+        writer.u8(0);
+        writer.buf(buf, length);
+    }
+    writeStr(str) {
+        const writer = this.writer;
+        const length = str.length;
+        const maxSize = 4 + 1 + 4 * length;
+        writer.ensureCapacity(maxSize);
+        const x = writer.x;
+        this.writeInt32(length + 1);
+        const bytesWritten = writer.utf8(str);
+        writer.u8(0);
+        if (bytesWritten !== length) {
+            writer.view.setInt32(x, bytesWritten + 1, true);
+        }
+    }
+    writeAsciiStr(str) {
+        this.writeStr(str);
+    }
+    writeArr(arr) {
+        this.writeObj(arr);
+    }
+    writeObj(obj) {
+        const writer = this.writer;
+        writer.ensureCapacity(8);
+        const x0 = writer.x0;
+        const dx = writer.x - x0;
+        writer.x += 4;
+        const keys = Object.keys(obj);
+        const length = keys.length;
+        for (let i = 0; i < length; i++) {
+            const key = keys[i];
+            const value = obj[key];
+            this.writeKey(key, value);
+        }
+        writer.u8(0);
+        const x = writer.x0 + dx;
+        const size = writer.x - x;
+        writer.view.setUint32(x, size, true);
+    }
+    writeCString(str) {
+        const writer = this.writer;
+        const length = str.length;
+        writer.ensureCapacity(1 + 4 * length);
+        const uint8 = writer.uint8;
+        let x = writer.x;
+        let pos = 0;
+        while (pos < length) {
+            let value = str.charCodeAt(pos++);
+            if ((value & 0xffffff80) === 0) {
+                if (!value)
+                    break;
+                uint8[x++] = value;
+                continue;
+            }
+            else if ((value & 0xfffff800) === 0) {
+                const octet = ((value >> 6) & 0x1f) | 0xc0;
+                if (!octet)
+                    break;
+                uint8[x++] = octet;
+            }
+            else {
+                if (value >= 0xd800 && value <= 0xdbff) {
+                    if (pos < length) {
+                        const extra = str.charCodeAt(pos);
+                        if ((extra & 0xfc00) === 0xdc00) {
+                            pos++;
+                            value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
+                        }
+                    }
+                }
+                if ((value & 0xffff0000) === 0) {
+                    const octet1 = ((value >> 12) & 0x0f) | 0xe0;
+                    const octet2 = ((value >> 6) & 0x3f) | 0x80;
+                    if (!octet1 || !octet2)
+                        throw new Error('INVALID_CSTRING');
+                    uint8[x++] = octet1;
+                    uint8[x++] = octet2;
+                }
+                else {
+                    const octet1 = ((value >> 18) & 0x07) | 0xf0;
+                    const octet2 = ((value >> 12) & 0x3f) | 0x80;
+                    const octet3 = ((value >> 6) & 0x3f) | 0x80;
+                    if (!octet1 || !octet2 || !octet3)
+                        throw new Error('INVALID_CSTRING');
+                    uint8[x++] = octet1;
+                    uint8[x++] = octet2;
+                    uint8[x++] = octet3;
+                }
+            }
+            const octet = (value & 0x3f) | 0x80;
+            if (!octet)
+                break;
+            uint8[x++] = octet;
+        }
+        uint8[x++] = 0;
+        writer.x = x;
+    }
+    writeObjectId(id) {
+        const writer = this.writer;
+        writer.ensureCapacity(12);
+        const uint8 = writer.uint8;
+        const x = writer.x;
+        const { timestamp, process, counter } = id;
+        uint8[x + 0] = timestamp >>> 24;
+        uint8[x + 1] = (timestamp >>> 16) & 0xff;
+        uint8[x + 2] = (timestamp >>> 8) & 0xff;
+        uint8[x + 3] = timestamp & 0xff;
+        uint8[x + 4] = process & 0xff;
+        uint8[x + 5] = (process >>> 8) & 0xff;
+        uint8[x + 6] = (process >>> 16) & 0xff;
+        uint8[x + 7] = (process >>> 24) & 0xff;
+        let lo32 = process | 0;
+        if (lo32 < 0)
+            lo32 += 4294967296;
+        const hi32 = (process - lo32) / 4294967296;
+        uint8[x + 8] = hi32 & 0xff;
+        uint8[x + 9] = counter >>> 16;
+        uint8[x + 10] = (counter >>> 8) & 0xff;
+        uint8[x + 11] = counter & 0xff;
+        writer.x += 12;
+    }
+    writeKey(key, value) {
+        const writer = this.writer;
+        switch (typeof value) {
+            case 'number': {
+                const isFloat = Math.floor(value) !== value;
+                if (isFloat) {
+                    writer.u8(0x01);
+                    this.writeCString(key);
+                    this.writeFloat(value);
+                    break;
+                }
+                if (value <= 2147483647 && value >= -2147483648) {
+                    writer.u8(0x10);
+                    this.writeCString(key);
+                    this.writeInt32(value);
+                    break;
+                }
+                writer.u8(0x12);
+                this.writeCString(key);
+                this.writeInt64(value);
+                break;
+            }
+            case 'string': {
+                writer.u8(0x02);
+                this.writeCString(key);
+                this.writeStr(value);
+                break;
+            }
+            case 'object': {
+                if (value === null) {
+                    writer.u8(0x0a);
+                    this.writeCString(key);
+                    break;
+                }
+                const constructor = value.constructor;
+                switch (constructor) {
+                    case Object: {
+                        writer.u8(0x03);
+                        this.writeCString(key);
+                        this.writeObj(value);
+                        break;
+                    }
+                    case Array: {
+                        writer.u8(0x04);
+                        this.writeCString(key);
+                        this.writeObj(value);
+                        break;
+                    }
+                    case Uint8Array: {
+                        writer.u8(0x05);
+                        this.writeCString(key);
+                        this.writeBin(value);
+                        break;
+                    }
+                    case values_1.BsonObjectId: {
+                        writer.u8(0x07);
+                        this.writeCString(key);
+                        this.writeObjectId(value);
+                        break;
+                    }
+                    case Date: {
+                        writer.u8(0x09);
+                        this.writeCString(key);
+                        writer.ensureCapacity(8);
+                        writer.view.setBigUint64(writer.x, BigInt(value.getTime()), true);
+                        writer.x += 8;
+                        break;
+                    }
+                    case RegExp: {
+                        writer.u8(0x0b);
+                        this.writeCString(key);
+                        this.writeCString(value.source);
+                        this.writeCString(value.flags);
+                        break;
+                    }
+                    case values_1.BsonDbPointer: {
+                        writer.u8(0x0c);
+                        this.writeCString(key);
+                        const pointer = value;
+                        this.writeStr(pointer.name);
+                        this.writeObjectId(pointer.id);
+                        break;
+                    }
+                    case values_1.BsonJavascriptCode: {
+                        writer.u8(0x0d);
+                        this.writeCString(key);
+                        this.writeStr(value.code);
+                        break;
+                    }
+                    case values_1.BsonJavascriptCodeWithScope: {
+                        writer.u8(0x0f);
+                        this.writeCString(key);
+                        const codeWithScope = value;
+                        const x0 = writer.x;
+                        writer.x += 4;
+                        this.writeStr(codeWithScope.code);
+                        this.writeObj(codeWithScope.scope);
+                        const totalLength = writer.x - x0;
+                        writer.view.setInt32(x0, totalLength, true);
+                        break;
+                    }
+                    case values_1.BsonInt32: {
+                        writer.u8(0x10);
+                        this.writeCString(key);
+                        this.writeInt32(value.value);
+                        break;
+                    }
+                    case values_1.BsonInt64: {
+                        writer.u8(0x12);
+                        this.writeCString(key);
+                        this.writeInt64(value.value);
+                        break;
+                    }
+                    case values_1.BsonFloat: {
+                        writer.u8(0x01);
+                        this.writeCString(key);
+                        this.writeFloat(value.value);
+                        break;
+                    }
+                    case values_1.BsonTimestamp: {
+                        writer.u8(0x11);
+                        this.writeCString(key);
+                        const ts = value;
+                        this.writeInt32(ts.increment);
+                        this.writeInt32(ts.timestamp);
+                        break;
+                    }
+                    case values_1.BsonDecimal128: {
+                        writer.u8(0x13);
+                        this.writeCString(key);
+                        const dec = value;
+                        if (dec.data.length !== 16)
+                            throw new Error('INVALID_DECIMAL128');
+                        writer.buf(dec.data, 16);
+                        break;
+                    }
+                    case values_1.BsonMinKey: {
+                        writer.u8(0xff);
+                        this.writeCString(key);
+                        break;
+                    }
+                    case values_1.BsonMaxKey: {
+                        writer.u8(0x7f);
+                        this.writeCString(key);
+                        break;
+                    }
+                    case values_1.BsonBinary: {
+                        writer.u8(0x05);
+                        this.writeCString(key);
+                        const bin = value;
+                        const length = bin.data.length;
+                        this.writeInt32(length);
+                        writer.u8(bin.subtype);
+                        writer.buf(bin.data, length);
+                        break;
+                    }
+                    default: {
+                        writer.u8(0x03);
+                        this.writeCString(key);
+                        this.writeObj(value);
+                        break;
+                    }
+                }
+                break;
+            }
+            case 'boolean': {
+                writer.u8(0x08);
+                this.writeCString(key);
+                writer.u8(+value);
+                break;
+            }
+            case 'undefined': {
+                writer.u8(0x06);
+                this.writeCString(key);
+                break;
+            }
+            case 'symbol': {
+                writer.u8(0x0e);
+                this.writeCString(key);
+                this.writeStr(value.description || '');
+                break;
+            }
+        }
+    }
+}
+exports.BsonEncoder = BsonEncoder;
+//# sourceMappingURL=BsonEncoder.js.map

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

@@ -0,0 +1,3 @@
+export * from './values';
+export * from './BsonEncoder';
+export * from './BsonDecoder';

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./values"), exports);
+tslib_1.__exportStar(require("./BsonEncoder"), exports);
+tslib_1.__exportStar(require("./BsonDecoder"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/bson/index.ts"],"names":[],"mappings":";;;AAAA,mDAAyB;AACzB,wDAA8B;AAC9B,wDAA8B"}

node_modules/@jsonjoy.com/json-pack/lib/bson/values.d.ts

@@ -0,0 +1,54 @@
+export declare class BsonObjectId {
+    timestamp: number;
+    process: number;
+    counter: number;
+    constructor(timestamp: number, process: number, counter: number);
+}
+export declare class BsonDbPointer {
+    name: string;
+    id: BsonObjectId;
+    constructor(name: string, id: BsonObjectId);
+}
+export declare class BsonJavascriptCode {
+    code: string;
+    constructor(code: string);
+}
+export declare class BsonSymbol {
+    symbol: string;
+    constructor(symbol: string);
+}
+export declare class BsonJavascriptCodeWithScope {
+    code: string;
+    scope: Record<string, unknown>;
+    constructor(code: string, scope: Record<string, unknown>);
+}
+export declare class BsonInt32 {
+    value: number;
+    constructor(value: number);
+}
+export declare class BsonInt64 {
+    value: number;
+    constructor(value: number);
+}
+export declare class BsonFloat {
+    value: number;
+    constructor(value: number);
+}
+export declare class BsonTimestamp {
+    increment: number;
+    timestamp: number;
+    constructor(increment: number, timestamp: number);
+}
+export declare class BsonDecimal128 {
+    data: Uint8Array;
+    constructor(data: Uint8Array);
+}
+export declare class BsonMinKey {
+}
+export declare class BsonMaxKey {
+}
+export declare class BsonBinary {
+    subtype: number;
+    data: Uint8Array;
+    constructor(subtype: number, data: Uint8Array);
+}

node_modules/@jsonjoy.com/json-pack/lib/bson/values.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BsonBinary = exports.BsonMaxKey = exports.BsonMinKey = exports.BsonDecimal128 = exports.BsonTimestamp = exports.BsonFloat = exports.BsonInt64 = exports.BsonInt32 = exports.BsonJavascriptCodeWithScope = exports.BsonSymbol = exports.BsonJavascriptCode = exports.BsonDbPointer = exports.BsonObjectId = void 0;
+class BsonObjectId {
+    constructor(timestamp, process, counter) {
+        this.timestamp = timestamp;
+        this.process = process;
+        this.counter = counter;
+    }
+}
+exports.BsonObjectId = BsonObjectId;
+class BsonDbPointer {
+    constructor(name, id) {
+        this.name = name;
+        this.id = id;
+    }
+}
+exports.BsonDbPointer = BsonDbPointer;
+class BsonJavascriptCode {
+    constructor(code) {
+        this.code = code;
+    }
+}
+exports.BsonJavascriptCode = BsonJavascriptCode;
+class BsonSymbol {
+    constructor(symbol) {
+        this.symbol = symbol;
+    }
+}
+exports.BsonSymbol = BsonSymbol;
+class BsonJavascriptCodeWithScope {
+    constructor(code, scope) {
+        this.code = code;
+        this.scope = scope;
+    }
+}
+exports.BsonJavascriptCodeWithScope = BsonJavascriptCodeWithScope;
+class BsonInt32 {
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.BsonInt32 = BsonInt32;
+class BsonInt64 {
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.BsonInt64 = BsonInt64;
+class BsonFloat {
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.BsonFloat = BsonFloat;
+class BsonTimestamp {
+    constructor(increment, timestamp) {
+        this.increment = increment;
+        this.timestamp = timestamp;
+    }
+}
+exports.BsonTimestamp = BsonTimestamp;
+class BsonDecimal128 {
+    constructor(data) {
+        this.data = data;
+    }
+}
+exports.BsonDecimal128 = BsonDecimal128;
+class BsonMinKey {
+}
+exports.BsonMinKey = BsonMinKey;
+class BsonMaxKey {
+}
+exports.BsonMaxKey = BsonMaxKey;
+class BsonBinary {
+    constructor(subtype, data) {
+        this.subtype = subtype;
+        this.data = data;
+    }
+}
+exports.BsonBinary = BsonBinary;
+//# sourceMappingURL=values.js.map

node_modules/@jsonjoy.com/json-pack/lib/bson/values.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.js","sourceRoot":"","sources":["../../src/bson/values.ts"],"names":[],"mappings":";;;AAAA,MAAa,YAAY;IACvB,YACS,SAAiB,EACjB,OAAe,EACf,OAAe;QAFf,cAAS,GAAT,SAAS,CAAQ;QACjB,YAAO,GAAP,OAAO,CAAQ;QACf,YAAO,GAAP,OAAO,CAAQ;IACrB,CAAC;CACL;AAND,oCAMC;AAED,MAAa,aAAa;IACxB,YACS,IAAY,EACZ,EAAgB;QADhB,SAAI,GAAJ,IAAI,CAAQ;QACZ,OAAE,GAAF,EAAE,CAAc;IACtB,CAAC;CACL;AALD,sCAKC;AAED,MAAa,kBAAkB;IAC7B,YAA0B,IAAY;QAAZ,SAAI,GAAJ,IAAI,CAAQ;IAAG,CAAC;CAC3C;AAFD,gDAEC;AAED,MAAa,UAAU;IACrB,YAA0B,MAAc;QAAd,WAAM,GAAN,MAAM,CAAQ;IAAG,CAAC;CAC7C;AAFD,gCAEC;AAED,MAAa,2BAA2B;IACtC,YACS,IAAY,EACZ,KAA8B;QAD9B,SAAI,GAAJ,IAAI,CAAQ;QACZ,UAAK,GAAL,KAAK,CAAyB;IACpC,CAAC;CACL;AALD,kEAKC;AAED,MAAa,SAAS;IACpB,YAA0B,KAAa;QAAb,UAAK,GAAL,KAAK,CAAQ;IAAG,CAAC;CAC5C;AAFD,8BAEC;AAED,MAAa,SAAS;IACpB,YAA0B,KAAa;QAAb,UAAK,GAAL,KAAK,CAAQ;IAAG,CAAC;CAC5C;AAFD,8BAEC;AAED,MAAa,SAAS;IACpB,YAA0B,KAAa;QAAb,UAAK,GAAL,KAAK,CAAQ;IAAG,CAAC;CAC5C;AAFD,8BAEC;AAED,MAAa,aAAa;IACxB,YACS,SAAiB,EACjB,SAAiB;QADjB,cAAS,GAAT,SAAS,CAAQ;QACjB,cAAS,GAAT,SAAS,CAAQ;IACvB,CAAC;CACL;AALD,sCAKC;AAED,MAAa,cAAc;IACzB,YAA0B,IAAgB;QAAhB,SAAI,GAAJ,IAAI,CAAY;IAAG,CAAC;CAC/C;AAFD,wCAEC;AAED,MAAa,UAAU;CAAG;AAA1B,gCAA0B;AAE1B,MAAa,UAAU;CAAG;AAA1B,gCAA0B;AAE1B,MAAa,UAAU;IACrB,YACS,OAAe,EACf,IAAgB;QADhB,YAAO,GAAP,OAAO,CAAQ;QACf,SAAI,GAAJ,IAAI,CAAY;IACtB,CAAC;CACL;AALD,gCAKC"}