@zudojs/serialization 0.1.0 → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zudojs Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,6 @@
 # @zudojs/serialization
 
-Data translation layer with JSON serializer, type transformers, envelopes, and registry for Zudojs applications.
+JSON serialization with optional type preservation, a transformer registry, and an envelope for cross-service payloads.
 
 ## Installation
 
@@ -13,26 +13,142 @@ npm install @zudojs/serialization
 ```typescript
 import { createSerializer } from "@zudojs/serialization";
 
-const serializer = createSerializer({
-  format: "json",
-  transformers: [dateTransformer, bigIntTransformer],
+// Format is positional; options are per-instance defaults.
+const serializer = createSerializer("json", { preserveTypes: true });
+
+const json = serializer.serialize({ id: "123", createdAt: new Date() });
+const value = serializer.deserialize<{ id: string; createdAt: Date }>(json);
+
+value.createdAt instanceof Date; // true
+```
+
+The methods are `serialize` / `deserialize`, and every option can be overridden
+per call:
+
+```typescript
+serializer.serialize(value, { pretty: true, maxSize: 1_000_000 });
+serializer.deserialize(json, { strict: true, maxDepth: 64 });
+```
+
+## Type preservation
+
+By default the serializer is a thin pass to `JSON.stringify`/`JSON.parse`. With
+`preserveTypes`, values that JSON cannot represent are tagged and restored:
+
+```typescript
+const s = createSerializer("json", { preserveTypes: true });
+
+const value = {
+  when: new Date(),
+  amount: 42n,
+  seen: new Set(["a"]),
+  index: new Map([["k", new Date()]]),
+  bytes: new Uint8Array([1, 2, 3]),
+};
+
+const json = s.serialize(value);
+const back = s.deserialize<typeof value>(json);
+// Date, BigInt, Set, Map, Uint8Array all restored — including values nested
+// inside a Map or Set.
+```
+
+Built-in transformers cover `Date`, `BigInt`, `Map`, `Set`, `Uint8Array`/`Buffer`
+and `Error`. Register your own against the same contract:
+
+```typescript
+import { TransformerRegistry, JSONSerializer } from "@zudojs/serialization";
+
+const registry = new TransformerRegistry();
+registry.register({
+  type: "Money",
+  canSerialize: (v): v is Money => v instanceof Money,
+  serialize: (v) => ({ $type: "Money", $value: v.toString() }),
+  deserialize: (v) => Money.parse((v as { $value: string }).$value),
+});
+
+const serializer = new JSONSerializer({ transformers: registry });
+```
+
+## Untrusted input
+
+`deserialize` is the boundary that matters — the string arrives from a queue, an
+RPC peer or a request body.
+
+- **Prototype-polluting keys are dropped** on the `preserveTypes` path, which
+  is the one that rebuilds objects key by key. `__proto__`, `constructor` and
+  `prototype` never reach the reconstructed object; set `allowUnsafeKeys` to
+  keep them, as real own properties, when the payload is trusted. The fast path
+  is plain `JSON.parse`, where `__proto__` survives as an inert own property and
+  never reaches the prototype — but do not spread or deep-merge such an object
+  into another without screening its keys.
+- **Input is size-bounded** by `maxSize`, and depth-bounded by `maxDepth`. On
+  the `preserveTypes` path the depth limit defaults to 128; on the fast path it
+  is enforced whenever you set it, per call or as an instance default.
+- **An unrecognised `$type` tag is treated as ordinary data**, so a peer cannot
+  stop the consumer with `{"$type":"anything"}` and your own records may carry a
+  `$type` field. Pass `strict: true` to make an unknown tag an error instead.
+
+## Errors
+
+Stack traces are **not** serialized unless you ask, because a serialized error
+routinely ends up in a queue message or a log sink:
+
+```typescript
+serializer.serialize({ error }, { preserveTypes: true }); // name, message, code
+serializer.serialize({ error }, { preserveTypes: true, includeStack: true });
+```
+
+On the way back, a wire-supplied stack is attached as a non-enumerable
+`originalStack` rather than overwriting the reconstructed error's own.
+
+## Envelopes
+
+An envelope carries the metadata a consumer needs to decode the payload:
+
+```typescript
+import {
+  serializeToEnvelope,
+  deserializeFromEnvelope,
+} from "@zudojs/serialization";
+
+const envelope = serializeToEnvelope(payload, serializer);
+// { metadata: { format, version, contentType, encoding }, data }
+
+const value = deserializeFromEnvelope(envelope, serializer, "json");
+```
+
+Both helpers forward a fourth argument to the serializer, so the options that
+matter on the wire are reachable through an envelope:
+
+```typescript
+const envelope = serializeToEnvelope(payload, serializer, "json", {
+  preserveTypes: true,
 });
 
-const json = serializer.stringify({ id: "123", createdAt: new Date() });
-const obj = serializer.parse(json);
+const value = deserializeFromEnvelope(envelope, serializer, "json", {
+  preserveTypes: true,
+  strict: true,
+  maxSize: 1_000_000,
+});
 ```
 
+`unwrapEnvelope` validates the shape and rejects a payload stamped with a schema
+version newer than this build understands, rather than misreading it.
+`contentType` is derived from the format.
+
 ## Features
 
-- JSON serialization with type transformers
-- Envelope pattern for API responses
-- Transformer registry
-- Support for BigInt, Date, Buffer, and custom types
-- Circular reference detection
+- JSON serialization with opt-in type preservation
+- Built-in transformers for Date, BigInt, Map, Set, Buffer and Error
+- Transformer registry for custom types
+- Envelope pattern with schema-version and encoding checks
+- Prototype-pollution protection on reconstruction
+- Size and depth limits on both directions
+- Circular reference detection (on the `preserveTypes` path)
 
 ## Use Cases
 
-- API response serialization
-- Event payload serialization
-- Cache serialization
-- Cross-service data transfer
+- Queue and RPC message payloads
+- Cross-service communication
+- Cache value encoding
+- API responses carrying non-JSON types

package/dist/index.d.ts

@@ -24,7 +24,7 @@
  * );
  * ```
  */
-export type { SerializationFormat, SerializedValue, SerializeOptions, DeserializeOptions, SerializationMetadata, SerializedEnvelope, Serializer, AsyncSerializer, TypeTransformer, UndefinedStrategy, } from "./serializerTypes/index.js";
+export type { SerializationFormat, SerializedValue, SerializeOptions, DeserializeOptions, SerializationMetadata, SerializedEnvelope, Serializer, TypeTransformer, } from "./serializerTypes/index.js";
 export { JSONSerializer } from "./serializerJson/index.js";
 export { TransformerRegistry } from "./serializerTransforms/index.js";
 export { DateTransformer } from "./serializerTransforms/index.js";
@@ -34,7 +34,8 @@ export { SetTransformer } from "./serializerTransforms/index.js";
 export { BufferTransformer } from "./serializerTransformsExt/index.js";
 export { ErrorTransformer } from "./serializerTransformsExt/index.js";
 export { toBase64, fromBase64, encodeUtf8, decodeUtf8, } from "./serializerTransformsExt/index.js";
-export { createEnvelope, unwrapEnvelope, serializeToEnvelope, deserializeFromEnvelope, } from "./serializerEnvelope/index.js";
+export { createEnvelope, assertValidEnvelope, contentTypeForFormat, unwrapEnvelope, serializeToEnvelope, deserializeFromEnvelope, } from "./serializerEnvelope/index.js";
 export { SerializerRegistry } from "./serializerRegistry/index.js";
 export { createSerializer, createDefaultRegistry, } from "./serializerRegistry/index.js";
+export type { CreateSerializerOptions } from "./serializerRegistry/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -37,7 +37,7 @@ export { BufferTransformer } from "./serializerTransformsExt/index.js";
 export { ErrorTransformer } from "./serializerTransformsExt/index.js";
 export { toBase64, fromBase64, encodeUtf8, decodeUtf8, } from "./serializerTransformsExt/index.js";
 // ─── Envelope ─────────────────────────────────────────────────
-export { createEnvelope, unwrapEnvelope, serializeToEnvelope, deserializeFromEnvelope, } from "./serializerEnvelope/index.js";
+export { createEnvelope, assertValidEnvelope, contentTypeForFormat, unwrapEnvelope, serializeToEnvelope, deserializeFromEnvelope, } from "./serializerEnvelope/index.js";
 // ─── Registry & Factory ───────────────────────────────────────
 export { SerializerRegistry } from "./serializerRegistry/index.js";
 export { createSerializer, createDefaultRegistry, } from "./serializerRegistry/index.js";

package/dist/serializerEnvelope/envelope.core.d.ts

@@ -5,7 +5,7 @@
  * so consumers know how to deserialize the payload. Essential for
  * messaging, queues, RPC, and cross-service communication.
  */
-import type { SerializedEnvelope, SerializedValue } from "../serializerTypes/index.js";
+import type { SerializedEnvelope, SerializedValue, SerializeOptions, DeserializeOptions } from "../serializerTypes/index.js";
 /**
  * Create a serialization envelope wrapping data with metadata.
  *
@@ -19,6 +19,20 @@ export declare function createEnvelope(data: SerializedValue, format?: string, o
     readonly contentType?: string;
     readonly encoding?: string;
 }): SerializedEnvelope;
+/**
+ * Maps a format identifier to its MIME content type.
+ *
+ * Defaulting every envelope to `application/json` regardless of format is how
+ * a msgpack payload ends up labelled as JSON on the wire.
+ */
+export declare function contentTypeForFormat(format: string): string;
+/**
+ * Validates that a value received from the wire is a well-formed envelope.
+ *
+ * @param envelope - The candidate envelope.
+ * @throws {Error} when the shape or schema version is unusable.
+ */
+export declare function assertValidEnvelope(envelope: unknown): asserts envelope is SerializedEnvelope;
 /**
  * Extract the data from an envelope, validating metadata.
  *
@@ -34,20 +48,29 @@ export declare function unwrapEnvelope(envelope: SerializedEnvelope, expectedFor
  * @param value - The value to serialize.
  * @param serializer - The serializer to use.
  * @param format - The format identifier for metadata.
+ * @param options - Serialize options forwarded to the serializer. Without this
+ *   the helper could only ever call `serialize(value)`, so `preserveTypes`,
+ *   `pretty` and the size/depth limits were unreachable through an envelope
+ *   unless they happened to be baked into the serializer instance.
  * @returns A SerializedEnvelope containing the serialized data.
  */
 export declare function serializeToEnvelope<T>(value: T, serializer: {
-    serialize: (v: T) => string;
-}, format?: string): SerializedEnvelope;
+    serialize: (v: T, options?: SerializeOptions) => string;
+    contentType?: string;
+}, format?: string, options?: SerializeOptions): SerializedEnvelope;
 /**
  * Unwrap an envelope and deserialize the data.
  *
  * @param envelope - The envelope to unwrap.
  * @param deserializer - The deserializer to use.
  * @param expectedFormat - Optional format to validate against.
+ * @param options - Deserialize options forwarded to the deserializer, so that
+ *   `preserveTypes`, `strict`, `maxSize` and `maxDepth` are reachable through
+ *   an envelope. Envelope payloads arrive from the wire, which is exactly
+ *   where those limits matter.
  * @returns The deserialized value.
  */
 export declare function deserializeFromEnvelope<T>(envelope: SerializedEnvelope, deserializer: {
-    deserialize: <U>(v: string) => U;
-}, expectedFormat?: string): T;
+    deserialize: <U>(v: string, options?: DeserializeOptions) => U;
+}, expectedFormat?: string, options?: DeserializeOptions): T;
 //# sourceMappingURL=envelope.core.d.ts.map

package/dist/serializerEnvelope/envelope.core.js

@@ -6,7 +6,7 @@
  * messaging, queues, RPC, and cross-service communication.
  */
 import { SerializationFormat, SerializationContentType, SERIALIZATION_SCHEMA_VERSION, } from "@zudojs/constants";
-import { encodeUtf8, decodeUtf8 } from "../serializerTransformsExt/index.js";
+import { decodeUtf8 } from "../serializerTransformsExt/index.js";
 /**
  * Create a serialization envelope wrapping data with metadata.
  *
@@ -20,12 +20,66 @@ export function createEnvelope(data, format = SerializationFormat.JSON, options
         metadata: {
             format,
             version: options.version ?? SERIALIZATION_SCHEMA_VERSION,
-            contentType: options.contentType ?? SerializationContentType.JSON,
+            contentType: options.contentType ?? contentTypeForFormat(format),
             encoding: options.encoding ?? "utf-8",
         },
         data,
     };
 }
+/**
+ * Maps a format identifier to its MIME content type.
+ *
+ * Defaulting every envelope to `application/json` regardless of format is how
+ * a msgpack payload ends up labelled as JSON on the wire.
+ */
+export function contentTypeForFormat(format) {
+    switch (format) {
+        case SerializationFormat.JSON:
+            return SerializationContentType.JSON;
+        case "text":
+            return "text/plain";
+        case "binary":
+            return "application/octet-stream";
+        case "messagepack":
+        case "msgpack":
+            return "application/msgpack";
+        default:
+            return "application/octet-stream";
+    }
+}
+/**
+ * Validates that a value received from the wire is a well-formed envelope.
+ *
+ * @param envelope - The candidate envelope.
+ * @throws {Error} when the shape or schema version is unusable.
+ */
+export function assertValidEnvelope(envelope) {
+    if (typeof envelope !== "object" || envelope === null) {
+        throw new Error(`Malformed envelope: expected an object, got ${envelope === null ? "null" : typeof envelope}`);
+    }
+    const candidate = envelope;
+    if (typeof candidate.metadata !== "object" || candidate.metadata === null) {
+        throw new Error("Malformed envelope: missing metadata");
+    }
+    const metadata = candidate.metadata;
+    if (typeof metadata.format !== "string" || metadata.format.length === 0) {
+        throw new Error("Malformed envelope: metadata.format is missing");
+    }
+    if (typeof candidate.data !== "string" &&
+        !(candidate.data instanceof Uint8Array)) {
+        throw new Error("Malformed envelope: data must be a string or Uint8Array");
+    }
+    // The version exists so a future producer can be detected rather than
+    // silently misread. Older versions stay readable; newer ones do not.
+    if (metadata.version !== undefined) {
+        if (!Number.isInteger(metadata.version)) {
+            throw new Error(`Malformed envelope: metadata.version must be an integer, got ${String(metadata.version)}`);
+        }
+        if (metadata.version > SERIALIZATION_SCHEMA_VERSION) {
+            throw new Error(`Unsupported envelope schema version ${metadata.version}: this build understands up to ${SERIALIZATION_SCHEMA_VERSION}`);
+        }
+    }
+}
 /**
  * Extract the data from an envelope, validating metadata.
  *
@@ -35,6 +89,7 @@ export function createEnvelope(data, format = SerializationFormat.JSON, options
  * @throws {Error} when the envelope format doesn't match expectations.
  */
 export function unwrapEnvelope(envelope, expectedFormat) {
+    assertValidEnvelope(envelope);
     if (expectedFormat && envelope.metadata.format !== expectedFormat) {
         throw new Error(`Envelope format mismatch: expected "${expectedFormat}", got "${envelope.metadata.format}"`);
     }
@@ -46,11 +101,17 @@ export function unwrapEnvelope(envelope, expectedFormat) {
  * @param value - The value to serialize.
  * @param serializer - The serializer to use.
  * @param format - The format identifier for metadata.
+ * @param options - Serialize options forwarded to the serializer. Without this
+ *   the helper could only ever call `serialize(value)`, so `preserveTypes`,
+ *   `pretty` and the size/depth limits were unreachable through an envelope
+ *   unless they happened to be baked into the serializer instance.
  * @returns A SerializedEnvelope containing the serialized data.
  */
-export function serializeToEnvelope(value, serializer, format = SerializationFormat.JSON) {
-    const data = serializer.serialize(value);
-    return createEnvelope(data, format);
+export function serializeToEnvelope(value, serializer, format = SerializationFormat.JSON, options) {
+    const data = serializer.serialize(value, options);
+    return createEnvelope(data, format, {
+        contentType: serializer.contentType,
+    });
 }
 /**
  * Unwrap an envelope and deserialize the data.
@@ -58,11 +119,21 @@ export function serializeToEnvelope(value, serializer, format = SerializationFor
  * @param envelope - The envelope to unwrap.
  * @param deserializer - The deserializer to use.
  * @param expectedFormat - Optional format to validate against.
+ * @param options - Deserialize options forwarded to the deserializer, so that
+ *   `preserveTypes`, `strict`, `maxSize` and `maxDepth` are reachable through
+ *   an envelope. Envelope payloads arrive from the wire, which is exactly
+ *   where those limits matter.
  * @returns The deserialized value.
  */
-export function deserializeFromEnvelope(envelope, deserializer, expectedFormat) {
+export function deserializeFromEnvelope(envelope, deserializer, expectedFormat, options) {
     const data = unwrapEnvelope(envelope, expectedFormat);
-    const str = typeof data === "string" ? data : decodeUtf8(data);
-    return deserializer.deserialize(str);
+    if (typeof data === "string") {
+        return deserializer.deserialize(data, options);
+    }
+    const encoding = (envelope.metadata.encoding ?? "utf-8").toLowerCase();
+    if (encoding !== "utf-8" && encoding !== "utf8") {
+        throw new Error(`Unsupported envelope encoding "${envelope.metadata.encoding}": only UTF-8 is supported`);
+    }
+    return deserializer.deserialize(decodeUtf8(data), options);
 }
 //# sourceMappingURL=envelope.core.js.map

package/dist/serializerEnvelope/index.d.ts

@@ -3,5 +3,5 @@
  *
  * Wraps serialized data with metadata for cross-service communication.
  */
-export { createEnvelope, unwrapEnvelope, serializeToEnvelope, deserializeFromEnvelope, } from "./envelope.core.js";
+export { createEnvelope, assertValidEnvelope, contentTypeForFormat, unwrapEnvelope, serializeToEnvelope, deserializeFromEnvelope, } from "./envelope.core.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/serializerEnvelope/index.js

@@ -3,5 +3,5 @@
  *
  * Wraps serialized data with metadata for cross-service communication.
  */
-export { createEnvelope, unwrapEnvelope, serializeToEnvelope, deserializeFromEnvelope, } from "./envelope.core.js";
+export { createEnvelope, assertValidEnvelope, contentTypeForFormat, unwrapEnvelope, serializeToEnvelope, deserializeFromEnvelope, } from "./envelope.core.js";
 //# sourceMappingURL=index.js.map

package/dist/serializerJson/jsonSerializer.core.d.ts

@@ -11,8 +11,11 @@ export declare class JSONSerializer implements Serializer<unknown, string> {
     readonly name = "json";
     readonly contentType = "application/json";
     private readonly transformers;
+    private readonly defaults;
     constructor(options?: {
         readonly transformers?: TransformerRegistry;
+        /** Default options merged into every call. */
+        readonly defaults?: SerializeOptions & DeserializeOptions;
     });
     /** Register a custom type transformer. */
     registerTransformer(transformer: import("../serializerTypes/index.js").TypeTransformer): void;
@@ -22,5 +25,6 @@ export declare class JSONSerializer implements Serializer<unknown, string> {
     private restoreValue;
     private assertValidJson;
     private assertOutputSize;
+    private assertInputSize;
 }
 //# sourceMappingURL=jsonSerializer.core.d.ts.map

package/dist/serializerJson/jsonSerializer.core.js

@@ -8,9 +8,9 @@
 import { TransformerRegistry } from "../serializerTransforms/index.js";
 import { DateTransformer, BigIntTransformer, MapTransformer, SetTransformer, } from "../serializerTransforms/index.js";
 import { BufferTransformer, ErrorTransformer, } from "../serializerTransformsExt/index.js";
-import { SerializationLimits, SerializationTags } from "@zudojs/constants";
+import { SerializationLimits, SerializationTags, SCHEMA_FORBIDDEN_KEYS, } from "@zudojs/constants";
 import { isPlainObject } from "@zudojs/types";
-import { assertNoCircularReference, assertDepthWithinLimit, assertSizeWithinLimit, } from "@zudojs/validation";
+import { assertNoCircularReference, assertDepthWithinLimit, } from "@zudojs/validation";
 /** Default transformer registry with all built-in transformers. */
 function createDefaultTransformers() {
     const registry = new TransformerRegistry();
@@ -26,110 +26,136 @@ export class JSONSerializer {
     name = "json";
     contentType = "application/json";
     transformers;
+    defaults;
     constructor(options) {
         this.transformers = options?.transformers ?? createDefaultTransformers();
+        this.defaults = options?.defaults ?? {};
     }
     /** Register a custom type transformer. */
     registerTransformer(transformer) {
         this.transformers.register(transformer);
     }
     serialize(value, options) {
-        const maxDepth = options?.maxDepth ?? SerializationLimits.MAX_DEPTH;
-        const maxSize = options?.maxSize ?? SerializationLimits.MAX_SIZE;
-        if (options?.preserveTypes === true) {
+        const opts = { ...this.defaults, ...options };
+        const maxDepth = opts.maxDepth ?? SerializationLimits.MAX_DEPTH;
+        const maxSize = opts.maxSize ?? SerializationLimits.MAX_SIZE;
+        if (opts.preserveTypes === true) {
             assertNoCircularReference(value);
             assertDepthWithinLimit(value, maxDepth);
-            const transformed = this.transformValue(value, 0, maxDepth);
-            const json = options?.pretty
-                ? JSON.stringify(transformed, null, options?.indent ?? 2)
+            const transformed = this.transformValue(value, 0, maxDepth, opts);
+            const json = opts.pretty
+                ? JSON.stringify(transformed, null, opts.indent ?? 2)
                 : JSON.stringify(transformed);
             this.assertOutputSize(json, maxSize);
             return json;
         }
-        const json = options?.pretty
-            ? JSON.stringify(value, null, options?.indent ?? 2)
+        // The fast path stays a bare `JSON.stringify` by default, but a depth
+        // limit the caller asked for must still be enforced: `maxDepth` used to
+        // be read only when `preserveTypes` was on, so a per-call or per-instance
+        // limit was silently ignored on the path most callers use.
+        if (opts.maxDepth !== undefined) {
+            assertDepthWithinLimit(value, maxDepth);
+        }
+        const json = opts.pretty
+            ? JSON.stringify(value, null, opts.indent ?? 2)
             : JSON.stringify(value);
         this.assertOutputSize(json, maxSize);
         return json;
     }
     deserialize(value, options) {
-        if (options?.strict === true)
+        const opts = { ...this.defaults, ...options };
+        // Bound the input before parsing. `maxSize` used to apply on the way out
+        // only, which is the wrong direction: serialized output is ours, whereas
+        // the string handed to `deserialize` arrives from a queue, an RPC peer, or
+        // a request body.
+        const maxSize = opts.maxSize ?? SerializationLimits.MAX_SIZE;
+        this.assertInputSize(value, maxSize);
+        if (opts.strict === true)
             this.assertValidJson(value);
         const parsed = JSON.parse(value);
-        if (options?.preserveTypes === true) {
-            const maxDepth = options?.maxDepth ?? SerializationLimits.MAX_DEPTH;
+        if (opts.preserveTypes === true) {
+            const maxDepth = opts.maxDepth ?? SerializationLimits.MAX_DEPTH;
             assertDepthWithinLimit(parsed, maxDepth);
-            return this.restoreValue(parsed, 0, maxDepth);
+            return this.restoreValue(parsed, 0, maxDepth, opts);
+        }
+        // Same contract on the fast path: an explicit `maxDepth` bounds input
+        // that arrives from the wire, whether or not types are being restored.
+        if (opts.maxDepth !== undefined) {
+            assertDepthWithinLimit(parsed, opts.maxDepth);
         }
         return parsed;
     }
-    transformValue(value, depth, maxDepth) {
+    transformValue(value, depth, maxDepth, options) {
         if (value === null || value === undefined)
             return value;
         if (typeof value === "bigint") {
             const transformer = this.transformers.findForValue(value);
-            return transformer ? transformer.serialize(value) : value.toString();
+            return transformer
+                ? transformer.serialize(value, options)
+                : value.toString();
         }
         if (typeof value !== "object")
             return value;
-        if (depth >= maxDepth)
-            return value;
+        if (depth >= maxDepth) {
+            // Depth is pre-checked by assertDepthWithinLimit, so this is a belt-and
+            // braces guard. Returning the raw value would silently emit an untagged
+            // Map or Date, which cannot round-trip — fail loudly instead.
+            throw new Error(`Serialization exceeded maximum depth of ${maxDepth}`);
+        }
         if (Array.isArray(value)) {
-            return value.map((item) => this.transformValue(item, depth + 1, maxDepth));
+            return value.map((item) => this.transformValue(item, depth + 1, maxDepth, options));
         }
         const transformer = this.transformers.findForValue(value);
         if (transformer) {
-            const raw = transformer.serialize(value);
-            return this.transformValue(raw, depth + 1, maxDepth);
-        }
-        if (value instanceof Map) {
-            const entries = [];
-            for (const [k, v] of value) {
-                entries.push([
-                    this.transformValue(k, depth + 1, maxDepth),
-                    this.transformValue(v, depth + 1, maxDepth),
-                ]);
-            }
-            return {
-                [SerializationTags.TYPE]: "Map",
-                [SerializationTags.VALUE]: entries,
-            };
-        }
-        if (value instanceof Set) {
-            return {
-                [SerializationTags.TYPE]: "Set",
-                [SerializationTags.VALUE]: [...value].map((v) => this.transformValue(v, depth + 1, maxDepth)),
-            };
+            const raw = transformer.serialize(value, options);
+            return this.transformValue(raw, depth + 1, maxDepth, options);
         }
         if (isPlainObject(value)) {
             const result = {};
             for (const key of Object.keys(value)) {
-                result[key] = this.transformValue(value[key], depth + 1, maxDepth);
+                defineKey(result, key, this.transformValue(value[key], depth + 1, maxDepth, options), options.allowUnsafeKeys === true);
             }
             return result;
         }
         return value;
     }
-    restoreValue(value, depth, maxDepth) {
+    restoreValue(value, depth, maxDepth, options) {
         if (value === null || value === undefined)
             return value;
         if (typeof value !== "object")
             return value;
-        if (depth >= maxDepth)
-            return value;
+        if (depth >= maxDepth) {
+            throw new Error(`Deserialization exceeded maximum depth of ${maxDepth}`);
+        }
         if (Array.isArray(value)) {
-            return value.map((item) => this.restoreValue(item, depth + 1, maxDepth));
+            return value.map((item) => this.restoreValue(item, depth + 1, maxDepth, options));
         }
         const obj = value;
         const typeTag = obj[SerializationTags.TYPE];
-        if (typeof typeTag === "string") {
-            const transformer = this.transformers.get(typeTag);
-            return transformer.deserialize(value);
+        if (typeof typeTag === "string" && this.transformers.has(typeTag)) {
+            // Restore the children first. A transformer receives a plain structure
+            // and has no way to recurse back into this serializer, so handing it the
+            // still-tagged payload is what used to leave a Map full of raw
+            // `{$type, $value}` objects.
+            const restoredShell = {};
+            for (const key of Object.keys(obj)) {
+                defineKey(restoredShell, key, key === SerializationTags.TYPE
+                    ? obj[key]
+                    : this.restoreValue(obj[key], depth + 1, maxDepth, options), options.allowUnsafeKeys === true);
+            }
+            return this.transformers.get(typeTag).deserialize(restoredShell, options);
+        }
+        // An unknown tag is ordinary data. Throwing here let any peer crash the
+        // consumer with `{"$type":"anything"}`, and made legitimate payloads that
+        // happen to carry a `$type` field unparseable.
+        if (typeof typeTag === "string" && options.strict === true) {
+            throw new Error(`Unknown serialization type tag: "${typeTag}". ` +
+                "Register a transformer for it, or deserialize without strict mode.");
         }
         if (isPlainObject(value)) {
             const result = {};
             for (const key of Object.keys(value)) {
-                result[key] = this.restoreValue(value[key], depth + 1, maxDepth);
+                defineKey(result, key, this.restoreValue(value[key], depth + 1, maxDepth, options), options.allowUnsafeKeys === true);
             }
             return result;
         }
@@ -144,12 +170,42 @@ export class JSONSerializer {
         }
     }
     assertOutputSize(json, maxSize) {
-        const size = typeof Buffer !== "undefined"
-            ? Buffer.byteLength(json, "utf-8")
-            : new TextEncoder().encode(json).byteLength;
+        const size = byteLength(json);
         if (size > maxSize) {
             throw new Error(`Serialized payload too large: ${size} bytes (max: ${maxSize})`);
         }
     }
+    assertInputSize(json, maxSize) {
+        const size = byteLength(json);
+        if (size > maxSize) {
+            throw new Error(`Serialized payload too large: ${size} bytes (max: ${maxSize})`);
+        }
+    }
+}
+/** Byte length of a string, in whichever runtime we are on. */
+function byteLength(value) {
+    return typeof Buffer !== "undefined"
+        ? Buffer.byteLength(value, "utf-8")
+        : new TextEncoder().encode(value).byteLength;
+}
+/**
+ * Assigns a key onto a freshly built object without invoking a setter.
+ *
+ * Plain assignment of `__proto__` does not create an own property — it calls
+ * the inherited setter and replaces the object's prototype, so an attacker's
+ * keys resolve on the result while `Object.keys` shows nothing. `defineProperty`
+ * always creates a real own property, and forbidden keys are dropped outright
+ * unless the caller has explicitly opted in with `allowUnsafeKeys`.
+ */
+function defineKey(target, key, value, allowUnsafeKeys) {
+    if (!allowUnsafeKeys && SCHEMA_FORBIDDEN_KEYS.has(key)) {
+        return;
+    }
+    Object.defineProperty(target, key, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
 }
 //# sourceMappingURL=jsonSerializer.core.js.map

package/dist/serializerRegistry/index.d.ts

@@ -6,4 +6,5 @@
  */
 export { SerializerRegistry } from "./serializerRegistry.core.js";
 export { createSerializer, createDefaultRegistry, } from "./serializerRegistry.factory.js";
+export type { CreateSerializerOptions } from "./serializerRegistry.factory.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/serializerRegistry/serializerRegistry.factory.d.ts

@@ -6,21 +6,33 @@
  * exposing concrete class constructors.
  */
 import type { Serializer, SerializationFormat } from "../serializerTypes/index.js";
+import { SerializationFormat as Format } from "@zudojs/constants";
 import { TransformerRegistry } from "../serializerTransforms/index.js";
 import { SerializerRegistry } from "./serializerRegistry.core.js";
+/** Options accepted when creating a serializer. */
+export interface CreateSerializerOptions {
+    /** Transformer registry to use instead of the built-in one. */
+    readonly transformers?: TransformerRegistry;
+    /** Pretty-print by default. Overridable per call. */
+    readonly pretty?: boolean;
+    /** Preserve special JS types by default. Overridable per call. */
+    readonly preserveTypes?: boolean;
+}
 /**
  * Create a serializer for the given format.
  *
+ * The `"json"` overload reports `Serializer<unknown, string>` rather than the
+ * `string | Uint8Array` union. JSON output is always a string, and the union
+ * made the result unusable with this package's own `serializeToEnvelope`,
+ * which needs a string-producing serializer.
+ *
  * @param format - The serialization format (e.g., "json").
  * @param options - Optional configuration for the serializer.
  * @returns A Serializer instance.
  * @throws {UnsupportedSerializationFormatError} when the format is not supported.
  */
-export declare function createSerializer(format: SerializationFormat, options?: {
-    readonly transformers?: TransformerRegistry;
-    readonly pretty?: boolean;
-    readonly preserveTypes?: boolean;
-}): Serializer;
+export declare function createSerializer(format: typeof Format.JSON, options?: CreateSerializerOptions): Serializer<unknown, string>;
+export declare function createSerializer(format: SerializationFormat, options?: CreateSerializerOptions): Serializer;
 /**
  * Create a default serializer registry pre-populated with built-in serializers.
  *

package/dist/serializerRegistry/serializerRegistry.factory.js

@@ -10,18 +10,21 @@ import { UnsupportedSerializationFormatError } from "@zudojs/errors";
 import { SerializationFormat as Format } from "@zudojs/constants";
 import { TransformerRegistry } from "../serializerTransforms/index.js";
 import { SerializerRegistry } from "./serializerRegistry.core.js";
-/**
- * Create a serializer for the given format.
- *
- * @param format - The serialization format (e.g., "json").
- * @param options - Optional configuration for the serializer.
- * @returns A Serializer instance.
- * @throws {UnsupportedSerializationFormatError} when the format is not supported.
- */
 export function createSerializer(format, options) {
     switch (format) {
         case Format.JSON:
-            return new JSONSerializer({ transformers: options?.transformers });
+            // `pretty` and `preserveTypes` used to be accepted and thrown away.
+            // They are now carried as per-instance defaults that each call can
+            // still override.
+            return new JSONSerializer({
+                transformers: options?.transformers,
+                defaults: {
+                    ...(options?.pretty !== undefined ? { pretty: options.pretty } : {}),
+                    ...(options?.preserveTypes !== undefined
+                        ? { preserveTypes: options.preserveTypes }
+                        : {}),
+                },
+            });
         default:
             throw new UnsupportedSerializationFormatError(format);
     }

package/dist/serializerTransformsExt/error.transformer.d.ts

@@ -2,7 +2,10 @@
  * @zudojs/serialization — Error transformer.
  *
  * Preserves Error instances across serialization boundaries.
- * Stack traces are controlled via options for security.
+ *
+ * Stack traces are omitted unless `includeStack` is set: a stack names
+ * absolute file paths and internal call structure, and a serialized error
+ * routinely ends up in a queue message, an RPC response, or a log sink.
  */
 import type { TypeTransformer } from "../serializerTypes/index.js";
 /** Transformer that handles Error round-trips. */

package/dist/serializerTransformsExt/error.transformer.js

@@ -2,7 +2,10 @@
  * @zudojs/serialization — Error transformer.
  *
  * Preserves Error instances across serialization boundaries.
- * Stack traces are controlled via options for security.
+ *
+ * Stack traces are omitted unless `includeStack` is set: a stack names
+ * absolute file paths and internal call structure, and a serialized error
+ * routinely ends up in a queue message, an RPC response, or a log sink.
  */
 import { SerializationTags } from "@zudojs/constants";
 const ERROR_TYPE = "Error";
@@ -12,13 +15,13 @@ export const ErrorTransformer = {
     canSerialize(value) {
         return value instanceof Error;
     },
-    serialize(value) {
+    serialize(value, options) {
         const result = {
             [SerializationTags.TYPE]: ERROR_TYPE,
             name: value.name,
             message: value.message,
         };
-        if (value.stack !== undefined) {
+        if (options?.includeStack === true && value.stack !== undefined) {
             result.stack = value.stack;
         }
         const code = value.code;
@@ -35,9 +38,17 @@ export const ErrorTransformer = {
         if (typeof name === "string" && name !== "Error") {
             error.name = name;
         }
+        // A stack from the wire is attacker-controlled text. Restoring it over the
+        // real one would make the reconstructed error lie about where it came
+        // from, so it is carried as a separate, clearly-named field instead.
         const stack = data.stack;
         if (typeof stack === "string") {
-            error.stack = stack;
+            Object.defineProperty(error, "originalStack", {
+                value: stack,
+                writable: true,
+                enumerable: false,
+                configurable: true,
+            });
         }
         const code = data.code;
         if (typeof code === "string") {

package/dist/serializerTypes/index.d.ts

@@ -3,5 +3,5 @@
  *
  * Core contracts for serializers, transformers, and serialization options.
  */
-export type { SerializationFormat, SerializedValue, SerializeOptions, DeserializeOptions, SerializationMetadata, SerializedEnvelope, Serializer, AsyncSerializer, TypeTransformer, UndefinedStrategy, } from "./serializer.type.js";
+export type { SerializationFormat, SerializedValue, SerializeOptions, DeserializeOptions, SerializationMetadata, SerializedEnvelope, Serializer, TypeTransformer, } from "./serializer.type.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/serializerTypes/serializer.type.d.ts

@@ -21,6 +21,18 @@ export interface SerializeOptions {
     readonly maxSize?: number;
     /** Indentation for pretty-print (default: 2). */
     readonly indent?: number;
+    /**
+     * Include `Error.stack` when serializing errors (default: false).
+     *
+     * A stack names absolute file paths and internal call structure. Serialized
+     * errors travel to queues, RPC peers and log sinks, so stacks are opt-in.
+     */
+    readonly includeStack?: boolean;
+    /**
+     * Permit `__proto__`, `constructor` and `prototype` as data keys
+     * (default: false). See {@link DeserializeOptions.allowUnsafeKeys}.
+     */
+    readonly allowUnsafeKeys?: boolean;
 }
 /** Options for deserialization operations. */
 export interface DeserializeOptions {
@@ -28,10 +40,24 @@ export interface DeserializeOptions {
     readonly preserveTypes?: boolean;
     /** Maximum object depth before throwing. */
     readonly maxDepth?: number;
-    /** Throw on malformed or unexpected data. */
+    /**
+     * Throw on malformed or unexpected data.
+     *
+     * Also makes an unrecognised `$type` tag an error rather than treating the
+     * object as ordinary data.
+     */
     readonly strict?: boolean;
-    /** Allow prototype-polluting keys during reconstruction. */
+    /**
+     * Allow prototype-polluting keys during reconstruction (default: false).
+     *
+     * With this off — the default — `__proto__`, `constructor` and `prototype`
+     * are dropped from reconstructed objects. Turning it on reinstates them as
+     * real own properties (never as a prototype assignment), which is only safe
+     * when the payload is trusted.
+     */
     readonly allowUnsafeKeys?: boolean;
+    /** Maximum accepted input size in bytes. */
+    readonly maxSize?: number;
 }
 /** Metadata attached to serialized output. */
 export interface SerializationMetadata {
@@ -60,13 +86,6 @@ export interface Serializer<TValue = unknown, TSerialized = SerializedValue> {
     /** Deserialize a value from the target format. */
     deserialize<T = TValue>(value: TSerialized, options?: DeserializeOptions): T;
 }
-/** Asynchronous serializer contract (for streaming / large payloads). */
-export interface AsyncSerializer<TValue = unknown, TSerialized = SerializedValue> {
-    readonly name: string;
-    readonly contentType: string;
-    serialize(value: TValue, options?: SerializeOptions): Promise<TSerialized>;
-    deserialize<T = TValue>(value: TSerialized, options?: DeserializeOptions): Promise<T>;
-}
 /** Transforms a specific JS type during serialization. */
 export interface TypeTransformer<TValue = unknown> {
     /** Tag name used in tagged representations (e.g., "Date"). */
@@ -74,10 +93,8 @@ export interface TypeTransformer<TValue = unknown> {
     /** Returns true when this transformer handles the given value. */
     canSerialize(value: unknown): value is TValue;
     /** Convert the value into a JSON-safe representation. */
-    serialize(value: TValue): unknown;
+    serialize(value: TValue, options?: SerializeOptions): unknown;
     /** Reconstruct the original value from the serialized form. */
-    deserialize(value: unknown): TValue;
+    deserialize(value: unknown, options?: DeserializeOptions): TValue;
 }
-/** Strategy for handling `undefined` values. */
-export type UndefinedStrategy = "omit" | "null" | "preserve";
 //# sourceMappingURL=serializer.type.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/serialization",
-  "version": "0.1.0",
+  "version": "1.0.1",
   "description": "Data translation layer with JSON serializer, type transformers, envelopes, and registry for Zudojs applications.",
   "type": "module",
   "main": "./dist/index.js",
@@ -13,25 +13,26 @@
   },
   "files": [
     "dist",
+    "!dist/**/*.map",
+    "!dist/**/*.tsbuildinfo",
+    "!dist/.tsbuildinfo",
     "LICENSE"
   ],
-  "scripts": {
-    "build": "tsc",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest"
-  },
   "dependencies": {
-    "@zudojs/constants": "0.1.0",
-    "@zudojs/errors": "0.1.0",
-    "@zudojs/types": "0.1.0",
-    "@zudojs/validation": "0.1.0"
+    "@zudojs/constants": "1.0.1",
+    "@zudojs/errors": "1.0.1",
+    "@zudojs/types": "1.0.0",
+    "@zudojs/validation": "1.0.1"
   },
   "devDependencies": {
-    "typescript": "^5.7.0",
+    "typescript": "7.0.2",
     "vitest": "^4.1.11"
   },
   "license": "MIT",
+  "author": {
+    "name": "Oluwayemi Oyinlola",
+    "url": "https://github.com/oyinlola-tech"
+  },
   "keywords": [
     "zudojs",
     "serialization",
@@ -46,8 +47,19 @@
   },
   "module": "./dist/index.js",
   "homepage": "https://github.com/oyinlola-tech/zudo#readme",
+  "bugs": {
+    "url": "https://github.com/oyinlola-tech/zudo/issues"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/oyinlola-tech/zudo"
+    "url": "https://github.com/oyinlola-tech/zudo",
+    "directory": "packages/serialization"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist"
   }
-}
+}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAGH,YAAY,EACV,mBAAmB,EACnB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,EAClB,UAAU,EACV,eAAe,EACf,eAAe,EACf,iBAAiB,GAClB,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAG3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAGjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AACtE,OAAO,EACL,QAAQ,EACR,UAAU,EACV,UAAU,EACV,UAAU,GACX,MAAM,oCAAoC,CAAC;AAG5C,OAAO,EACL,cAAc,EACd,cAAc,EACd,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,+BAA+B,CAAC;AAGvC,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EACL,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,+BAA+B,CAAC"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAgBH,iEAAiE;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,iEAAiE;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEjE,iEAAiE;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AACtE,OAAO,EACL,QAAQ,EACR,UAAU,EACV,UAAU,EACV,UAAU,GACX,MAAM,oCAAoC,CAAC;AAE5C,iEAAiE;AACjE,OAAO,EACL,cAAc,EACd,cAAc,EACd,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,+BAA+B,CAAC;AAEvC,iEAAiE;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EACL,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,+BAA+B,CAAC"}

package/dist/serializerEnvelope/envelope.core.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"envelope.core.d.ts","sourceRoot":"","sources":["../../src/serializerEnvelope/envelope.core.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAElB,eAAe,EAChB,MAAM,6BAA6B,CAAC;AAQrC;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,eAAe,EACrB,MAAM,GAAE,MAAiC,EACzC,OAAO,GAAE;IACP,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACvB,GACL,kBAAkB,CAUpB;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,kBAAkB,EAC5B,cAAc,CAAC,EAAE,MAAM,GACtB,eAAe,CAOjB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,KAAK,EAAE,CAAC,EACR,UAAU,EAAE;IAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAA;CAAE,EAC3C,MAAM,GAAE,MAAiC,GACxC,kBAAkB,CAGpB;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,QAAQ,EAAE,kBAAkB,EAC5B,YAAY,EAAE;IAAE,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC,CAAA;CAAE,EAClD,cAAc,CAAC,EAAE,MAAM,GACtB,CAAC,CAIH"}

package/dist/serializerEnvelope/envelope.core.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"envelope.core.js","sourceRoot":"","sources":["../../src/serializerEnvelope/envelope.core.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAOH,OAAO,EACL,mBAAmB,EACnB,wBAAwB,EACxB,4BAA4B,GAC7B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAE7E;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAC5B,IAAqB,EACrB,SAAiB,mBAAmB,CAAC,IAAI,EACzC,UAII,EAAE;IAEN,OAAO;QACL,QAAQ,EAAE;YACR,MAAM;YACN,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,4BAA4B;YACxD,WAAW,EAAE,OAAO,CAAC,WAAW,IAAI,wBAAwB,CAAC,IAAI;YACjE,QAAQ,EAAE,OAAO,CAAC,QAAQ,IAAI,OAAO;SACtC;QACD,IAAI;KACL,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAC5B,QAA4B,EAC5B,cAAuB;IAEvB,IAAI,cAAc,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,KAAK,cAAc,EAAE,CAAC;QAClE,MAAM,IAAI,KAAK,CACb,uCAAuC,cAAc,WAAW,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAC5F,CAAC;IACJ,CAAC;IACD,OAAO,QAAQ,CAAC,IAAI,CAAC;AACvB,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAAQ,EACR,UAA2C,EAC3C,SAAiB,mBAAmB,CAAC,IAAI;IAEzC,MAAM,IAAI,GAAG,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACzC,OAAO,cAAc,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,uBAAuB,CACrC,QAA4B,EAC5B,YAAkD,EAClD,cAAuB;IAEvB,MAAM,IAAI,GAAG,cAAc,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;IACtD,MAAM,GAAG,GAAG,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IAC/D,OAAO,YAAY,CAAC,WAAW,CAAI,GAAG,CAAC,CAAC;AAC1C,CAAC"}

package/dist/serializerEnvelope/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/serializerEnvelope/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,cAAc,EACd,cAAc,EACd,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,oBAAoB,CAAC"}

package/dist/serializerEnvelope/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/serializerEnvelope/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,cAAc,EACd,cAAc,EACd,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,oBAAoB,CAAC"}

package/dist/serializerJson/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/serializerJson/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/serializerJson/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/serializerJson/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/serializerJson/jsonSerializer.core.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsonSerializer.core.d.ts","sourceRoot":"","sources":["../../src/serializerJson/jsonSerializer.core.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AA+BvE,qBAAa,cAAe,YAAW,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC;IAChE,SAAgB,IAAI,UAAU;IAC9B,SAAgB,WAAW,sBAAsB;IAEjD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAsB;gBAEvC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAA;KAAE;IAIrE,0CAA0C;IAC1C,mBAAmB,CACjB,WAAW,EAAE,OAAO,6BAA6B,EAAE,eAAe,GACjE,IAAI;IAIP,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM;IAsB7D,WAAW,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,CAAC;IAcxE,OAAO,CAAC,cAAc;IA+DtB,OAAO,CAAC,YAAY;IAoCpB,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,gBAAgB;CAWzB"}

package/dist/serializerJson/jsonSerializer.core.js.map

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

package/dist/serializerRegistry/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/serializerRegistry/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EACL,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,iCAAiC,CAAC"}

package/dist/serializerRegistry/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/serializerRegistry/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EACL,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,iCAAiC,CAAC"}

package/dist/serializerRegistry/serializerRegistry.core.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serializerRegistry.core.d.ts","sourceRoot":"","sources":["../../src/serializerRegistry/serializerRegistry.core.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAG9D;;;;;GAKG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAiC;IAE7D,sFAAsF;IACtF,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAItC,uCAAuC;IACvC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIjC,kFAAkF;IAClF,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAM7B,iEAAiE;IACjE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B,+CAA+C;IAC/C,KAAK,IAAI,MAAM,EAAE;IAIjB,yCAAyC;IACzC,KAAK,IAAI,IAAI;IAIb,wCAAwC;IACxC,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/dist/serializerRegistry/serializerRegistry.core.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"serializerRegistry.core.js","sourceRoot":"","sources":["../../src/serializerRegistry/serializerRegistry.core.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAEzD;;;;;GAKG;AACH,MAAM,OAAO,kBAAkB;IACZ,WAAW,GAAG,IAAI,GAAG,EAAsB,CAAC;IAE7D,sFAAsF;IACtF,QAAQ,CAAC,UAAsB;QAC7B,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IACpD,CAAC;IAED,uCAAuC;IACvC,UAAU,CAAC,IAAY;QACrB,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACvC,CAAC;IAED,kFAAkF;IAClF,GAAG,CAAC,IAAY;QACd,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC9C,IAAI,CAAC,UAAU;YAAE,MAAM,IAAI,uBAAuB,CAAC,IAAI,CAAC,CAAC;QACzD,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,iEAAiE;IACjE,GAAG,CAAC,IAAY;QACd,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC;IAED,+CAA+C;IAC/C,KAAK;QACH,OAAO,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC;IACtC,CAAC;IAED,yCAAyC;IACzC,KAAK;QACH,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;IAC3B,CAAC;IAED,wCAAwC;IACxC,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;IAC/B,CAAC;CACF"}

package/dist/serializerRegistry/serializerRegistry.factory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serializerRegistry.factory.d.ts","sourceRoot":"","sources":["../../src/serializerRegistry/serializerRegistry.factory.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,mBAAmB,EACpB,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAElE;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,mBAAmB,EAC3B,OAAO,CAAC,EAAE;IACR,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAC;IAC5C,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC,GACA,UAAU,CAOZ;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI,kBAAkB,CAI1D"}

package/dist/serializerRegistry/serializerRegistry.factory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"serializerRegistry.factory.js","sourceRoot":"","sources":["../../src/serializerRegistry/serializerRegistry.factory.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,mCAAmC,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,EAAE,mBAAmB,IAAI,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAElE;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAC9B,MAA2B,EAC3B,OAIC;IAED,QAAQ,MAAM,EAAE,CAAC;QACf,KAAK,MAAM,CAAC,IAAI;YACd,OAAO,IAAI,cAAc,CAAC,EAAE,YAAY,EAAE,OAAO,EAAE,YAAY,EAAE,CAAC,CAAC;QACrE;YACE,MAAM,IAAI,mCAAmC,CAAC,MAAM,CAAC,CAAC;IAC1D,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,qBAAqB;IACnC,MAAM,QAAQ,GAAG,IAAI,kBAAkB,EAAE,CAAC;IAC1C,QAAQ,CAAC,QAAQ,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IACjD,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/serializerTransforms/bigint.transformer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bigint.transformer.d.ts","sourceRoot":"","sources":["../../src/serializerTransforms/bigint.transformer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAKnE,mDAAmD;AACnD,eAAO,MAAM,iBAAiB,EAAE,eAAe,CAAC,MAAM,CA4BrD,CAAC"}

package/dist/serializerTransforms/bigint.transformer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bigint.transformer.js","sourceRoot":"","sources":["../../src/serializerTransforms/bigint.transformer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,MAAM,WAAW,GAAG,QAAiB,CAAC;AAEtC,mDAAmD;AACnD,MAAM,CAAC,MAAM,iBAAiB,GAA4B;IACxD,IAAI,EAAE,WAAW;IAEjB,YAAY,CAAC,KAAc;QACzB,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC;IACnC,CAAC;IAED,SAAS,CAAC,KAAa;QACrB,OAAO;YACL,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;YACrC,CAAC,iBAAiB,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,QAAQ,EAAE;SAC5C,CAAC;IACJ,CAAC;IAED,WAAW,CAAC,KAAc;QACxB,MAAM,IAAI,GAAG,KAAgC,CAAC;QAC9C,MAAM,GAAG,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;QAC1C,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CACb,yDAAyD,OAAO,GAAG,EAAE,CACtE,CAAC;QACJ,CAAC;QACD,IAAI,CAAC;YACH,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;QACrB,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,IAAI,KAAK,CAAC,8BAA8B,GAAG,GAAG,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;CACF,CAAC"}

package/dist/serializerTransforms/date.transformer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"date.transformer.d.ts","sourceRoot":"","sources":["../../src/serializerTransforms/date.transformer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAKnE,iDAAiD;AACjD,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,IAAI,CA4BjD,CAAC"}

package/dist/serializerTransforms/date.transformer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"date.transformer.js","sourceRoot":"","sources":["../../src/serializerTransforms/date.transformer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,MAAM,SAAS,GAAG,MAAe,CAAC;AAElC,iDAAiD;AACjD,MAAM,CAAC,MAAM,eAAe,GAA0B;IACpD,IAAI,EAAE,SAAS;IAEf,YAAY,CAAC,KAAc;QACzB,OAAO,KAAK,YAAY,IAAI,CAAC;IAC/B,CAAC;IAED,SAAS,CAAC,KAAW;QACnB,OAAO;YACL,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,SAAS;YACnC,CAAC,iBAAiB,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,WAAW,EAAE;SAC/C,CAAC;IACJ,CAAC;IAED,WAAW,CAAC,KAAc;QACxB,MAAM,IAAI,GAAG,KAAgC,CAAC;QAC9C,MAAM,GAAG,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;QAC1C,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CACb,uDAAuD,OAAO,GAAG,EAAE,CACpE,CAAC;QACJ,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC;QAC3B,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CAAC,wBAAwB,GAAG,GAAG,CAAC,CAAC;QAClD,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;CACF,CAAC"}

package/dist/serializerTransforms/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/serializerTransforms/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/serializerTransforms/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/serializerTransforms/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/serializerTransforms/map.transformer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"map.transformer.d.ts","sourceRoot":"","sources":["../../src/serializerTransforms/map.transformer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAKnE,gDAAgD;AAChD,eAAO,MAAM,cAAc,EAAE,eAAe,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CA4BjE,CAAC"}

package/dist/serializerTransforms/map.transformer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"map.transformer.js","sourceRoot":"","sources":["../../src/serializerTransforms/map.transformer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,MAAM,QAAQ,GAAG,KAAc,CAAC;AAEhC,gDAAgD;AAChD,MAAM,CAAC,MAAM,cAAc,GAA2C;IACpE,IAAI,EAAE,QAAQ;IAEd,YAAY,CAAC,KAAc;QACzB,OAAO,KAAK,YAAY,GAAG,CAAC;IAC9B,CAAC;IAED,SAAS,CAAC,KAA4B;QACpC,MAAM,OAAO,GAA8B,EAAE,CAAC;QAC9C,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC;YAC3B,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACvB,CAAC;QACD,OAAO;YACL,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,QAAQ;YAClC,CAAC,iBAAiB,CAAC,KAAK,CAAC,EAAE,OAAO;SACnC,CAAC;IACJ,CAAC;IAED,WAAW,CAAC,KAAc;QACxB,MAAM,IAAI,GAAG,KAAgC,CAAC;QAC9C,MAAM,GAAG,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;QAC1C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CACb,qDAAqD,OAAO,GAAG,EAAE,CAClE,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,GAAG,CAAC,GAAgC,CAAC,CAAC;IACnD,CAAC;CACF,CAAC"}

package/dist/serializerTransforms/set.transformer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"set.transformer.d.ts","sourceRoot":"","sources":["../../src/serializerTransforms/set.transformer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAKnE,gDAAgD;AAChD,eAAO,MAAM,cAAc,EAAE,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,CAwBxD,CAAC"}

package/dist/serializerTransforms/set.transformer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"set.transformer.js","sourceRoot":"","sources":["../../src/serializerTransforms/set.transformer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,MAAM,QAAQ,GAAG,KAAc,CAAC;AAEhC,gDAAgD;AAChD,MAAM,CAAC,MAAM,cAAc,GAAkC;IAC3D,IAAI,EAAE,QAAQ;IAEd,YAAY,CAAC,KAAc;QACzB,OAAO,KAAK,YAAY,GAAG,CAAC;IAC9B,CAAC;IAED,SAAS,CAAC,KAAmB;QAC3B,OAAO;YACL,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,QAAQ;YAClC,CAAC,iBAAiB,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC;SACtC,CAAC;IACJ,CAAC;IAED,WAAW,CAAC,KAAc;QACxB,MAAM,IAAI,GAAG,KAAgC,CAAC;QAC9C,MAAM,GAAG,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;QAC1C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CACb,qDAAqD,OAAO,GAAG,EAAE,CAClE,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;IACtB,CAAC;CACF,CAAC"}

package/dist/serializerTransforms/transformerRegistry.core.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transformerRegistry.core.d.ts","sourceRoot":"","sources":["../../src/serializerTransforms/transformerRegistry.core.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAInE;;;;;GAKG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAsC;IAEnE,8DAA8D;IAC9D,QAAQ,CAAC,WAAW,EAAE,eAAe,GAAG,IAAI;IAS5C,4CAA4C;IAC5C,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIjC,0CAA0C;IAC1C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe;IAMlC,6DAA6D;IAC7D,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,GAAG,SAAS;IAOzD,sEAAsE;IACtE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B,wCAAwC;IACxC,KAAK,IAAI,MAAM,EAAE;IAIjB,0CAA0C;IAC1C,KAAK,IAAI,IAAI;IAIb,yCAAyC;IACzC,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/dist/serializerTransforms/transformerRegistry.core.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"transformerRegistry.core.js","sourceRoot":"","sources":["../../src/serializerTransforms/transformerRegistry.core.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD;;;;;GAKG;AACH,MAAM,OAAO,mBAAmB;IACb,YAAY,GAAG,IAAI,GAAG,EAA2B,CAAC;IAEnE,8DAA8D;IAC9D,QAAQ,CAAC,WAA4B;QACnC,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,IAAI,mBAAmB,CAAC,gBAAgB,EAAE,CAAC;YACnE,MAAM,IAAI,KAAK,CACb,8BAA8B,mBAAmB,CAAC,gBAAgB,YAAY,CAC/E,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;IACvD,CAAC;IAED,4CAA4C;IAC5C,UAAU,CAAC,IAAY;QACrB,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC;IAED,0CAA0C;IAC1C,GAAG,CAAC,IAAY;QACd,MAAM,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAChD,IAAI,CAAC,WAAW;YAAE,MAAM,IAAI,wBAAwB,CAAC,IAAI,CAAC,CAAC;QAC3D,OAAO,WAAW,CAAC;IACrB,CAAC;IAED,6DAA6D;IAC7D,YAAY,CAAC,KAAc;QACzB,KAAK,MAAM,WAAW,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,EAAE,CAAC;YACrD,IAAI,WAAW,CAAC,YAAY,CAAC,KAAK,CAAC;gBAAE,OAAO,WAAW,CAAC;QAC1D,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,sEAAsE;IACtE,GAAG,CAAC,IAAY;QACd,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACrC,CAAC;IAED,wCAAwC;IACxC,KAAK;QACH,OAAO,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC;IACvC,CAAC;IAED,0CAA0C;IAC1C,KAAK;QACH,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;IAC5B,CAAC;IAED,yCAAyC;IACzC,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC;IAChC,CAAC;CACF"}

package/dist/serializerTransformsExt/buffer.transformer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"buffer.transformer.d.ts","sourceRoot":"","sources":["../../src/serializerTransformsExt/buffer.transformer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAMnE,uDAAuD;AACvD,eAAO,MAAM,iBAAiB,EAAE,eAAe,CAAC,UAAU,CAyBzD,CAAC"}

package/dist/serializerTransformsExt/buffer.transformer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"buffer.transformer.js","sourceRoot":"","sources":["../../src/serializerTransformsExt/buffer.transformer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE3D,MAAM,WAAW,GAAG,QAAiB,CAAC;AAEtC,uDAAuD;AACvD,MAAM,CAAC,MAAM,iBAAiB,GAAgC;IAC5D,IAAI,EAAE,WAAW;IAEjB,YAAY,CAAC,KAAc;QACzB,OAAO,KAAK,YAAY,UAAU,CAAC;IACrC,CAAC;IAED,SAAS,CAAC,KAAiB;QACzB,OAAO;YACL,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;YACrC,CAAC,iBAAiB,CAAC,QAAQ,CAAC,EAAE,QAAQ;YACtC,CAAC,iBAAiB,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;SAC3C,CAAC;IACJ,CAAC;IAED,WAAW,CAAC,KAAc;QACxB,MAAM,IAAI,GAAG,KAAgC,CAAC;QAC9C,MAAM,GAAG,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;QAC1C,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CACb,yDAAyD,OAAO,GAAG,EAAE,CACtE,CAAC;QACJ,CAAC;QACD,OAAO,UAAU,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;CACF,CAAC"}

package/dist/serializerTransformsExt/encoding.utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"encoding.utils.d.ts","sourceRoot":"","sources":["../../src/serializerTransformsExt/encoding.utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,8CAA8C;AAC9C,wBAAgB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CASjD;AAED,gDAAgD;AAChD,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAUrD;AAED,mDAAmD;AACnD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAKnD;AAED,mDAAmD;AACnD,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAKnD"}

package/dist/serializerTransformsExt/encoding.utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"encoding.utils.js","sourceRoot":"","sources":["../../src/serializerTransformsExt/encoding.utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,8CAA8C;AAC9C,MAAM,UAAU,QAAQ,CAAC,IAAgB;IACvC,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;QAClC,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAC9C,CAAC;IACD,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,MAAM,IAAI,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAE,CAAC,CAAC;IAC1C,CAAC;IACD,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC;AACtB,CAAC;AAED,gDAAgD;AAChD,MAAM,UAAU,UAAU,CAAC,MAAc;IACvC,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;QAClC,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;IACvD,CAAC;IACD,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IAC5B,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC5C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACvC,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IAClC,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,mDAAmD;AACnD,MAAM,UAAU,UAAU,CAAC,IAAY;IACrC,IAAI,OAAO,WAAW,KAAK,WAAW,EAAE,CAAC;QACvC,OAAO,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC;IACD,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;AACpD,CAAC;AAED,mDAAmD;AACnD,MAAM,UAAU,UAAU,CAAC,IAAgB;IACzC,IAAI,OAAO,WAAW,KAAK,WAAW,EAAE,CAAC;QACvC,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;IACD,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;AAC7C,CAAC"}

package/dist/serializerTransformsExt/error.transformer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"error.transformer.d.ts","sourceRoot":"","sources":["../../src/serializerTransformsExt/error.transformer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAKnE,kDAAkD;AAClD,eAAO,MAAM,gBAAgB,EAAE,eAAe,CAAC,KAAK,CAgDnD,CAAC"}

package/dist/serializerTransformsExt/error.transformer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"error.transformer.js","sourceRoot":"","sources":["../../src/serializerTransformsExt/error.transformer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,MAAM,UAAU,GAAG,OAAgB,CAAC;AAEpC,kDAAkD;AAClD,MAAM,CAAC,MAAM,gBAAgB,GAA2B;IACtD,IAAI,EAAE,UAAU;IAEhB,YAAY,CAAC,KAAc;QACzB,OAAO,KAAK,YAAY,KAAK,CAAC;IAChC,CAAC;IAED,SAAS,CAAC,KAAY;QACpB,MAAM,MAAM,GAA4B;YACtC,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,UAAU;YACpC,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,OAAO,EAAE,KAAK,CAAC,OAAO;SACvB,CAAC;QAEF,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YAC9B,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;QAC7B,CAAC;QAED,MAAM,IAAI,GAAI,KAA4C,CAAC,IAAI,CAAC;QAChE,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC7B,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC;QACrB,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,WAAW,CAAC,KAAc;QACxB,MAAM,IAAI,GAAG,KAAgC,CAAC;QAC9C,MAAM,OAAO,GAAG,OAAO,IAAI,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;QACrE,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;QAEjC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACvB,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;YACjD,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC;QACpB,CAAC;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC;QACtB,CAAC;QAED,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACvB,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC5B,KAA4C,CAAC,IAAI,GAAG,IAAI,CAAC;QAC5D,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;CACF,CAAC"}

package/dist/serializerTransformsExt/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/serializerTransformsExt/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EACL,QAAQ,EACR,UAAU,EACV,UAAU,EACV,UAAU,GACX,MAAM,qBAAqB,CAAC"}

package/dist/serializerTransformsExt/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/serializerTransformsExt/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EACL,QAAQ,EACR,UAAU,EACV,UAAU,EACV,UAAU,GACX,MAAM,qBAAqB,CAAC"}

package/dist/serializerTypes/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/serializerTypes/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EACV,mBAAmB,EACnB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,EAClB,UAAU,EACV,eAAe,EACf,eAAe,EACf,iBAAiB,GAClB,MAAM,sBAAsB,CAAC"}

package/dist/serializerTypes/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/serializerTypes/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/serializerTypes/serializer.type.d.ts.map

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

package/dist/serializerTypes/serializer.type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"serializer.type.js","sourceRoot":"","sources":["../../src/serializerTypes/serializer.type.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}