seriall 1.0.0

package/LICENSE

@@ -0,0 +1,9 @@
+
+
+Copyright 2026 Loïc Duvail
+
+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

@@ -0,0 +1,2 @@
+# Seriall 
+A general purpose js serializer, which preserves referential integrity (circular objects...), special values (Infintiy, NaN, undefined...), as well as native and custom classes instances.

package/dist/index.cjs

@@ -0,0 +1,437 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SYMBOLS: () => SYMBOLS,
+  SerializableClass: () => SerializableClass,
+  Serializer: () => Serializer,
+  Transformer: () => Transformer
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/const/const.ts
+var SIGNATURE_KEY = "$";
+var DATA_KEY = "d";
+var NO_TRANSFORM_DATA = void 0;
+var PRIORITY = {
+  CUSTOM_CLASS: 0,
+  NATIVE_CLASS: 1,
+  PRIMITIVE: 2,
+  custom: (priority) => (priority <= 0 ? 1 : priority) + PRIORITY.CUSTOM_CLASS
+};
+
+// src/utils/number.utils.ts
+var isSpecialNumber = (value) => {
+  return [Infinity, -Infinity, NaN].includes(value) || Object.is(value, -0);
+};
+var encodeSpecialNumber = (value) => {
+  if (Number.isNaN(value)) return 0;
+  if (value === Infinity) return 1;
+  if (value === -Infinity) return 2;
+  if (Object.is(value, -0)) return 3;
+  throw new Error(value + " is not a special number");
+};
+var decodeSpecialNumber = (value) => {
+  switch (value) {
+    case 0:
+      return NaN;
+    case 1:
+      return Infinity;
+    case 2:
+      return -Infinity;
+    case 3:
+      return -0;
+    default:
+      throw new Error(value + " is not a special number");
+  }
+};
+
+// src/utils/json.utils.ts
+var isJsonPrimitive = (value) => {
+  if (typeof value === "number") {
+    return !isSpecialNumber(value);
+  }
+  return typeof value === "string" || typeof value === "boolean";
+};
+
+// src/utils/object.utils.ts
+var isPlainObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+var deepMerge = (...objects) => {
+  const result = {};
+  for (const obj of objects) {
+    if (!isPlainObject(obj)) continue;
+    for (const [key, value] of Object.entries(obj)) {
+      if (Array.isArray(value)) {
+        result[key] = structuredClone(value);
+      } else if (isPlainObject(value)) {
+        const existing = result[key];
+        result[key] = deepMerge(isPlainObject(existing) ? existing : {}, value);
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+};
+
+// src/serialization/serialize.ts
+var serialize = (data, transformers) => {
+  const graph = [];
+  const seen = /* @__PURE__ */ new Map();
+  const addNodeToGraph = (node) => {
+    if (isJsonPrimitive(node)) {
+      const id2 = graph.length;
+      graph.push(node);
+      return id2;
+    }
+    let id = seen.get(node);
+    if (id !== void 0) {
+      return id;
+    }
+    id = graph.length;
+    seen.set(node, id);
+    const transformer = transformers.find(
+      (transformer2) => transformer2.match(node)
+    );
+    if (transformer) {
+      graph.push({ $: transformer.id });
+      const revivable = graph[id];
+      const encoded = transformer.encode(node);
+      if (encoded !== NO_TRANSFORM_DATA) {
+        const dataId = addNodeToGraph(encoded);
+        revivable.d = dataId;
+      }
+      return id;
+    }
+    if (Array.isArray(node)) {
+      graph.push([]);
+      const arr = graph[id];
+      for (const element of node) {
+        const elementId = addNodeToGraph(element);
+        arr.push(elementId);
+      }
+      return id;
+    }
+    throw new Error(
+      `No transformer found for the current value "${node?.toString()}", please add one`
+    );
+  };
+  addNodeToGraph(data);
+  return JSON.stringify(graph);
+};
+
+// src/serialization/deserialize.ts
+var deserialize = (data, transformers) => {
+  const graph = JSON.parse(data);
+  const revived = /* @__PURE__ */ new Map();
+  const reviveNode = (index) => {
+    if (revived.has(index)) {
+      return revived.get(index);
+    }
+    if (graph.length <= index || index < 0) {
+      throw new Error(`Invalid serialized graph reference: ${index}`);
+    }
+    const node = graph[index];
+    if (isJsonPrimitive(node)) {
+      return node;
+    }
+    if (Array.isArray(node)) {
+      const arr = [];
+      revived.set(index, arr);
+      for (const element of node) {
+        arr.push(reviveNode(element));
+      }
+      return arr;
+    }
+    const transformerId = node[SIGNATURE_KEY];
+    const transformer = transformers.get(transformerId);
+    if (!transformerId) {
+      throw new Error(`No transformer found for node "${node}"`);
+    }
+    if (transformer === void 0) {
+      throw new Error(`No transformer found with id "${transformerId}"`);
+    }
+    const nonRecursiveTransformer = transformer;
+    const dataId = node[DATA_KEY];
+    if (dataId === void 0) {
+      const decoded = nonRecursiveTransformer.decode(NO_TRANSFORM_DATA);
+      revived.set(index, decoded);
+      return decoded;
+    }
+    if (!transformer.recursive) {
+      const decoded = nonRecursiveTransformer.decode(reviveNode(dataId));
+      revived.set(index, decoded);
+      return decoded;
+    }
+    const registerNode = (node2) => {
+      revived.set(index, node2);
+      return reviveNode(dataId);
+    };
+    return transformer.decode(registerNode);
+  };
+  return reviveNode(0);
+};
+
+// src/transformer/Transformer.ts
+var Transformer = class {
+  id;
+  recursive;
+  match;
+  encode;
+  decode;
+  priority;
+  static PRIORITY = PRIORITY;
+  constructor({
+    id,
+    match,
+    encode,
+    decode,
+    priority,
+    recursive
+  }) {
+    this.id = id;
+    this.recursive = recursive;
+    this.match = match;
+    this.encode = encode;
+    this.decode = decode;
+    this.priority = priority || PRIORITY.CUSTOM_CLASS;
+  }
+};
+
+// src/transformer/builtin.transformers.ts
+var primitivesTransformers = [
+  new Transformer({
+    id: "sym",
+    priority: Transformer.PRIORITY.PRIMITIVE,
+    match: (node) => typeof node === "symbol",
+    encode: (node) => ({
+      d: node.description,
+      f: Symbol.keyFor(node) === void 0 ? 0 : 1
+    }),
+    decode: (encoded) => {
+      if (encoded.f === 1 && encoded.d) {
+        return Symbol.for(encoded.d);
+      }
+      return Symbol(encoded.d);
+    }
+  }),
+  new Transformer({
+    id: "spe",
+    priority: Transformer.PRIORITY.PRIMITIVE,
+    match: isSpecialNumber,
+    encode: encodeSpecialNumber,
+    decode: decodeSpecialNumber
+  }),
+  new Transformer({
+    id: "udf",
+    priority: Transformer.PRIORITY.PRIMITIVE,
+    match: (node) => node === void 0,
+    encode: () => NO_TRANSFORM_DATA,
+    decode: () => void 0
+  }),
+  new Transformer({
+    id: "nul",
+    priority: Transformer.PRIORITY.PRIMITIVE,
+    match: (node) => node === null,
+    encode: () => NO_TRANSFORM_DATA,
+    decode: () => null
+  }),
+  new Transformer({
+    id: "big",
+    priority: Transformer.PRIORITY.PRIMITIVE,
+    match: (node) => typeof node === "bigint",
+    encode: (node) => node.toString(),
+    decode: (node) => BigInt(node)
+  }),
+  new Transformer({
+    id: "obj",
+    priority: Transformer.PRIORITY.PRIMITIVE,
+    recursive: true,
+    match: (node) => !Array.isArray(node) && typeof node === "object",
+    encode: (node) => {
+      const obj = [];
+      for (const key of Reflect.ownKeys(node)) {
+        obj.push([key, node[key]]);
+      }
+      return obj;
+    },
+    decode: (registerNode) => {
+      const obj = {};
+      const encoded = registerNode(obj);
+      for (const [key, value] of encoded) {
+        obj[key] = value;
+      }
+      return obj;
+    }
+  })
+];
+var nativeClassesTransformers = [
+  new Transformer({
+    id: "Dte",
+    priority: Transformer.PRIORITY.NATIVE_CLASS,
+    match: (node) => node instanceof Date,
+    encode: (node) => node.getTime(),
+    decode: (node) => new Date(node)
+  }),
+  new Transformer({
+    id: "Set",
+    priority: Transformer.PRIORITY.NATIVE_CLASS,
+    recursive: true,
+    match: (node) => node instanceof Set,
+    encode: (node) => Array.from(node),
+    decode: (registerNode) => {
+      const set = /* @__PURE__ */ new Set();
+      const encoded = registerNode(set);
+      for (const element of encoded) {
+        set.add(element);
+      }
+      return set;
+    }
+  }),
+  new Transformer({
+    id: "Map",
+    priority: Transformer.PRIORITY.NATIVE_CLASS,
+    recursive: true,
+    match: (node) => node instanceof Map,
+    encode: (node) => Array.from(node),
+    decode: (registerNode) => {
+      const map = /* @__PURE__ */ new Map();
+      const encoded = registerNode(map);
+      for (const [key, value] of encoded) {
+        map.set(key, value);
+      }
+      return map;
+    }
+  }),
+  new Transformer({
+    id: "Rgx",
+    priority: Transformer.PRIORITY.NATIVE_CLASS,
+    match: (node) => node instanceof RegExp,
+    encode: (node) => ({ s: node.source, f: node.flags }),
+    decode: (node) => new RegExp(node.s, node.f)
+  }),
+  new Transformer({
+    id: "Str",
+    priority: Transformer.PRIORITY.NATIVE_CLASS,
+    match: (node) => node instanceof String,
+    encode: (node) => node.valueOf(),
+    decode: (node) => new String(node)
+  }),
+  new Transformer({
+    id: "Num",
+    priority: Transformer.PRIORITY.NATIVE_CLASS,
+    match: (node) => node instanceof Number,
+    encode: (node) => node.valueOf(),
+    decode: (node) => new Number(node)
+  }),
+  new Transformer({
+    id: "Bol",
+    priority: Transformer.PRIORITY.NATIVE_CLASS,
+    match: (node) => node instanceof Boolean,
+    encode: (node) => node.valueOf(),
+    decode: (node) => new Boolean(node)
+  })
+];
+
+// src/transformer/builtin.classTransformer.ts
+var ENCODE = /* @__PURE__ */ Symbol("encode");
+var DECODE = /* @__PURE__ */ Symbol("decode");
+var SYMBOLS = { ENCODE, DECODE };
+var SerializableClass = class {
+  constructor(..._) {
+  }
+  [ENCODE] = () => {
+    const encoded = {};
+    for (const key of Reflect.ownKeys(this)) {
+      const value = this[key];
+      if (typeof value !== "function") {
+        encoded[key] = this[key];
+      }
+    }
+    return encoded;
+  };
+  static [DECODE] = function(registerNode) {
+    let revivedInstance = {};
+    const args = registerNode(revivedInstance);
+    Object.assign(revivedInstance, args);
+    Object.setPrototypeOf(revivedInstance, this.prototype);
+    return revivedInstance;
+  };
+};
+var createClassTransformer = (id, clazz) => new Transformer({
+  id,
+  priority: Transformer.PRIORITY.CUSTOM_CLASS,
+  recursive: true,
+  match: (node) => node instanceof clazz,
+  encode: (node) => node[ENCODE](),
+  decode: (registerNode) => clazz[DECODE](registerNode)
+});
+
+// src/serialization/Serializer.ts
+var defaultOptions = {
+  enable: {
+    builtinPrimitiveTransformers: true,
+    builtinNativeClasses: true,
+    builtinClassTransformer: true
+  }
+};
+var Serializer = class {
+  transformers = [];
+  transformersMap = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    const opt = deepMerge(defaultOptions, options);
+    if (opt.enable.builtinPrimitiveTransformers)
+      primitivesTransformers.forEach(this.registerTransformer);
+    if (opt.enable.builtinNativeClasses)
+      nativeClassesTransformers.forEach(this.registerTransformer);
+  }
+  serialize = (data) => serialize(data, this.transformers);
+  deserialize = (data) => deserialize(data, this.transformersMap);
+  registerTransformer = (transformer) => {
+    if (this.transformersMap.has(transformer.id)) {
+      throw new Error(
+        `A transformer with id "${transformer.id}" is already registered, chose another one`
+      );
+    }
+    this.transformers.push(transformer);
+    this.transformers = this.transformers.sort(
+      (a, b) => (a.priority ?? Infinity) - (b.priority ?? Infinity)
+    );
+    this.transformersMap.set(transformer.id, transformer);
+  };
+  deregisterTransformer = (transformer) => {
+    const id = typeof transformer === "object" ? transformer.id : transformer;
+    if (!this.transformersMap.has(id)) {
+      throw new Error(
+        `No transformer found for id "${id}", cannot deregister it`
+      );
+    }
+    this.transformers = this.transformers.filter(
+      (transformer2) => transformer2.id !== id
+    );
+    this.transformersMap.delete(id);
+  };
+  registerClass = (name, clazz) => {
+    this.registerTransformer(createClassTransformer("$" + name, clazz));
+  };
+  deregisterClass = (name) => {
+    this.deregisterTransformer("$" + name);
+  };
+};

package/dist/index.d.cts

@@ -0,0 +1,117 @@
+declare namespace Seriall {
+  export type Serializable =
+    | JsonPrimitive
+    | symbol
+    | bigint
+    | undefined
+    | null
+    | object
+    | Serializable[];
+
+  export type JsonPrimitive = string | number | boolean;
+
+  export namespace Serialized {
+    export type RevivableNode = { $: Transformer.Id; d?: number };
+    export type Node = JsonPrimitive | number[] | RevivableNode;
+    export type Graph = Node[];
+  }
+
+  namespace Transformer {
+    /** `NoData` is used to signify that no value should be passed to the Revivable node,
+     * which is then only described by its tag ($)*/
+    type NoData = undefined;
+
+    type Encoded<Recursive extends boolean> = Recursive extends false
+      ? JsonPrimitive | object | Encoded<false>[] | NoData
+      : (JsonPrimitive | Encoded<true>)[] | object;
+
+    type Id = string | number;
+
+    type Matcher<T extends Serializable> = (node: T) => boolean;
+
+    type Encoder<
+      T extends Serializable,
+      O extends Encoded<Recursive>,
+      Recursive extends boolean,
+    > = (node: T) => O;
+
+    type Decoder<
+      T extends Encoded<Recursive>,
+      O extends Serializable,
+      Recursive extends boolean,
+    > = Recursive extends false
+      ? (node: T) => O
+      : (registerNode: (emptyNode: O) => T) => O;
+  }
+
+  export type Transformer<
+    Recursive extends boolean = boolean,
+    Decoded extends Serializable = Serializable,
+    Encoded extends Transformer.Encoded<Recursive> =
+      Transformer.Encoded<Recursive>,
+  > = {
+    id: Transformer.Id;
+    priority?: number;
+    recursive?: Recursive | undefined;
+    match: Transformer.Matcher<Decoded>;
+    encode: Transformer.Encoder<Decoded, Encoded, Recursive>;
+    decode: Transformer.Decoder<Encoded, Decoded, Recursive>;
+  };
+}
+
+type DeepOptional<T> = {
+  [K in keyof T]?: T[K] extends object ? DeepOptional<T[K]> : T[K];
+};
+
+declare class Transformer<Decoded extends Seriall.Serializable, Encoded extends Seriall.Transformer.Encoded<Options["recursive"]>, Options extends {
+    recursive: boolean;
+} = {
+    recursive: false;
+}> implements Seriall.Transformer<Options["recursive"], Decoded, Encoded> {
+    id: Seriall.Transformer.Id;
+    recursive?: Options["recursive"] | undefined;
+    match: Seriall.Transformer.Matcher<Seriall.Serializable>;
+    encode: Seriall.Transformer.Encoder<Decoded, Encoded, Options["recursive"]>;
+    decode: Seriall.Transformer.Decoder<Encoded, Decoded, Options["recursive"]>;
+    priority: number;
+    static PRIORITY: {
+        readonly CUSTOM_CLASS: 0;
+        readonly NATIVE_CLASS: 1;
+        readonly PRIMITIVE: 2;
+        readonly custom: (priority: number) => number;
+    };
+    constructor({ id, match, encode, decode, priority, recursive, }: Seriall.Transformer<Options["recursive"], Decoded, Encoded>);
+}
+
+declare const ENCODE: unique symbol;
+declare const DECODE: unique symbol;
+declare const SYMBOLS: {
+    ENCODE: symbol;
+    DECODE: symbol;
+};
+declare abstract class SerializableClass {
+    constructor(..._: any);
+    [ENCODE]: () => {};
+    static [DECODE]: <T extends typeof SerializableClass>(this: T, registerNode: Parameters<Seriall.Transformer.Decoder<any, any, true>>[0]) => InstanceType<T>;
+}
+
+type SerializerOptions = {
+    enable: {
+        builtinPrimitiveTransformers: boolean;
+        builtinNativeClasses: boolean;
+        builtinClassTransformer: boolean;
+    };
+};
+declare class Serializer {
+    private transformers;
+    private transformersMap;
+    constructor(options?: DeepOptional<SerializerOptions>);
+    serialize: (data: Seriall.Serializable) => string;
+    deserialize: (data: string) => any;
+    registerTransformer: (transformer: Seriall.Transformer) => void;
+    deregisterTransformer: (transformer: Seriall.Transformer | Seriall.Transformer.Id) => void;
+    registerClass: (name: string, clazz: typeof SerializableClass) => void;
+    deregisterClass: (name: string) => void;
+}
+
+export { SYMBOLS, SerializableClass, Serializer, Seriall, Transformer };

package/dist/index.d.mts

@@ -0,0 +1,117 @@
+declare namespace Seriall {
+  export type Serializable =
+    | JsonPrimitive
+    | symbol
+    | bigint
+    | undefined
+    | null
+    | object
+    | Serializable[];
+
+  export type JsonPrimitive = string | number | boolean;
+
+  export namespace Serialized {
+    export type RevivableNode = { $: Transformer.Id; d?: number };
+    export type Node = JsonPrimitive | number[] | RevivableNode;
+    export type Graph = Node[];
+  }
+
+  namespace Transformer {
+    /** `NoData` is used to signify that no value should be passed to the Revivable node,
+     * which is then only described by its tag ($)*/
+    type NoData = undefined;
+
+    type Encoded<Recursive extends boolean> = Recursive extends false
+      ? JsonPrimitive | object | Encoded<false>[] | NoData
+      : (JsonPrimitive | Encoded<true>)[] | object;
+
+    type Id = string | number;
+
+    type Matcher<T extends Serializable> = (node: T) => boolean;
+
+    type Encoder<
+      T extends Serializable,
+      O extends Encoded<Recursive>,
+      Recursive extends boolean,
+    > = (node: T) => O;
+
+    type Decoder<
+      T extends Encoded<Recursive>,
+      O extends Serializable,
+      Recursive extends boolean,
+    > = Recursive extends false
+      ? (node: T) => O
+      : (registerNode: (emptyNode: O) => T) => O;
+  }
+
+  export type Transformer<
+    Recursive extends boolean = boolean,
+    Decoded extends Serializable = Serializable,
+    Encoded extends Transformer.Encoded<Recursive> =
+      Transformer.Encoded<Recursive>,
+  > = {
+    id: Transformer.Id;
+    priority?: number;
+    recursive?: Recursive | undefined;
+    match: Transformer.Matcher<Decoded>;
+    encode: Transformer.Encoder<Decoded, Encoded, Recursive>;
+    decode: Transformer.Decoder<Encoded, Decoded, Recursive>;
+  };
+}
+
+type DeepOptional<T> = {
+  [K in keyof T]?: T[K] extends object ? DeepOptional<T[K]> : T[K];
+};
+
+declare class Transformer<Decoded extends Seriall.Serializable, Encoded extends Seriall.Transformer.Encoded<Options["recursive"]>, Options extends {
+    recursive: boolean;
+} = {
+    recursive: false;
+}> implements Seriall.Transformer<Options["recursive"], Decoded, Encoded> {
+    id: Seriall.Transformer.Id;
+    recursive?: Options["recursive"] | undefined;
+    match: Seriall.Transformer.Matcher<Seriall.Serializable>;
+    encode: Seriall.Transformer.Encoder<Decoded, Encoded, Options["recursive"]>;
+    decode: Seriall.Transformer.Decoder<Encoded, Decoded, Options["recursive"]>;
+    priority: number;
+    static PRIORITY: {
+        readonly CUSTOM_CLASS: 0;
+        readonly NATIVE_CLASS: 1;
+        readonly PRIMITIVE: 2;
+        readonly custom: (priority: number) => number;
+    };
+    constructor({ id, match, encode, decode, priority, recursive, }: Seriall.Transformer<Options["recursive"], Decoded, Encoded>);
+}
+
+declare const ENCODE: unique symbol;
+declare const DECODE: unique symbol;
+declare const SYMBOLS: {
+    ENCODE: symbol;
+    DECODE: symbol;
+};
+declare abstract class SerializableClass {
+    constructor(..._: any);
+    [ENCODE]: () => {};
+    static [DECODE]: <T extends typeof SerializableClass>(this: T, registerNode: Parameters<Seriall.Transformer.Decoder<any, any, true>>[0]) => InstanceType<T>;
+}
+
+type SerializerOptions = {
+    enable: {
+        builtinPrimitiveTransformers: boolean;
+        builtinNativeClasses: boolean;
+        builtinClassTransformer: boolean;
+    };
+};
+declare class Serializer {
+    private transformers;
+    private transformersMap;
+    constructor(options?: DeepOptional<SerializerOptions>);
+    serialize: (data: Seriall.Serializable) => string;
+    deserialize: (data: string) => any;
+    registerTransformer: (transformer: Seriall.Transformer) => void;
+    deregisterTransformer: (transformer: Seriall.Transformer | Seriall.Transformer.Id) => void;
+    registerClass: (name: string, clazz: typeof SerializableClass) => void;
+    deregisterClass: (name: string) => void;
+}
+
+export { SYMBOLS, SerializableClass, Serializer, Seriall, Transformer };

package/dist/index.mjs

@@ -0,0 +1,415 @@
+// src/const/const.ts
+var SIGNATURE_KEY = "$";
+var DATA_KEY = "d";
+var NO_TRANSFORM_DATA = void 0;
+var PRIORITY = {
+  CUSTOM_CLASS: 0,
+  NATIVE_CLASS: 1,
+  PRIMITIVE: 2,
+  custom: (priority) => (priority <= 0 ? 1 : priority) + PRIORITY.CUSTOM_CLASS
+};
+
+// src/utils/number.utils.ts
+var isSpecialNumber = (value) => {
+  return [Infinity, -Infinity, NaN].includes(value) || Object.is(value, -0);
+};
+var encodeSpecialNumber = (value) => {
+  if (Number.isNaN(value)) return 0;
+  if (value === Infinity) return 1;
+  if (value === -Infinity) return 2;
+  if (Object.is(value, -0)) return 3;
+  throw new Error(value + " is not a special number");
+};
+var decodeSpecialNumber = (value) => {
+  switch (value) {
+    case 0:
+      return NaN;
+    case 1:
+      return Infinity;
+    case 2:
+      return -Infinity;
+    case 3:
+      return -0;
+    default:
+      throw new Error(value + " is not a special number");
+  }
+};
+
+// src/utils/json.utils.ts
+var isJsonPrimitive = (value) => {
+  if (typeof value === "number") {
+    return !isSpecialNumber(value);
+  }
+  return typeof value === "string" || typeof value === "boolean";
+};
+
+// src/utils/object.utils.ts
+var isPlainObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+var deepMerge = (...objects) => {
+  const result = {};
+  for (const obj of objects) {
+    if (!isPlainObject(obj)) continue;
+    for (const [key, value] of Object.entries(obj)) {
+      if (Array.isArray(value)) {
+        result[key] = structuredClone(value);
+      } else if (isPlainObject(value)) {
+        const existing = result[key];
+        result[key] = deepMerge(isPlainObject(existing) ? existing : {}, value);
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+};
+
+// src/serialization/serialize.ts
+var serialize = (data, transformers) => {
+  const graph = [];
+  const seen = /* @__PURE__ */ new Map();
+  const addNodeToGraph = (node) => {
+    if (isJsonPrimitive(node)) {
+      const id2 = graph.length;
+      graph.push(node);
+      return id2;
+    }
+    let id = seen.get(node);
+    if (id !== void 0) {
+      return id;
+    }
+    id = graph.length;
+    seen.set(node, id);
+    const transformer = transformers.find(
+      (transformer2) => transformer2.match(node)
+    );
+    if (transformer) {
+      graph.push({ $: transformer.id });
+      const revivable = graph[id];
+      const encoded = transformer.encode(node);
+      if (encoded !== NO_TRANSFORM_DATA) {
+        const dataId = addNodeToGraph(encoded);
+        revivable.d = dataId;
+      }
+      return id;
+    }
+    if (Array.isArray(node)) {
+      graph.push([]);
+      const arr = graph[id];
+      for (const element of node) {
+        const elementId = addNodeToGraph(element);
+        arr.push(elementId);
+      }
+      return id;
+    }
+    throw new Error(
+      `No transformer found for the current value "${node?.toString()}", please add one`
+    );
+  };
+  addNodeToGraph(data);
+  return JSON.stringify(graph);
+};
+
+// src/serialization/deserialize.ts
+var deserialize = (data, transformers) => {
+  const graph = JSON.parse(data);
+  const revived = /* @__PURE__ */ new Map();
+  const reviveNode = (index) => {
+    if (revived.has(index)) {
+      return revived.get(index);
+    }
+    if (graph.length <= index || index < 0) {
+      throw new Error(`Invalid serialized graph reference: ${index}`);
+    }
+    const node = graph[index];
+    if (isJsonPrimitive(node)) {
+      return node;
+    }
+    if (Array.isArray(node)) {
+      const arr = [];
+      revived.set(index, arr);
+      for (const element of node) {
+        arr.push(reviveNode(element));
+      }
+      return arr;
+    }
+    const transformerId = node[SIGNATURE_KEY];
+    const transformer = transformers.get(transformerId);
+    if (!transformerId) {
+      throw new Error(`No transformer found for node "${node}"`);
+    }
+    if (transformer === void 0) {
+      throw new Error(`No transformer found with id "${transformerId}"`);
+    }
+    const nonRecursiveTransformer = transformer;
+    const dataId = node[DATA_KEY];
+    if (dataId === void 0) {
+      const decoded = nonRecursiveTransformer.decode(NO_TRANSFORM_DATA);
+      revived.set(index, decoded);
+      return decoded;
+    }
+    if (!transformer.recursive) {
+      const decoded = nonRecursiveTransformer.decode(reviveNode(dataId));
+      revived.set(index, decoded);
+      return decoded;
+    }
+    const registerNode = (node2) => {
+      revived.set(index, node2);
+      return reviveNode(dataId);
+    };
+    return transformer.decode(registerNode);
+  };
+  return reviveNode(0);
+};
+
+// src/transformer/Transformer.ts
+var Transformer = class {
+  id;
+  recursive;
+  match;
+  encode;
+  decode;
+  priority;
+  static PRIORITY = PRIORITY;
+  constructor({
+    id,
+    match,
+    encode,
+    decode,
+    priority,
+    recursive
+  }) {
+    this.id = id;
+    this.recursive = recursive;
+    this.match = match;
+    this.encode = encode;
+    this.decode = decode;
+    this.priority = priority || PRIORITY.CUSTOM_CLASS;
+  }
+};
+
+// src/transformer/builtin.transformers.ts
+var primitivesTransformers = [
+  new Transformer({
+    id: "sym",
+    priority: Transformer.PRIORITY.PRIMITIVE,
+    match: (node) => typeof node === "symbol",
+    encode: (node) => ({
+      d: node.description,
+      f: Symbol.keyFor(node) === void 0 ? 0 : 1
+    }),
+    decode: (encoded) => {
+      if (encoded.f === 1 && encoded.d) {
+        return Symbol.for(encoded.d);
+      }
+      return Symbol(encoded.d);
+    }
+  }),
+  new Transformer({
+    id: "spe",
+    priority: Transformer.PRIORITY.PRIMITIVE,
+    match: isSpecialNumber,
+    encode: encodeSpecialNumber,
+    decode: decodeSpecialNumber
+  }),
+  new Transformer({
+    id: "udf",
+    priority: Transformer.PRIORITY.PRIMITIVE,
+    match: (node) => node === void 0,
+    encode: () => NO_TRANSFORM_DATA,
+    decode: () => void 0
+  }),
+  new Transformer({
+    id: "nul",
+    priority: Transformer.PRIORITY.PRIMITIVE,
+    match: (node) => node === null,
+    encode: () => NO_TRANSFORM_DATA,
+    decode: () => null
+  }),
+  new Transformer({
+    id: "big",
+    priority: Transformer.PRIORITY.PRIMITIVE,
+    match: (node) => typeof node === "bigint",
+    encode: (node) => node.toString(),
+    decode: (node) => BigInt(node)
+  }),
+  new Transformer({
+    id: "obj",
+    priority: Transformer.PRIORITY.PRIMITIVE,
+    recursive: true,
+    match: (node) => !Array.isArray(node) && typeof node === "object",
+    encode: (node) => {
+      const obj = [];
+      for (const key of Reflect.ownKeys(node)) {
+        obj.push([key, node[key]]);
+      }
+      return obj;
+    },
+    decode: (registerNode) => {
+      const obj = {};
+      const encoded = registerNode(obj);
+      for (const [key, value] of encoded) {
+        obj[key] = value;
+      }
+      return obj;
+    }
+  })
+];
+var nativeClassesTransformers = [
+  new Transformer({
+    id: "Dte",
+    priority: Transformer.PRIORITY.NATIVE_CLASS,
+    match: (node) => node instanceof Date,
+    encode: (node) => node.getTime(),
+    decode: (node) => new Date(node)
+  }),
+  new Transformer({
+    id: "Set",
+    priority: Transformer.PRIORITY.NATIVE_CLASS,
+    recursive: true,
+    match: (node) => node instanceof Set,
+    encode: (node) => Array.from(node),
+    decode: (registerNode) => {
+      const set = /* @__PURE__ */ new Set();
+      const encoded = registerNode(set);
+      for (const element of encoded) {
+        set.add(element);
+      }
+      return set;
+    }
+  }),
+  new Transformer({
+    id: "Map",
+    priority: Transformer.PRIORITY.NATIVE_CLASS,
+    recursive: true,
+    match: (node) => node instanceof Map,
+    encode: (node) => Array.from(node),
+    decode: (registerNode) => {
+      const map = /* @__PURE__ */ new Map();
+      const encoded = registerNode(map);
+      for (const [key, value] of encoded) {
+        map.set(key, value);
+      }
+      return map;
+    }
+  }),
+  new Transformer({
+    id: "Rgx",
+    priority: Transformer.PRIORITY.NATIVE_CLASS,
+    match: (node) => node instanceof RegExp,
+    encode: (node) => ({ s: node.source, f: node.flags }),
+    decode: (node) => new RegExp(node.s, node.f)
+  }),
+  new Transformer({
+    id: "Str",
+    priority: Transformer.PRIORITY.NATIVE_CLASS,
+    match: (node) => node instanceof String,
+    encode: (node) => node.valueOf(),
+    decode: (node) => new String(node)
+  }),
+  new Transformer({
+    id: "Num",
+    priority: Transformer.PRIORITY.NATIVE_CLASS,
+    match: (node) => node instanceof Number,
+    encode: (node) => node.valueOf(),
+    decode: (node) => new Number(node)
+  }),
+  new Transformer({
+    id: "Bol",
+    priority: Transformer.PRIORITY.NATIVE_CLASS,
+    match: (node) => node instanceof Boolean,
+    encode: (node) => node.valueOf(),
+    decode: (node) => new Boolean(node)
+  })
+];
+
+// src/transformer/builtin.classTransformer.ts
+var ENCODE = /* @__PURE__ */ Symbol("encode");
+var DECODE = /* @__PURE__ */ Symbol("decode");
+var SYMBOLS = { ENCODE, DECODE };
+var SerializableClass = class {
+  constructor(..._) {
+  }
+  [ENCODE] = () => {
+    const encoded = {};
+    for (const key of Reflect.ownKeys(this)) {
+      const value = this[key];
+      if (typeof value !== "function") {
+        encoded[key] = this[key];
+      }
+    }
+    return encoded;
+  };
+  static [DECODE] = function(registerNode) {
+    let revivedInstance = {};
+    const args = registerNode(revivedInstance);
+    Object.assign(revivedInstance, args);
+    Object.setPrototypeOf(revivedInstance, this.prototype);
+    return revivedInstance;
+  };
+};
+var createClassTransformer = (id, clazz) => new Transformer({
+  id,
+  priority: Transformer.PRIORITY.CUSTOM_CLASS,
+  recursive: true,
+  match: (node) => node instanceof clazz,
+  encode: (node) => node[ENCODE](),
+  decode: (registerNode) => clazz[DECODE](registerNode)
+});
+
+// src/serialization/Serializer.ts
+var defaultOptions = {
+  enable: {
+    builtinPrimitiveTransformers: true,
+    builtinNativeClasses: true,
+    builtinClassTransformer: true
+  }
+};
+var Serializer = class {
+  transformers = [];
+  transformersMap = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    const opt = deepMerge(defaultOptions, options);
+    if (opt.enable.builtinPrimitiveTransformers)
+      primitivesTransformers.forEach(this.registerTransformer);
+    if (opt.enable.builtinNativeClasses)
+      nativeClassesTransformers.forEach(this.registerTransformer);
+  }
+  serialize = (data) => serialize(data, this.transformers);
+  deserialize = (data) => deserialize(data, this.transformersMap);
+  registerTransformer = (transformer) => {
+    if (this.transformersMap.has(transformer.id)) {
+      throw new Error(
+        `A transformer with id "${transformer.id}" is already registered, chose another one`
+      );
+    }
+    this.transformers.push(transformer);
+    this.transformers = this.transformers.sort(
+      (a, b) => (a.priority ?? Infinity) - (b.priority ?? Infinity)
+    );
+    this.transformersMap.set(transformer.id, transformer);
+  };
+  deregisterTransformer = (transformer) => {
+    const id = typeof transformer === "object" ? transformer.id : transformer;
+    if (!this.transformersMap.has(id)) {
+      throw new Error(
+        `No transformer found for id "${id}", cannot deregister it`
+      );
+    }
+    this.transformers = this.transformers.filter(
+      (transformer2) => transformer2.id !== id
+    );
+    this.transformersMap.delete(id);
+  };
+  registerClass = (name, clazz) => {
+    this.registerTransformer(createClassTransformer("$" + name, clazz));
+  };
+  deregisterClass = (name) => {
+    this.deregisterTransformer("$" + name);
+  };
+};
+export {
+  SYMBOLS,
+  SerializableClass,
+  Serializer,
+  Transformer
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "seriall",
+  "version": "1.0.0",
+  "description": "A flexible js serializer, capable of serializing/deserializing any js data, while preserving referential integrity, non-json-primitive values, and even custom class instances",
+  "author": {
+    "email": "loic.duvail.pro@gmail.com",
+    "name": "loicd"
+  },
+  "type": "module",
+  "exports": {
+    "import": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "require": {
+      "types": "./dist/index.d.cts",
+      "default": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -rf ./dist && npm run build:js && npm run build:types",
+    "build:js": "node ./esbuild.js",
+    "build:types": "rollup -c",
+    "build:test": "node ./esbuild.test.js",
+    "test": "npm run build:test && npx jest"
+  },
+  "keywords": [
+    "serializer",
+    "serialization",
+    "circular",
+    "json",
+    "referential",
+    "integrity"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/loicDuvail/seriall.git"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^26.5.1",
+    "esbuild": "^0.28.2",
+    "jest": "^30.5.1",
+    "rollup": "^4.63.6",
+    "rollup-plugin-dts": "^6.5.1",
+    "typescript": "^6.0.3"
+  }
+}