@schema-pack/message-pack 0.0.0-commit.cdc6b744227cc8ddcb9fc2fea8035c9fffab4fb5 → 0.0.0-commit.e0aa9d9c91f8e596fb35378fe25325240245548c

package/dist/cjs/encoder/encoder.cjs

@@ -1,16 +1,15 @@
+const require_symbols = require("../symbols.cjs");
 const require_bufferWithExtensions = require("../bufferWithExtensions.cjs");
 const require_constants = require("../constants.cjs");
 const require_defaultNewBufferFn = require("../defaultNewBufferFn.cjs");
-const require_symbols = require("../symbols.cjs");
 const require_utils_fitIn7Bits = require("../utils/fitIn7Bits.cjs");
 const require_utils_fitIn8Bits = require("../utils/fitIn8Bits.cjs");
 const require_utils_fitIn16Bits = require("../utils/fitIn16Bits.cjs");
 const require_utils_fitIn32Bits = require("../utils/fitIn32Bits.cjs");
 const require_encoder_textEncoders_defaultTextEncoder = require("./textEncoders/defaultTextEncoder.cjs");
 //#region src/encoder/encoder.ts
+const BIGINT_MASK = 18446744073709551615n;
 var Encoder = class Encoder extends require_bufferWithExtensions {
-	/** The current offset in the buffer where the next write operation will occur. */
-	offset;
 	/**
 	* Shared buffer is used to encode strings, to avoid allocating a new buffer
 	* for each string. The shared buffer is resized if the string is larger than
@@ -18,6 +17,10 @@ var Encoder = class Encoder extends require_bufferWithExtensions {
 	* reducing memory allocations and garbage collection overhead.
 	*/
 	sharedBuffer;
+	extensionsByConstructors = /* @__PURE__ */ new Map();
+	builtInExtensionsByConstructors = /* @__PURE__ */ new Map();
+	/** The current offset in the buffer where the next write operation will occur. */
+	offset;
 	/**
 	* Determines whether the keys of a map should be sorted before encoding.
 	* Sorting keys can be useful for ensuring consistent serialization of
@@ -34,6 +37,19 @@ var Encoder = class Encoder extends require_bufferWithExtensions {
 	*/
 	forceFloat32;
 	/**
+	* The initial size of the main buffer. This determines how much memory is
+	* allocated for the buffer when the encoder is first created. If the buffer
+	* needs to grow beyond this size, it will be reallocated with a larger size.
+	*/
+	initialBufferSize;
+	/**
+	* The initial size of the shared buffer used for encoding strings. This
+	* determines how much memory is allocated for the shared buffer when the
+	* encoder is first created. If the shared buffer needs to grow beyond this
+	* size, it will be reallocated with a larger size.
+	*/
+	initialSharedBufferSize;
+	/**
 	* A function that creates a new buffer of the specified size. This function
 	* is used to allocate new buffers when the current buffer is not large enough
 	* to accommodate the data being written. The function should return a new
@@ -55,24 +71,45 @@ var Encoder = class Encoder extends require_bufferWithExtensions {
 	*/
 	#extensionEncoder;
 	constructor(options) {
-		super();
+		super(options);
 		this.offset = 0;
 		this.textEncoder = options?.textEncoder ?? new require_encoder_textEncoders_defaultTextEncoder();
+		this.initialBufferSize = options?.initialBufferSize ?? 1024;
+		this.initialSharedBufferSize = options?.initialSharedBufferSize ?? 1024;
 		this.bufferFactory = options?.bufferFactory ?? require_defaultNewBufferFn;
-		this.buffer = this.bufferFactory(options?.initialBufferSize ?? 1024);
-		this.sharedBuffer = this.bufferFactory(options?.initialSharedBufferSize ?? 1024);
+		this.buffer = this.bufferFactory(this.initialBufferSize);
+		this.sharedBuffer = this.bufferFactory(this.initialSharedBufferSize);
 		this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
 		this.sortKeys = options?.sortKeys ?? false;
 		this.forceFloat32 = options?.forceFloat32 ?? false;
+		if (this.errorExtension) for (const constructor of this.errorExtension.constructors) this.builtInExtensionsByConstructors.set(constructor, this.errorExtension);
+		if (this.timestampDateExtension) for (const constructor of this.timestampDateExtension.constructors) this.builtInExtensionsByConstructors.set(constructor, this.timestampDateExtension);
+	}
+	addExtension(extension) {
+		super.addExtension(extension);
+		if (Array.isArray(extension.constructors)) for (const constructor of extension.constructors) this.extensionsByConstructors.set(constructor, extension);
+		else this.extensionsByConstructors.set(extension.constructors, extension);
+		if (this.#extensionEncoder) this.#extensionEncoder.addExtension(extension);
+		return this;
 	}
 	getExtensionEncoder() {
-		if (!this.#extensionEncoder) this.#extensionEncoder = new Encoder({
-			bufferFactory: this.bufferFactory,
-			initialBufferSize: this.sharedBuffer.byteLength,
-			initialSharedBufferSize: 0,
-			sortKeys: this.sortKeys,
-			textEncoder: this.textEncoder
-		});
+		if (!this.#extensionEncoder) {
+			const extensionEncoder = new Encoder({
+				bufferFactory: this.bufferFactory,
+				extensions: {
+					bigInt: this.bigIntExtension ?? false,
+					error: this.errorExtension ?? false,
+					timestampDate: this.timestampDateExtension ?? false
+				},
+				forceFloat32: this.forceFloat32,
+				initialBufferSize: this.initialBufferSize,
+				initialSharedBufferSize: this.initialSharedBufferSize,
+				sortKeys: this.sortKeys,
+				textEncoder: this.textEncoder
+			});
+			for (const extension of this.extensions.values()) extensionEncoder.addExtension(extension);
+			this.#extensionEncoder = extensionEncoder;
+		}
 		return this.#extensionEncoder;
 	}
 	resizeBuffer(newSize) {
@@ -339,7 +376,7 @@ var Encoder = class Encoder extends require_bufferWithExtensions {
 	writeString(value) {
 		const valueLength = value.length;
 		const requiredSize = value.length * 4;
-		if (valueLength < 51) {
+		if (valueLength < 64) {
 			this.ensureCapacity(1 + requiredSize);
 			const initialoffset = this.offset;
 			const byteLengthoffset = this.offset++;
@@ -533,60 +570,113 @@ var Encoder = class Encoder extends require_bufferWithExtensions {
 		} else throw new Error(`Uint8Array too large to encode: ${value.length}`);
 		return this.writeBin(value);
 	}
-	writeExtension(extension, encoder) {
-		const writtenBytes = encoder.offset;
-		if (writtenBytes === 1) {
+	writeExtensionSymbol(type, size) {
+		if (size === 1) {
 			this.ensureCapacity(3);
-			this.writeFixExt1Symbol(extension.type);
-		} else if (writtenBytes === 2) {
+			this.writeFixExt1Symbol(type);
+		} else if (size === 2) {
 			this.ensureCapacity(4);
-			this.writeFixExt2Symbol(extension.type);
-		} else if (writtenBytes === 4) {
+			this.writeFixExt2Symbol(type);
+		} else if (size === 4) {
 			this.ensureCapacity(6);
-			this.writeFixExt4Symbol(extension.type);
-		} else if (writtenBytes === 8) {
+			this.writeFixExt4Symbol(type);
+		} else if (size === 8) {
 			this.ensureCapacity(10);
-			this.writeFixExt8Symbol(extension.type);
-		} else if (writtenBytes === 16) {
+			this.writeFixExt8Symbol(type);
+		} else if (size === 16) {
 			this.ensureCapacity(18);
-			this.writeFixExt16Symbol(extension.type);
-		} else if (require_utils_fitIn8Bits(writtenBytes)) {
-			this.ensureCapacity(3 + writtenBytes);
-			this.writeExt8Symbol(extension.type, writtenBytes);
-		} else if (require_utils_fitIn16Bits(writtenBytes)) {
-			this.ensureCapacity(4 + writtenBytes);
-			this.writeExt16Symbol(extension.type, writtenBytes);
-		} else if (require_utils_fitIn32Bits(writtenBytes)) {
-			this.ensureCapacity(6 + writtenBytes);
-			this.writeExt32Symbol(extension.type, writtenBytes);
-		} else throw new Error(`Extension data too large to encode: ${writtenBytes} bytes`);
-		this.buffer.set(encoder.buffer.subarray(0, writtenBytes), this.offset);
+			this.writeFixExt16Symbol(type);
+		} else if (require_utils_fitIn8Bits(size)) {
+			this.ensureCapacity(3 + size);
+			this.writeExt8Symbol(type, size);
+		} else if (require_utils_fitIn16Bits(size)) {
+			this.ensureCapacity(4 + size);
+			this.writeExt16Symbol(type, size);
+		} else if (require_utils_fitIn32Bits(size)) {
+			this.ensureCapacity(6 + size);
+			this.writeExt32Symbol(type, size);
+		} else throw new Error(`Extension data too large to encode: ${size} bytes`);
+		return this;
+	}
+	writeExtension(extension, extensionEncoder) {
+		const writtenBytes = extensionEncoder.offset;
+		this.writeExtensionSymbol(extension.type, writtenBytes);
+		this.buffer.set(extensionEncoder.buffer.subarray(0, writtenBytes), this.offset);
 		this.offset += writtenBytes;
 		return this;
 	}
-	tryToWriteExtensionValue(value) {
-		if (this.extensions.size > 0) {
-			const iterator = this.extensions.values();
-			const extensionEncoder = this.getExtensionEncoder();
-			for (const extension of iterator) {
-				extensionEncoder.resetBuffer();
-				extension.encode(value, extensionEncoder);
-				if (extensionEncoder.offset > 0) {
-					this.writeExtension(extension, extensionEncoder);
-					return extensionEncoder.offset;
-				}
-			}
+	writeBigInt(value) {
+		if (!this.bigIntExtension) throw new Error(`BigInt extension is disabled, cannot encode BigInt.`);
+		let magnitude;
+		if (value < 0n) magnitude = (-value << 1n) - 1n;
+		else magnitude = value << 1n;
+		let sizeOffset;
+		let size = 0;
+		if (magnitude >> 64n === 0n) {
+			this.ensureCapacity(2);
+			this.writeFixExt8Symbol(this.bigIntExtension.type);
+		} else if (magnitude >> 128n === 0n) {
+			this.ensureCapacity(2);
+			this.writeFixExt16Symbol(this.bigIntExtension.type);
+		} else if (magnitude >> 1984n === 0n) {
+			this.ensureCapacity(3);
+			this.buffer[this.offset++] = require_symbols.EXT8;
+			sizeOffset = this.offset++;
+			this.buffer[this.offset++] = this.bigIntExtension.type;
+		} else if (magnitude >> 524224n === 0n) {
+			this.ensureCapacity(4);
+			this.buffer[this.offset++] = require_symbols.EXT16;
+			sizeOffset = this.offset;
+			this.offset += 2;
+			this.buffer[this.offset++] = this.bigIntExtension.type;
+		} else {
+			this.ensureCapacity(6);
+			this.buffer[this.offset++] = require_symbols.EXT32;
+			sizeOffset = this.offset;
+			this.offset += 4;
+			this.buffer[this.offset++] = this.bigIntExtension.type;
+		}
+		if (magnitude === 0n) {
+			this.ensureCapacity(8);
+			this.view.setBigUint64(this.offset, 0n, false);
+			this.offset += 8;
+			return this;
 		}
-		return 0;
+		while (magnitude > 0n) {
+			this.ensureCapacity(8);
+			this.view.setBigUint64(this.offset, magnitude & BIGINT_MASK, false);
+			this.offset += 8;
+			magnitude >>= 64n;
+			size += 8;
+		}
+		if (sizeOffset !== void 0) {
+			if (require_utils_fitIn8Bits(size)) this.buffer[sizeOffset] = size;
+			else if (require_utils_fitIn16Bits(size)) this.view.setUint16(sizeOffset, size, false);
+			else this.view.setUint32(sizeOffset, size, false);
+		}
+		return this;
 	}
-	writeBigInt(value) {
-		if (this.tryToWriteExtensionValue(value) > 0) return this;
-		throw new TypeError("\"bigint\" encoding is not supported by default. Consider using BigIntExtension");
+	writeError(error) {
+		if (!this.errorExtension) throw new Error(`Error extension is disabled, cannot encode Error.`);
+		this.errorExtension.encodeInto(error, this);
+		return this;
 	}
 	writeObject(value) {
 		if (Array.isArray(value)) return this.writeArray(value);
-		if (this.tryToWriteExtensionValue(value) > 0) return this;
 		if (value instanceof Uint8Array) return this.writeUint8Array(value);
+		const valueConstructor = value.constructor;
+		const builtInExtension = this.builtInExtensionsByConstructors.get(valueConstructor);
+		if (builtInExtension) {
+			builtInExtension.encodeInto(value, this);
+			return this;
+		}
+		const extension = this.extensionsByConstructors.get(valueConstructor);
+		if (extension) {
+			const extensionEncoder = this.getExtensionEncoder();
+			extensionEncoder.resetBuffer();
+			extension.encode(value, extensionEncoder);
+			if (extensionEncoder.offset > 0) return this.writeExtension(extension, extensionEncoder);
+		}
 		return this.writeMap(value);
 	}
 	write(value) {

package/dist/cjs/encoder/encoder.d.cts

@@ -1,2 +1,2 @@
-import { t as Encoder } from "../encoder-C9JlmRrE.cjs";
+import { t as Encoder } from "../encoder-yQYOtvXU.cjs";
 export = Encoder;

package/dist/cjs/encoder/index.d.cts

@@ -1,7 +1,7 @@
-import { a as MessagePackEncoder, i as OmitByPattern, n as EncoderOptions, r as ExtensionEncoder } from "../messagePackExtension-DS5fpQDE.cjs";
-import { t as MessagePackTextEncoder } from "../messagePackTextEncoder-D7iCft_t.cjs";
+import { a as EncoderOptions, n as MessagePackEncoder, o as ExtensionEncoder } from "../error-B129l__v.cjs";
+import { t as MessagePackTextEncoder } from "../messagePackTextEncoder-MeyNUt3L.cjs";
+import { t as Encoder } from "../encoder-yQYOtvXU.cjs";
 import { t as encode } from "../encode-4SxHVw0M.cjs";
-import { t as Encoder } from "../encoder-C9JlmRrE.cjs";
-import { t as DefaultTextEncoder } from "../defaultTextEncoder-DzdGBX6s.cjs";
-import { t as NodeTextEncoder } from "../nodeTextEncoder-DJzFDBXd.cjs";
-export { DefaultTextEncoder, Encoder, type EncoderOptions, type ExtensionEncoder, type MessagePackEncoder, type MessagePackTextEncoder, NodeTextEncoder, type OmitByPattern, encode };
+import { t as DefaultTextEncoder } from "../defaultTextEncoder-BpUrJKD9.cjs";
+import { t as NodeTextEncoder } from "../nodeTextEncoder-BpJi8Jx-.cjs";
+export { DefaultTextEncoder, Encoder, type EncoderOptions, type ExtensionEncoder, type MessagePackEncoder, type MessagePackTextEncoder, NodeTextEncoder, encode };

package/dist/cjs/encoder/interfaces/index.d.cts

@@ -1,4 +1,4 @@
-import { a as MessagePackEncoder } from "../../messagePackExtension-DS5fpQDE.cjs";
-import { t as MessagePackTextEncoder } from "../../messagePackTextEncoder-D7iCft_t.cjs";
-import "../../index-DMnXy2Rv.cjs";
+import { n as MessagePackEncoder } from "../../error-B129l__v.cjs";
+import { t as MessagePackTextEncoder } from "../../messagePackTextEncoder-MeyNUt3L.cjs";
+import "../../index-CaxrMD1A.cjs";
 export type { MessagePackEncoder, MessagePackTextEncoder };

package/dist/cjs/encoder/interfaces/messagePackEncoder.d.cts

@@ -1,2 +1,2 @@
-import { a as MessagePackEncoder } from "../../messagePackExtension-DS5fpQDE.cjs";
+import { n as MessagePackEncoder } from "../../error-B129l__v.cjs";
 export = MessagePackEncoder;

package/dist/cjs/encoder/interfaces/messagePackTextEncoder.d.cts

@@ -1,2 +1,2 @@
-import { t as MessagePackTextEncoder } from "../../messagePackTextEncoder-D7iCft_t.cjs";
+import { t as MessagePackTextEncoder } from "../../messagePackTextEncoder-MeyNUt3L.cjs";
 export = MessagePackTextEncoder;

package/dist/cjs/encoder/textEncoders/defaultTextEncoder.d.cts

@@ -1,2 +1,2 @@
-import { t as DefaultTextEncoder } from "../../defaultTextEncoder-DzdGBX6s.cjs";
+import { t as DefaultTextEncoder } from "../../defaultTextEncoder-BpUrJKD9.cjs";
 export = DefaultTextEncoder;

package/dist/cjs/encoder/textEncoders/index.d.cts

@@ -1,4 +1,4 @@
-import { t as DefaultTextEncoder } from "../../defaultTextEncoder-DzdGBX6s.cjs";
-import { t as NodeTextEncoder } from "../../nodeTextEncoder-DJzFDBXd.cjs";
+import { t as DefaultTextEncoder } from "../../defaultTextEncoder-BpUrJKD9.cjs";
+import { t as NodeTextEncoder } from "../../nodeTextEncoder-BpJi8Jx-.cjs";
 import "../../index-CQnkyOId.cjs";
 export { DefaultTextEncoder, NodeTextEncoder };

package/dist/cjs/encoder/textEncoders/nodeTextEncoder.d.cts

@@ -1,2 +1,2 @@
-import { t as NodeTextEncoder } from "../../nodeTextEncoder-DJzFDBXd.cjs";
+import { t as NodeTextEncoder } from "../../nodeTextEncoder-BpJi8Jx-.cjs";
 export = NodeTextEncoder;

package/dist/cjs/encoder/types.d.cts

@@ -1,2 +1,2 @@
-import { i as OmitByPattern, n as EncoderOptions, r as ExtensionEncoder } from "../messagePackExtension-DS5fpQDE.cjs";
-export { EncoderOptions, ExtensionEncoder, OmitByPattern };
+import { a as EncoderOptions, o as ExtensionEncoder } from "../error-B129l__v.cjs";
+export { EncoderOptions, ExtensionEncoder };

package/dist/cjs/{encoder-C9JlmRrE.d.cts → encoder-yQYOtvXU.d.cts}

@@ -1,12 +1,10 @@
-import { t as BufferFactory } from "./types-DTcs4Mkd.cjs";
-import { a as MessagePackEncoder, n as EncoderOptions, r as ExtensionEncoder, t as MessagePackExtension } from "./messagePackExtension-DS5fpQDE.cjs";
-import { t as MessagePackTextEncoder } from "./messagePackTextEncoder-D7iCft_t.cjs";
-import { t as BufferWithExtensions } from "./bufferWithExtensions-Bn-W9WIx.cjs";
+import { t as Constructor } from "./types-BcIA43h9.cjs";
+import { a as EncoderOptions, c as BufferFactory, f as MessagePackBuiltInExtension, i as MessagePackExtension, n as MessagePackEncoder, o as ExtensionEncoder } from "./error-B129l__v.cjs";
+import { t as MessagePackTextEncoder } from "./messagePackTextEncoder-MeyNUt3L.cjs";
+import { t as BufferWithExtensions } from "./bufferWithExtensions-Cg4LGSIy.cjs";
 //#region src/encoder/encoder.d.ts
 declare class Encoder<TBuffer extends Uint8Array = Uint8Array> extends BufferWithExtensions<TBuffer> implements MessagePackEncoder<TBuffer> {
   #private;
-  /** The current offset in the buffer where the next write operation will occur. */
-  offset: number;
   /**
    * Shared buffer is used to encode strings, to avoid allocating a new buffer
    * for each string. The shared buffer is resized if the string is larger than
@@ -14,6 +12,10 @@ declare class Encoder<TBuffer extends Uint8Array = Uint8Array> extends BufferWit
    * reducing memory allocations and garbage collection overhead.
    */
   protected sharedBuffer: TBuffer;
+  protected extensionsByConstructors: Map<Constructor<object>, MessagePackExtension<object, TBuffer>>;
+  protected builtInExtensionsByConstructors: Map<Constructor<object>, MessagePackBuiltInExtension<object, TBuffer>>;
+  /** The current offset in the buffer where the next write operation will occur. */
+  offset: number;
   /**
    * Determines whether the keys of a map should be sorted before encoding.
    * Sorting keys can be useful for ensuring consistent serialization of
@@ -29,17 +31,31 @@ declare class Encoder<TBuffer extends Uint8Array = Uint8Array> extends BufferWit
    * small numbers.
    */
   readonly forceFloat32: boolean;
+  /**
+   * The initial size of the main buffer. This determines how much memory is
+   * allocated for the buffer when the encoder is first created. If the buffer
+   * needs to grow beyond this size, it will be reallocated with a larger size.
+   */
+  readonly initialBufferSize: number;
+  /**
+   * The initial size of the shared buffer used for encoding strings. This
+   * determines how much memory is allocated for the shared buffer when the
+   * encoder is first created. If the shared buffer needs to grow beyond this
+   * size, it will be reallocated with a larger size.
+   */
+  readonly initialSharedBufferSize: number;
   /**
    * A function that creates a new buffer of the specified size. This function
    * is used to allocate new buffers when the current buffer is not large enough
    * to accommodate the data being written. The function should return a new
    * instance of TBuffer with the specified size.
    */
-  protected bufferFactory: BufferFactory<TBuffer>;
+  readonly bufferFactory: BufferFactory<TBuffer>;
   readonly textEncoder: MessagePackTextEncoder<TBuffer>;
   buffer: TBuffer;
   view: DataView;
   constructor(options?: Partial<EncoderOptions<TBuffer>>);
+  addExtension<TValue extends object>(extension: MessagePackExtension<TValue, TBuffer>): this;
   getExtensionEncoder(): Encoder<TBuffer>;
   resizeBuffer(newSize: number): this;
   ensureCapacity(sizeToWrite: number): this;
@@ -47,7 +63,7 @@ declare class Encoder<TBuffer extends Uint8Array = Uint8Array> extends BufferWit
   flush(): TBuffer;
   writePositiveFixInt(value: number): this;
   writeNegativeFixInt(value: number): this;
-  writeBin(bytes: Uint8Array): this;
+  writeBin<TBytes extends Uint8Array>(bytes: TBytes): this;
   writeFloat32(value: number): this;
   writeFloat64(value: number): this;
   writeUint8(value: number): this;
@@ -103,12 +119,13 @@ declare class Encoder<TBuffer extends Uint8Array = Uint8Array> extends BufferWit
   openArray(length: number): this;
   writeArray(value: unknown[]): this;
   writeUint8Array(value: Uint8Array): this;
-  writeExtension(extension: MessagePackExtension, encoder: ExtensionEncoder<TBuffer>): this;
-  tryToWriteExtensionValue(value: object | bigint): number;
+  writeExtensionSymbol(type: number, size: number): this;
+  writeExtension<TValue extends object = object>(extension: MessagePackExtension<TValue, TBuffer> | MessagePackBuiltInExtension<TValue, TBuffer>, extensionEncoder: ExtensionEncoder<TBuffer>): this;
   writeBigInt(value: bigint): this;
+  writeError(error: Error): this;
   writeObject(value: object): this;
   write(value: unknown): this;
 }
 //#endregion
 export { Encoder as t };
-//# sourceMappingURL=encoder-C9JlmRrE.d.cts.map
+//# sourceMappingURL=encoder-yQYOtvXU.d.cts.map

package/dist/cjs/encoder-yQYOtvXU.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoder-yQYOtvXU.d.cts","names":[],"sources":["../../src/encoder/encoder.ts"],"mappings":";;;;;cA0BM,QAAQ,gBAAgB,aAAa,oBACjC,qBAAqB,oBAClB,mBAAmB;;;;;;;;YAQpB,cAAc;YAEd,0BAAwB,IAAA,qBAAA,6BAAA;YAKxB,iCAA+B,IAAA,qBAAA,oCAAA;;EAMzC;;;;;;;WAQS;;;;;;;;WASA;;;;;;WAOA;;;;;;;WAQA;;;;;;;WAQA,eAAe,cAAc;WAE7B,aAAa,uBAAuB;EAE7C,QAAQ;EACR,MAAM;EAcN,YAAY,UAAU,QAAQ,eAAe;EA4CpC,aAAa,uBACpB,WAAW,qBAAqB,QAAQ;EAmB1C,uBAAuB,QAAQ;EA0B/B,aAAa;EAeb,eAAe;EAUf;EAMA,SAAS;EAST,oBAAoB;EAMpB,oBAAoB;EAMpB,SAAS,eAAe,YAAY,OAAO;EAQ3C,aAAa;EAOb,aAAa;EAOb,WAAW;EAMX,YAAY;EAOZ,YAAY;EAOZ,YAAY;EAaZ,UAAU;EAMV,WAAW;EAOX,WAAW;EAOX,WAAW;EAYX,SAAS;EAMT;EAMA;EAMA;EAMA,kBAAkB;EAMlB,oBAAoB;EAMpB,kBAAkB;EAMlB,gBAAgB;EAOhB,iBAAiB;EAQjB,iBAAiB;EAQjB;EAMA;EAMA;EAMA;EAMA;EAMA;EAMA;EAMA;EAMA;EAMA;EAMA,gBAAgB;EAOhB,iBAAiB;EASjB,iBAAiB;EASjB,mBAAmB;EASnB,mBAAmB;EASnB,iBAAiB;EASjB,iBAAiB;EASjB,mBAAmB;EAOnB,mBAAmB;EAOnB,mBAAmB;EAOnB,mBAAmB;EAOnB,oBAAoB;EAOpB,gBAAgB,cAAc;EAQ9B,iBAAiB,cAAc;EAW/B,iBAAiB,cAAc;EAW/B,YAAY;EAyGZ,mBAAmB;EA2BnB,qBAAqB;EAmCrB,WAAW;EAYX,YAAY;EAYZ,QAAQ;EAqBR,SAAS,8BAA8B,QACrC,OAAO,OAAO,MAAM;EAqBtB,UAAU;EAqBV,WAAW;EAYX,gBAAgB,OAAO;EAiBvB,qBAAqB,cAAc;EAwCnC,eAAe,gCACb,WACI,qBAAqB,QAAQ,WAC7B,4BAA4B,QAAQ,UACxC,kBAAkB,iBAAiB;EAgBrC,YAAY;EA8EZ,WAAW,OAAO;EAUlB,YAAY;EAqCZ,MAAM"}