@stryke/json 0.9.44 → 0.10.0

package/dist/storm-json-AaFeOao2.d.cts

@@ -0,0 +1,70 @@
+import { H as JsonSerializeOptions, U as JsonValue, d as JsonParserResult, l as JsonParseOptions, t as Class } from "./types-BUeTTE_U.cjs";
+import SuperJSON from "superjson";
+
+//#region src/storm-json.d.ts
+
+/**
+ * A static JSON parser class used by Storm Software to serialize and deserialize JSON data
+ *
+ * @remarks
+ * This class uses the [SuperJSON](https://github.com/blitz-js/superjson) library under the hood.
+ */
+declare class StormJSON extends SuperJSON {
+  #private;
+  static get instance(): StormJSON;
+  /**
+   * Deserialize the given value with superjson using the given metadata
+   */
+  static deserialize<TData = unknown>(payload: JsonParserResult): TData;
+  /**
+   * Serialize the given value with superjson
+   */
+  static serialize(object: JsonValue): JsonParserResult;
+  /**
+   * Parse the given string value with superjson using the given metadata
+   *
+   * @param value - The string value to parse
+   * @returns The parsed data
+   */
+  static parse<TData = unknown>(value: string): TData;
+  /**
+   * Serializes the given data to a JSON string.
+   * By default the JSON string is formatted with a 2 space indentation to be easy readable.
+   *
+   * @param value - Object which should be serialized to JSON
+   * @param options - JSON serialize options
+   * @returns the formatted JSON representation of the object
+   */
+  static stringify<T>(value: T, options?: JsonSerializeOptions): string;
+  /**
+   * Parses the given JSON string and returns the object the JSON content represents.
+   * By default javascript-style comments and trailing commas are allowed.
+   *
+   * @param strData - JSON content as string
+   * @param options - JSON parse options
+   * @returns Object the JSON content represents
+   */
+  static parseJson<TData = unknown>(strData: string, options?: JsonParseOptions): TData;
+  /**
+   * Register a custom schema with superjson
+   *
+   * @param name - The name of the schema
+   * @param serialize - The function to serialize the schema
+   * @param deserialize - The function to deserialize the schema
+   * @param isApplicable - The function to check if the schema is applicable
+   */
+  static register<TData = any, TJsonObject extends JsonValue = JsonValue>(name: string, serialize: (data: TData) => TJsonObject, deserialize: (json: TJsonObject) => TData, isApplicable: (data: any) => data is TData): void;
+  /**
+   * Register a class with superjson
+   *
+   * @param classConstructor - The class constructor to register
+   */
+  static registerClass(classConstructor: Class, options?: {
+    identifier?: string;
+    allowProps?: string[];
+  } | string): void;
+  private constructor();
+}
+//#endregion
+export { StormJSON as t };
+//# sourceMappingURL=storm-json-AaFeOao2.d.cts.map

package/dist/storm-json-AaFeOao2.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storm-json-AaFeOao2.d.cts","names":[],"sources":["../src/storm-json.ts"],"sourcesContent":[],"mappings":";;;;;;;AA0CA;;;;AAuB2C,cAvB9B,SAAA,SAAkB,SAAA,CAuBY;EAAY,CAAA,OAAA;EAUS,WAAA,QAAA,CAAA,CAAA,EA9BhC,SA8BgC;EAarD;;;EAyBN,OAAA,WAAA,CAAA,QAAA,OAAA,CAAA,CAAA,OAAA,EAxDQ,gBAwDR,CAAA,EAvDA,KAuDA;EAiCmB;;;EAGQ,OAAA,SAAA,CAAA,MAAA,EApFW,SAoFX,CAAA,EApFuB,gBAoFvB;EACR;;;;;;gDA3EwC;;;;;;;;;6BAarD,aACG;;;;;;;;;+DAuBA,mBACT;;;;;;;;;mDAiCmB,YAAY,2CAGd,UAAU,iCACR,gBAAgB,4CACC;;;;;;yCAkBnB"}

package/dist/storm-json-BvRkzAlR.d.mts

@@ -0,0 +1,70 @@
+import { H as JsonSerializeOptions, U as JsonValue, d as JsonParserResult, l as JsonParseOptions, t as Class } from "./types-C_KlcCNw.mjs";
+import SuperJSON from "superjson";
+
+//#region src/storm-json.d.ts
+
+/**
+ * A static JSON parser class used by Storm Software to serialize and deserialize JSON data
+ *
+ * @remarks
+ * This class uses the [SuperJSON](https://github.com/blitz-js/superjson) library under the hood.
+ */
+declare class StormJSON extends SuperJSON {
+  #private;
+  static get instance(): StormJSON;
+  /**
+   * Deserialize the given value with superjson using the given metadata
+   */
+  static deserialize<TData = unknown>(payload: JsonParserResult): TData;
+  /**
+   * Serialize the given value with superjson
+   */
+  static serialize(object: JsonValue): JsonParserResult;
+  /**
+   * Parse the given string value with superjson using the given metadata
+   *
+   * @param value - The string value to parse
+   * @returns The parsed data
+   */
+  static parse<TData = unknown>(value: string): TData;
+  /**
+   * Serializes the given data to a JSON string.
+   * By default the JSON string is formatted with a 2 space indentation to be easy readable.
+   *
+   * @param value - Object which should be serialized to JSON
+   * @param options - JSON serialize options
+   * @returns the formatted JSON representation of the object
+   */
+  static stringify<T>(value: T, options?: JsonSerializeOptions): string;
+  /**
+   * Parses the given JSON string and returns the object the JSON content represents.
+   * By default javascript-style comments and trailing commas are allowed.
+   *
+   * @param strData - JSON content as string
+   * @param options - JSON parse options
+   * @returns Object the JSON content represents
+   */
+  static parseJson<TData = unknown>(strData: string, options?: JsonParseOptions): TData;
+  /**
+   * Register a custom schema with superjson
+   *
+   * @param name - The name of the schema
+   * @param serialize - The function to serialize the schema
+   * @param deserialize - The function to deserialize the schema
+   * @param isApplicable - The function to check if the schema is applicable
+   */
+  static register<TData = any, TJsonObject extends JsonValue = JsonValue>(name: string, serialize: (data: TData) => TJsonObject, deserialize: (json: TJsonObject) => TData, isApplicable: (data: any) => data is TData): void;
+  /**
+   * Register a class with superjson
+   *
+   * @param classConstructor - The class constructor to register
+   */
+  static registerClass(classConstructor: Class, options?: {
+    identifier?: string;
+    allowProps?: string[];
+  } | string): void;
+  private constructor();
+}
+//#endregion
+export { StormJSON as t };
+//# sourceMappingURL=storm-json-BvRkzAlR.d.mts.map

package/dist/storm-json-BvRkzAlR.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storm-json-BvRkzAlR.d.mts","names":[],"sources":["../src/storm-json.ts"],"sourcesContent":[],"mappings":";;;;;;;AA0CA;;;;AAuB2C,cAvB9B,SAAA,SAAkB,SAAA,CAuBY;EAAY,CAAA,OAAA;EAUS,WAAA,QAAA,CAAA,CAAA,EA9BhC,SA8BgC;EAarD;;;EAyBN,OAAA,WAAA,CAAA,QAAA,OAAA,CAAA,CAAA,OAAA,EAxDQ,gBAwDR,CAAA,EAvDA,KAuDA;EAiCmB;;;EAGQ,OAAA,SAAA,CAAA,MAAA,EApFW,SAoFX,CAAA,EApFuB,gBAoFvB;EACR;;;;;;gDA3EwC;;;;;;;;;6BAarD,aACG;;;;;;;;;+DAuBA,mBACT;;;;;;;;;mDAiCmB,YAAY,2CAGd,UAAU,iCACR,gBAAgB,4CACC;;;;;;yCAkBnB"}

package/dist/storm-json-Cy3PuAhj.mjs

@@ -0,0 +1,116 @@
+import { t as isObject } from "./is-object-BpfmzHWa.mjs";
+import { t as isString } from "./is-string-CLiBUSKV.mjs";
+import { t as parse$1 } from "./parse-obdkJfj5.mjs";
+import { t as formatParseError } from "./parse-error-C3Qmubee.mjs";
+import { n as stringify } from "./stringify-D5baUfEe.mjs";
+import { parse } from "jsonc-parser";
+import { Buffer } from "node:buffer";
+import SuperJSON from "superjson";
+
+//#region src/storm-json.ts
+/**
+* A static JSON parser class used by Storm Software to serialize and deserialize JSON data
+*
+* @remarks
+* This class uses the [SuperJSON](https://github.com/blitz-js/superjson) library under the hood.
+*/
+var StormJSON = class StormJSON extends SuperJSON {
+	static #instance;
+	static get instance() {
+		if (!StormJSON.#instance) StormJSON.#instance = new StormJSON();
+		return StormJSON.#instance;
+	}
+	/**
+	* Deserialize the given value with superjson using the given metadata
+	*/
+	static deserialize(payload) {
+		return StormJSON.instance.deserialize(payload);
+	}
+	/**
+	* Serialize the given value with superjson
+	*/
+	static serialize(object) {
+		return StormJSON.instance.serialize(object);
+	}
+	/**
+	* Parse the given string value with superjson using the given metadata
+	*
+	* @param value - The string value to parse
+	* @returns The parsed data
+	*/
+	static parse(value) {
+		return parse$1(value);
+	}
+	/**
+	* Serializes the given data to a JSON string.
+	* By default the JSON string is formatted with a 2 space indentation to be easy readable.
+	*
+	* @param value - Object which should be serialized to JSON
+	* @param options - JSON serialize options
+	* @returns the formatted JSON representation of the object
+	*/
+	static stringify(value, options) {
+		const customTransformer = StormJSON.instance.customTransformerRegistry.findApplicable(value);
+		let result = value;
+		if (customTransformer && customTransformer.isApplicable(value)) result = customTransformer.serialize(result);
+		return stringify(result, options?.spaces ?? 2);
+	}
+	/**
+	* Parses the given JSON string and returns the object the JSON content represents.
+	* By default javascript-style comments and trailing commas are allowed.
+	*
+	* @param strData - JSON content as string
+	* @param options - JSON parse options
+	* @returns Object the JSON content represents
+	*/
+	static parseJson(strData, options) {
+		try {
+			if (options?.expectComments === false) return StormJSON.instance.parse(strData);
+		} catch {}
+		const errors = [];
+		const result = parse(strData, errors, {
+			allowTrailingComma: true,
+			...options
+		});
+		if (errors.length > 0 && errors[0]) throw new Error(formatParseError(strData, errors[0]));
+		return result;
+	}
+	/**
+	* Register a custom schema with superjson
+	*
+	* @param name - The name of the schema
+	* @param serialize - The function to serialize the schema
+	* @param deserialize - The function to deserialize the schema
+	* @param isApplicable - The function to check if the schema is applicable
+	*/
+	static register(name, serialize, deserialize, isApplicable) {
+		StormJSON.instance.registerCustom({
+			isApplicable,
+			serialize,
+			deserialize
+		}, name);
+	}
+	/**
+	* Register a class with superjson
+	*
+	* @param classConstructor - The class constructor to register
+	*/
+	static registerClass(classConstructor, options) {
+		StormJSON.instance.registerClass(classConstructor, {
+			identifier: isString(options) ? options : options?.identifier || classConstructor.name,
+			allowProps: options && isObject(options) && options?.allowProps && Array.isArray(options.allowProps) ? options.allowProps : ["__typename"]
+		});
+	}
+	constructor() {
+		super({ dedupe: true });
+	}
+};
+StormJSON.instance.registerCustom({
+	isApplicable: (v) => typeof Buffer.isBuffer === "function" && Buffer.isBuffer(v),
+	serialize: (v) => v.toString("base64"),
+	deserialize: (v) => Buffer.from(v, "base64")
+}, "Bytes");
+
+//#endregion
+export { StormJSON as t };
+//# sourceMappingURL=storm-json-Cy3PuAhj.mjs.map

package/dist/storm-json-Cy3PuAhj.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"storm-json-Cy3PuAhj.mjs","names":["#instance","parseValue","stringifyValue","errors: ParseError[]"],"sources":["../src/storm-json.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport type { ParseError } from \"jsonc-parser\";\nimport type {\n  Class,\n  JsonParseOptions,\n  JsonParserResult,\n  JsonSerializeOptions,\n  JsonValue\n} from \"./types\";\n// import { Decimal } from \"decimal.js\";\nimport { isObject } from \"@stryke/type-checks/is-object\";\nimport { isString } from \"@stryke/type-checks/is-string\";\nimport { parse } from \"jsonc-parser\";\nimport { Buffer } from \"node:buffer\";\nimport SuperJSON from \"superjson\";\nimport { parse as parseValue } from \"./utils/parse\";\nimport { formatParseError } from \"./utils/parse-error\";\nimport { stringify as stringifyValue } from \"./utils/stringify\";\n\n/**\n * A static JSON parser class used by Storm Software to serialize and deserialize JSON data\n *\n * @remarks\n * This class uses the [SuperJSON](https://github.com/blitz-js/superjson) library under the hood.\n */\nexport class StormJSON extends SuperJSON {\n  static #instance: StormJSON;\n\n  public static get instance(): StormJSON {\n    if (!StormJSON.#instance) {\n      StormJSON.#instance = new StormJSON();\n    }\n\n    return StormJSON.#instance;\n  }\n\n  /**\n   * Deserialize the given value with superjson using the given metadata\n   */\n  public static override deserialize<TData = unknown>(\n    payload: JsonParserResult\n  ): TData {\n    return StormJSON.instance.deserialize(payload);\n  }\n\n  /**\n   * Serialize the given value with superjson\n   */\n  public static override serialize(object: JsonValue): JsonParserResult {\n    return StormJSON.instance.serialize(object);\n  }\n\n  /**\n   * Parse the given string value with superjson using the given metadata\n   *\n   * @param value - The string value to parse\n   * @returns The parsed data\n   */\n  public static override parse<TData = unknown>(value: string): TData {\n    return parseValue(value);\n  }\n\n  /**\n   * Serializes the given data to a JSON string.\n   * By default the JSON string is formatted with a 2 space indentation to be easy readable.\n   *\n   * @param value - Object which should be serialized to JSON\n   * @param options - JSON serialize options\n   * @returns the formatted JSON representation of the object\n   */\n  public static override stringify<T>(\n    value: T,\n    options?: JsonSerializeOptions\n  ): string {\n    const customTransformer =\n      StormJSON.instance.customTransformerRegistry.findApplicable(value);\n\n    let result = value;\n    if (customTransformer && customTransformer.isApplicable(value)) {\n      result = customTransformer.serialize(result) as T;\n    }\n\n    return stringifyValue(result, options?.spaces ?? 2);\n  }\n\n  /**\n   * Parses the given JSON string and returns the object the JSON content represents.\n   * By default javascript-style comments and trailing commas are allowed.\n   *\n   * @param strData - JSON content as string\n   * @param options - JSON parse options\n   * @returns Object the JSON content represents\n   */\n  public static parseJson<TData = unknown>(\n    strData: string,\n    options?: JsonParseOptions\n  ): TData {\n    try {\n      if (options?.expectComments === false) {\n        return StormJSON.instance.parse(strData);\n      }\n    } catch {\n      // Do nothing\n    }\n\n    const errors: ParseError[] = [];\n    const opts = {\n      allowTrailingComma: true,\n      ...options\n    };\n    const result = parse(strData, errors, opts) as TData;\n\n    if (errors.length > 0 && errors[0]) {\n      throw new Error(formatParseError(strData, errors[0]));\n    }\n\n    return result;\n  }\n\n  /**\n   * Register a custom schema with superjson\n   *\n   * @param name - The name of the schema\n   * @param serialize - The function to serialize the schema\n   * @param deserialize - The function to deserialize the schema\n   * @param isApplicable - The function to check if the schema is applicable\n   */\n  public static register<\n    TData = any,\n    TJsonObject extends JsonValue = JsonValue\n  >(\n    name: string,\n    serialize: (data: TData) => TJsonObject,\n    deserialize: (json: TJsonObject) => TData,\n    isApplicable: (data: any) => data is TData\n  ) {\n    StormJSON.instance.registerCustom<TData, TJsonObject>(\n      {\n        isApplicable,\n        serialize,\n        deserialize\n      },\n      name\n    );\n  }\n\n  /**\n   * Register a class with superjson\n   *\n   * @param classConstructor - The class constructor to register\n   */\n  public static override registerClass(\n    classConstructor: Class,\n    options?: { identifier?: string; allowProps?: string[] } | string\n  ) {\n    StormJSON.instance.registerClass(classConstructor, {\n      identifier: isString(options)\n        ? options\n        : options?.identifier || classConstructor.name,\n      allowProps:\n        options &&\n        isObject(options) &&\n        options?.allowProps &&\n        Array.isArray(options.allowProps)\n          ? options.allowProps\n          : [\"__typename\"]\n    });\n  }\n\n  private constructor() {\n    super({ dedupe: true });\n  }\n}\n\nStormJSON.instance.registerCustom<Buffer, string>(\n  {\n    isApplicable: (v): v is Buffer =>\n      typeof Buffer.isBuffer === \"function\" && Buffer.isBuffer(v),\n    serialize: v => v.toString(\"base64\"),\n    deserialize: v => Buffer.from(v, \"base64\")\n  },\n  \"Bytes\"\n);\n"],"mappings":";;;;;;;;;;;;;;;;AA0CA,IAAa,YAAb,MAAa,kBAAkB,UAAU;CACvC,QAAOA;CAEP,WAAkB,WAAsB;AACtC,MAAI,CAAC,WAAUA,SACb,YAAUA,WAAY,IAAI,WAAW;AAGvC,SAAO,WAAUA;;;;;CAMnB,OAAuB,YACrB,SACO;AACP,SAAO,UAAU,SAAS,YAAY,QAAQ;;;;;CAMhD,OAAuB,UAAU,QAAqC;AACpE,SAAO,UAAU,SAAS,UAAU,OAAO;;;;;;;;CAS7C,OAAuB,MAAuB,OAAsB;AAClE,SAAOC,QAAW,MAAM;;;;;;;;;;CAW1B,OAAuB,UACrB,OACA,SACQ;EACR,MAAM,oBACJ,UAAU,SAAS,0BAA0B,eAAe,MAAM;EAEpE,IAAI,SAAS;AACb,MAAI,qBAAqB,kBAAkB,aAAa,MAAM,CAC5D,UAAS,kBAAkB,UAAU,OAAO;AAG9C,SAAOC,UAAe,QAAQ,SAAS,UAAU,EAAE;;;;;;;;;;CAWrD,OAAc,UACZ,SACA,SACO;AACP,MAAI;AACF,OAAI,SAAS,mBAAmB,MAC9B,QAAO,UAAU,SAAS,MAAM,QAAQ;UAEpC;EAIR,MAAMC,SAAuB,EAAE;EAK/B,MAAM,SAAS,MAAM,SAAS,QAJjB;GACX,oBAAoB;GACpB,GAAG;GACJ,CAC0C;AAE3C,MAAI,OAAO,SAAS,KAAK,OAAO,GAC9B,OAAM,IAAI,MAAM,iBAAiB,SAAS,OAAO,GAAG,CAAC;AAGvD,SAAO;;;;;;;;;;CAWT,OAAc,SAIZ,MACA,WACA,aACA,cACA;AACA,YAAU,SAAS,eACjB;GACE;GACA;GACA;GACD,EACD,KACD;;;;;;;CAQH,OAAuB,cACrB,kBACA,SACA;AACA,YAAU,SAAS,cAAc,kBAAkB;GACjD,YAAY,SAAS,QAAQ,GACzB,UACA,SAAS,cAAc,iBAAiB;GAC5C,YACE,WACA,SAAS,QAAQ,IACjB,SAAS,cACT,MAAM,QAAQ,QAAQ,WAAW,GAC7B,QAAQ,aACR,CAAC,aAAa;GACrB,CAAC;;CAGJ,AAAQ,cAAc;AACpB,QAAM,EAAE,QAAQ,MAAM,CAAC;;;AAI3B,UAAU,SAAS,eACjB;CACE,eAAe,MACb,OAAO,OAAO,aAAa,cAAc,OAAO,SAAS,EAAE;CAC7D,YAAW,MAAK,EAAE,SAAS,SAAS;CACpC,cAAa,MAAK,OAAO,KAAK,GAAG,SAAS;CAC3C,EACD,QACD"}

package/dist/storm-json.cjs

@@ -1,117 +1,4 @@
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
-const require_is_object = require('./type-checks/src/is-object.cjs');
-const require_is_string = require('./type-checks/src/is-string.cjs');
-const require_utils_parse = require('./utils/parse.cjs');
-const require_utils_parse_error = require('./utils/parse-error.cjs');
-const require_utils_stringify = require('./utils/stringify.cjs');
-let jsonc_parser = require("jsonc-parser");
-let node_buffer = require("node:buffer");
-let superjson = require("superjson");
-superjson = require_rolldown_runtime.__toESM(superjson);
+const require_storm_json = require('./storm-json-6WpS7qnH.cjs');
+require('./parse-error-Dzwg4sdE.cjs');
 
-//#region src/storm-json.ts
-/**
-* A static JSON parser class used by Storm Software to serialize and deserialize JSON data
-*
-* @remarks
-* This class uses the [SuperJSON](https://github.com/blitz-js/superjson) library under the hood.
-*/
-var StormJSON = class StormJSON extends superjson.default {
-	static #instance;
-	static get instance() {
-		if (!StormJSON.#instance) StormJSON.#instance = new StormJSON();
-		return StormJSON.#instance;
-	}
-	/**
-	* Deserialize the given value with superjson using the given metadata
-	*/
-	static deserialize(payload) {
-		return StormJSON.instance.deserialize(payload);
-	}
-	/**
-	* Serialize the given value with superjson
-	*/
-	static serialize(object) {
-		return StormJSON.instance.serialize(object);
-	}
-	/**
-	* Parse the given string value with superjson using the given metadata
-	*
-	* @param value - The string value to parse
-	* @returns The parsed data
-	*/
-	static parse(value) {
-		return require_utils_parse.parse(value);
-	}
-	/**
-	* Serializes the given data to a JSON string.
-	* By default the JSON string is formatted with a 2 space indentation to be easy readable.
-	*
-	* @param value - Object which should be serialized to JSON
-	* @param _options - JSON serialize options
-	* @returns the formatted JSON representation of the object
-	*/
-	static stringify(value, _options) {
-		const customTransformer = StormJSON.instance.customTransformerRegistry.findApplicable(value);
-		let result = value;
-		if (customTransformer && customTransformer.isApplicable(value)) result = customTransformer.serialize(result);
-		return require_utils_stringify.stringify(result);
-	}
-	/**
-	* Parses the given JSON string and returns the object the JSON content represents.
-	* By default javascript-style comments and trailing commas are allowed.
-	*
-	* @param strData - JSON content as string
-	* @param options - JSON parse options
-	* @returns Object the JSON content represents
-	*/
-	static parseJson(strData, options) {
-		try {
-			if (options?.expectComments === false) return StormJSON.instance.parse(strData);
-		} catch {}
-		const errors = [];
-		const result = (0, jsonc_parser.parse)(strData, errors, {
-			allowTrailingComma: true,
-			...options
-		});
-		if (errors.length > 0 && errors[0]) throw new Error(require_utils_parse_error.formatParseError(strData, errors[0]));
-		return result;
-	}
-	/**
-	* Register a custom schema with superjson
-	*
-	* @param name - The name of the schema
-	* @param serialize - The function to serialize the schema
-	* @param deserialize - The function to deserialize the schema
-	* @param isApplicable - The function to check if the schema is applicable
-	*/
-	static register(name, serialize, deserialize, isApplicable) {
-		StormJSON.instance.registerCustom({
-			isApplicable,
-			serialize,
-			deserialize
-		}, name);
-	}
-	/**
-	* Register a class with superjson
-	*
-	* @param classConstructor - The class constructor to register
-	*/
-	static registerClass(classConstructor, options) {
-		StormJSON.instance.registerClass(classConstructor, {
-			identifier: require_is_string.isString(options) ? options : options?.identifier || classConstructor.name,
-			allowProps: options && require_is_object.isObject(options) && options?.allowProps && Array.isArray(options.allowProps) ? options.allowProps : ["__typename"]
-		});
-	}
-	constructor() {
-		super({ dedupe: true });
-	}
-};
-StormJSON.instance.registerCustom({
-	isApplicable: (v) => node_buffer.Buffer.isBuffer(v),
-	serialize: (v) => v.toString("base64"),
-	deserialize: (v) => node_buffer.Buffer.from(v, "base64")
-}, "Bytes");
-
-//#endregion
-exports.StormJSON = StormJSON;
+exports.StormJSON = require_storm_json.StormJSON;

package/dist/storm-json.d.cts

@@ -1,70 +1,2 @@
-import { Class, JsonParseOptions, JsonParserResult, JsonSerializeOptions, JsonValue } from "./types.cjs";
-import SuperJSON from "superjson";
-
-//#region src/storm-json.d.ts
-
-/**
- * A static JSON parser class used by Storm Software to serialize and deserialize JSON data
- *
- * @remarks
- * This class uses the [SuperJSON](https://github.com/blitz-js/superjson) library under the hood.
- */
-declare class StormJSON extends SuperJSON {
-  #private;
-  static get instance(): StormJSON;
-  /**
-   * Deserialize the given value with superjson using the given metadata
-   */
-  static deserialize<TData = unknown>(payload: JsonParserResult): TData;
-  /**
-   * Serialize the given value with superjson
-   */
-  static serialize(object: JsonValue): JsonParserResult;
-  /**
-   * Parse the given string value with superjson using the given metadata
-   *
-   * @param value - The string value to parse
-   * @returns The parsed data
-   */
-  static parse<TData = unknown>(value: string): TData;
-  /**
-   * Serializes the given data to a JSON string.
-   * By default the JSON string is formatted with a 2 space indentation to be easy readable.
-   *
-   * @param value - Object which should be serialized to JSON
-   * @param _options - JSON serialize options
-   * @returns the formatted JSON representation of the object
-   */
-  static stringify<T>(value: T, _options?: JsonSerializeOptions): string;
-  /**
-   * Parses the given JSON string and returns the object the JSON content represents.
-   * By default javascript-style comments and trailing commas are allowed.
-   *
-   * @param strData - JSON content as string
-   * @param options - JSON parse options
-   * @returns Object the JSON content represents
-   */
-  static parseJson<TData = unknown>(strData: string, options?: JsonParseOptions): TData;
-  /**
-   * Register a custom schema with superjson
-   *
-   * @param name - The name of the schema
-   * @param serialize - The function to serialize the schema
-   * @param deserialize - The function to deserialize the schema
-   * @param isApplicable - The function to check if the schema is applicable
-   */
-  static register<TData = any, TJsonObject extends JsonValue = JsonValue>(name: string, serialize: (data: TData) => TJsonObject, deserialize: (json: TJsonObject) => TData, isApplicable: (data: any) => data is TData): void;
-  /**
-   * Register a class with superjson
-   *
-   * @param classConstructor - The class constructor to register
-   */
-  static registerClass(classConstructor: Class, options?: {
-    identifier?: string;
-    allowProps?: string[];
-  } | string): void;
-  private constructor();
-}
-//#endregion
-export { StormJSON };
-//# sourceMappingURL=storm-json.d.cts.map
+import { t as StormJSON } from "./storm-json-AaFeOao2.cjs";
+export { StormJSON };

package/dist/storm-json.d.mts

@@ -1,70 +1,3 @@
-import { Class, JsonParseOptions, JsonParserResult, JsonSerializeOptions, JsonValue } from "./types.mjs";
-import SuperJSON from "superjson";
-
-//#region src/storm-json.d.ts
-
-/**
- * A static JSON parser class used by Storm Software to serialize and deserialize JSON data
- *
- * @remarks
- * This class uses the [SuperJSON](https://github.com/blitz-js/superjson) library under the hood.
- */
-declare class StormJSON extends SuperJSON {
-  #private;
-  static get instance(): StormJSON;
-  /**
-   * Deserialize the given value with superjson using the given metadata
-   */
-  static deserialize<TData = unknown>(payload: JsonParserResult): TData;
-  /**
-   * Serialize the given value with superjson
-   */
-  static serialize(object: JsonValue): JsonParserResult;
-  /**
-   * Parse the given string value with superjson using the given metadata
-   *
-   * @param value - The string value to parse
-   * @returns The parsed data
-   */
-  static parse<TData = unknown>(value: string): TData;
-  /**
-   * Serializes the given data to a JSON string.
-   * By default the JSON string is formatted with a 2 space indentation to be easy readable.
-   *
-   * @param value - Object which should be serialized to JSON
-   * @param _options - JSON serialize options
-   * @returns the formatted JSON representation of the object
-   */
-  static stringify<T>(value: T, _options?: JsonSerializeOptions): string;
-  /**
-   * Parses the given JSON string and returns the object the JSON content represents.
-   * By default javascript-style comments and trailing commas are allowed.
-   *
-   * @param strData - JSON content as string
-   * @param options - JSON parse options
-   * @returns Object the JSON content represents
-   */
-  static parseJson<TData = unknown>(strData: string, options?: JsonParseOptions): TData;
-  /**
-   * Register a custom schema with superjson
-   *
-   * @param name - The name of the schema
-   * @param serialize - The function to serialize the schema
-   * @param deserialize - The function to deserialize the schema
-   * @param isApplicable - The function to check if the schema is applicable
-   */
-  static register<TData = any, TJsonObject extends JsonValue = JsonValue>(name: string, serialize: (data: TData) => TJsonObject, deserialize: (json: TJsonObject) => TData, isApplicable: (data: any) => data is TData): void;
-  /**
-   * Register a class with superjson
-   *
-   * @param classConstructor - The class constructor to register
-   */
-  static registerClass(classConstructor: Class, options?: {
-    identifier?: string;
-    allowProps?: string[];
-  } | string): void;
-  private constructor();
-}
-//#endregion
-export { StormJSON };
-//# sourceMappingURL=storm-json.d.mts.map
+import "./types-C_KlcCNw.mjs";
+import { t as StormJSON } from "./storm-json-BvRkzAlR.mjs";
+export { StormJSON };

package/dist/storm-json.mjs

@@ -1,116 +1,4 @@
-import { isObject } from "./type-checks/src/is-object.mjs";
-import { isString } from "./type-checks/src/is-string.mjs";
-import { parse as parse$1 } from "./utils/parse.mjs";
-import { formatParseError } from "./utils/parse-error.mjs";
-import { stringify } from "./utils/stringify.mjs";
-import { parse } from "jsonc-parser";
-import { Buffer } from "node:buffer";
-import SuperJSON from "superjson";
+import "./parse-error-C3Qmubee.mjs";
+import { t as StormJSON } from "./storm-json-Cy3PuAhj.mjs";
 
-//#region src/storm-json.ts
-/**
-* A static JSON parser class used by Storm Software to serialize and deserialize JSON data
-*
-* @remarks
-* This class uses the [SuperJSON](https://github.com/blitz-js/superjson) library under the hood.
-*/
-var StormJSON = class StormJSON extends SuperJSON {
-	static #instance;
-	static get instance() {
-		if (!StormJSON.#instance) StormJSON.#instance = new StormJSON();
-		return StormJSON.#instance;
-	}
-	/**
-	* Deserialize the given value with superjson using the given metadata
-	*/
-	static deserialize(payload) {
-		return StormJSON.instance.deserialize(payload);
-	}
-	/**
-	* Serialize the given value with superjson
-	*/
-	static serialize(object) {
-		return StormJSON.instance.serialize(object);
-	}
-	/**
-	* Parse the given string value with superjson using the given metadata
-	*
-	* @param value - The string value to parse
-	* @returns The parsed data
-	*/
-	static parse(value) {
-		return parse$1(value);
-	}
-	/**
-	* Serializes the given data to a JSON string.
-	* By default the JSON string is formatted with a 2 space indentation to be easy readable.
-	*
-	* @param value - Object which should be serialized to JSON
-	* @param _options - JSON serialize options
-	* @returns the formatted JSON representation of the object
-	*/
-	static stringify(value, _options) {
-		const customTransformer = StormJSON.instance.customTransformerRegistry.findApplicable(value);
-		let result = value;
-		if (customTransformer && customTransformer.isApplicable(value)) result = customTransformer.serialize(result);
-		return stringify(result);
-	}
-	/**
-	* Parses the given JSON string and returns the object the JSON content represents.
-	* By default javascript-style comments and trailing commas are allowed.
-	*
-	* @param strData - JSON content as string
-	* @param options - JSON parse options
-	* @returns Object the JSON content represents
-	*/
-	static parseJson(strData, options) {
-		try {
-			if (options?.expectComments === false) return StormJSON.instance.parse(strData);
-		} catch {}
-		const errors = [];
-		const result = parse(strData, errors, {
-			allowTrailingComma: true,
-			...options
-		});
-		if (errors.length > 0 && errors[0]) throw new Error(formatParseError(strData, errors[0]));
-		return result;
-	}
-	/**
-	* Register a custom schema with superjson
-	*
-	* @param name - The name of the schema
-	* @param serialize - The function to serialize the schema
-	* @param deserialize - The function to deserialize the schema
-	* @param isApplicable - The function to check if the schema is applicable
-	*/
-	static register(name, serialize, deserialize, isApplicable) {
-		StormJSON.instance.registerCustom({
-			isApplicable,
-			serialize,
-			deserialize
-		}, name);
-	}
-	/**
-	* Register a class with superjson
-	*
-	* @param classConstructor - The class constructor to register
-	*/
-	static registerClass(classConstructor, options) {
-		StormJSON.instance.registerClass(classConstructor, {
-			identifier: isString(options) ? options : options?.identifier || classConstructor.name,
-			allowProps: options && isObject(options) && options?.allowProps && Array.isArray(options.allowProps) ? options.allowProps : ["__typename"]
-		});
-	}
-	constructor() {
-		super({ dedupe: true });
-	}
-};
-StormJSON.instance.registerCustom({
-	isApplicable: (v) => Buffer.isBuffer(v),
-	serialize: (v) => v.toString("base64"),
-	deserialize: (v) => Buffer.from(v, "base64")
-}, "Bytes");
-
-//#endregion
-export { StormJSON };
-//# sourceMappingURL=storm-json.mjs.map
+export { StormJSON };