@stryke/json 0.9.44 → 0.11.0

package/dist/schema-DGmzxHja.mjs

@@ -0,0 +1,72 @@
+import { n as isFunction, t as isSetObject } from "./is-set-object-C1Qnj1Q8.mjs";
+
+//#region src/schema.ts
+/**
+* Type guard for {@link JsonSchema7AllOfType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7AllOfType}, false otherwise
+*/
+function isJsonSchema7AllOfType(schema) {
+	if ("type" in schema && schema.type === "string") return false;
+	return "allOf" in schema;
+}
+/**
+* Type guard for {@link JsonSchema7ObjectType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7ObjectType}, false otherwise
+*/
+function isJsonSchema7ObjectType(schema) {
+	if ("type" in schema && schema.type === "object") return false;
+	return "properties" in schema;
+}
+/**
+* Type guard for {@link JsonSchema7ArrayType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7ArrayType}, false otherwise
+*/
+function isJsonSchema7ArrayType(schema) {
+	return "type" in schema && schema.type === "array" && "items" in schema;
+}
+/**
+* Type guard for {@link JsonSchema7PrimitiveLiteralType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7PrimitiveLiteralType}, false otherwise
+*/
+function isJsonSchema7PrimitiveLiteralType(schema) {
+	if (!("type" in schema)) return false;
+	const { type } = schema;
+	return (type === "string" || type === "number" || type === "integer" || type === "boolean") && "const" in schema;
+}
+/**
+* Type guard for {@link JsonSchema7LiteralType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7LiteralType}, false otherwise
+*/
+function isJsonSchema7LiteralType(schema) {
+	if (isJsonSchema7PrimitiveLiteralType(schema)) return true;
+	if (!("type" in schema)) return false;
+	return schema.type === "object" || schema.type === "array";
+}
+/**
+* Type guard to check if a value is a {@link StandardJSONSchemaV1 | Standard JSON Schema}.
+*
+* @remarks
+* This function checks if the value has the structure of a Standard JSON Schema, which includes a `~standard` property with a `jsonSchema` object that has `input` and `output` functions.
+*
+* @see https://standardschema.dev/json-schema
+*
+* @param value - The value to check.
+* @returns True if the value is a {@link StandardJSONSchemaV1 | Standard JSON Schema}, false otherwise.
+*/
+function isStandardJsonSchema(value) {
+	return isSetObject(value) && "~standard" in value && isSetObject(value["~standard"]) && "jsonSchema" in value["~standard"] && isSetObject(value["~standard"].jsonSchema) && "input" in value["~standard"].jsonSchema && isFunction(value["~standard"].jsonSchema.input) && "output" in value["~standard"].jsonSchema && isFunction(value["~standard"].jsonSchema.output);
+}
+
+//#endregion
+export { isJsonSchema7PrimitiveLiteralType as a, isJsonSchema7ObjectType as i, isJsonSchema7ArrayType as n, isStandardJsonSchema as o, isJsonSchema7LiteralType as r, isJsonSchema7AllOfType as t };
+//# sourceMappingURL=schema-DGmzxHja.mjs.map

package/dist/schema-DGmzxHja.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-DGmzxHja.mjs","names":[],"sources":["../src/schema.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 { StandardJSONSchemaV1 } from \"@standard-schema/spec\";\nimport { isFunction } from \"@stryke/type-checks/is-function\";\nimport { isSetObject } from \"@stryke/type-checks/is-set-object\";\nimport type {\n  JsonSchema7AllOfType,\n  JsonSchema7ArrayType,\n  JsonSchema7LiteralType,\n  JsonSchema7ObjectType,\n  JsonSchema7PrimitiveLiteralType,\n  JsonSchema7StringType,\n  JsonSchema7Type\n} from \"./types\";\n\n/**\n * Type guard for {@link JsonSchema7AllOfType}\n *\n * @param schema - The schema to check\n * @returns True if the schema is a {@link JsonSchema7AllOfType}, false otherwise\n */\nexport function isJsonSchema7AllOfType(\n  schema: JsonSchema7Type | JsonSchema7StringType\n): schema is JsonSchema7AllOfType {\n  if (\"type\" in schema && schema.type === \"string\") {\n    return false;\n  }\n\n  return \"allOf\" in schema;\n}\n\n/**\n * Type guard for {@link JsonSchema7ObjectType}\n *\n * @param schema - The schema to check\n * @returns True if the schema is a {@link JsonSchema7ObjectType}, false otherwise\n */\nexport function isJsonSchema7ObjectType(\n  schema: JsonSchema7Type | JsonSchema7StringType\n): schema is JsonSchema7ObjectType {\n  if (\"type\" in schema && schema.type === \"object\") {\n    return false;\n  }\n\n  return \"properties\" in schema;\n}\n\n/**\n * Type guard for {@link JsonSchema7ArrayType}\n *\n * @param schema - The schema to check\n * @returns True if the schema is a {@link JsonSchema7ArrayType}, false otherwise\n */\nexport function isJsonSchema7ArrayType(\n  schema: JsonSchema7Type\n): schema is JsonSchema7ArrayType {\n  return \"type\" in schema && schema.type === \"array\" && \"items\" in schema;\n}\n\n/**\n * Type guard for {@link JsonSchema7PrimitiveLiteralType}\n *\n * @param schema - The schema to check\n * @returns True if the schema is a {@link JsonSchema7PrimitiveLiteralType}, false otherwise\n */\nexport function isJsonSchema7PrimitiveLiteralType(\n  schema: JsonSchema7Type\n): schema is JsonSchema7PrimitiveLiteralType {\n  if (!(\"type\" in schema)) {\n    return false;\n  }\n\n  const { type } = schema;\n\n  return (\n    (type === \"string\" ||\n      type === \"number\" ||\n      type === \"integer\" ||\n      type === \"boolean\") &&\n    \"const\" in schema\n  );\n}\n\n/**\n * Type guard for {@link JsonSchema7LiteralType}\n *\n * @param schema - The schema to check\n * @returns True if the schema is a {@link JsonSchema7LiteralType}, false otherwise\n */\nexport function isJsonSchema7LiteralType(\n  schema: JsonSchema7Type\n): schema is JsonSchema7LiteralType {\n  if (isJsonSchema7PrimitiveLiteralType(schema)) {\n    return true;\n  }\n\n  if (!(\"type\" in schema)) {\n    return false;\n  }\n\n  return schema.type === \"object\" || schema.type === \"array\";\n}\n\n/**\n * Type guard to check if a value is a {@link StandardJSONSchemaV1 | Standard JSON Schema}.\n *\n * @remarks\n * This function checks if the value has the structure of a Standard JSON Schema, which includes a `~standard` property with a `jsonSchema` object that has `input` and `output` functions.\n *\n * @see https://standardschema.dev/json-schema\n *\n * @param value - The value to check.\n * @returns True if the value is a {@link StandardJSONSchemaV1 | Standard JSON Schema}, false otherwise.\n */\nexport function isStandardJsonSchema<Input = unknown, Output = Input>(\n  value: any\n): value is StandardJSONSchemaV1<Input, Output> {\n  return (\n    isSetObject(value) &&\n    \"~standard\" in value &&\n    isSetObject(value[\"~standard\"]) &&\n    \"jsonSchema\" in value[\"~standard\"] &&\n    isSetObject(value[\"~standard\"].jsonSchema) &&\n    \"input\" in value[\"~standard\"].jsonSchema &&\n    isFunction(value[\"~standard\"].jsonSchema.input) &&\n    \"output\" in value[\"~standard\"].jsonSchema &&\n    isFunction(value[\"~standard\"].jsonSchema.output)\n  );\n}\n"],"mappings":";;;;;;;;;AAqCA,SAAgB,uBACd,QACgC;AAChC,KAAI,UAAU,UAAU,OAAO,SAAS,SACtC,QAAO;AAGT,QAAO,WAAW;;;;;;;;AASpB,SAAgB,wBACd,QACiC;AACjC,KAAI,UAAU,UAAU,OAAO,SAAS,SACtC,QAAO;AAGT,QAAO,gBAAgB;;;;;;;;AASzB,SAAgB,uBACd,QACgC;AAChC,QAAO,UAAU,UAAU,OAAO,SAAS,WAAW,WAAW;;;;;;;;AASnE,SAAgB,kCACd,QAC2C;AAC3C,KAAI,EAAE,UAAU,QACd,QAAO;CAGT,MAAM,EAAE,SAAS;AAEjB,SACG,SAAS,YACR,SAAS,YACT,SAAS,aACT,SAAS,cACX,WAAW;;;;;;;;AAUf,SAAgB,yBACd,QACkC;AAClC,KAAI,kCAAkC,OAAO,CAC3C,QAAO;AAGT,KAAI,EAAE,UAAU,QACd,QAAO;AAGT,QAAO,OAAO,SAAS,YAAY,OAAO,SAAS;;;;;;;;;;;;;AAcrD,SAAgB,qBACd,OAC8C;AAC9C,QACE,YAAY,MAAM,IAClB,eAAe,SACf,YAAY,MAAM,aAAa,IAC/B,gBAAgB,MAAM,gBACtB,YAAY,MAAM,aAAa,WAAW,IAC1C,WAAW,MAAM,aAAa,cAC9B,WAAW,MAAM,aAAa,WAAW,MAAM,IAC/C,YAAY,MAAM,aAAa,cAC/B,WAAW,MAAM,aAAa,WAAW,OAAO"}

package/dist/schema-Dl018Aq4.cjs

@@ -0,0 +1,106 @@
+const require_is_set_object = require('./is-set-object-BmHip9em.cjs');
+
+//#region src/schema.ts
+/**
+* Type guard for {@link JsonSchema7AllOfType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7AllOfType}, false otherwise
+*/
+function isJsonSchema7AllOfType(schema) {
+	if ("type" in schema && schema.type === "string") return false;
+	return "allOf" in schema;
+}
+/**
+* Type guard for {@link JsonSchema7ObjectType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7ObjectType}, false otherwise
+*/
+function isJsonSchema7ObjectType(schema) {
+	if ("type" in schema && schema.type === "object") return false;
+	return "properties" in schema;
+}
+/**
+* Type guard for {@link JsonSchema7ArrayType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7ArrayType}, false otherwise
+*/
+function isJsonSchema7ArrayType(schema) {
+	return "type" in schema && schema.type === "array" && "items" in schema;
+}
+/**
+* Type guard for {@link JsonSchema7PrimitiveLiteralType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7PrimitiveLiteralType}, false otherwise
+*/
+function isJsonSchema7PrimitiveLiteralType(schema) {
+	if (!("type" in schema)) return false;
+	const { type } = schema;
+	return (type === "string" || type === "number" || type === "integer" || type === "boolean") && "const" in schema;
+}
+/**
+* Type guard for {@link JsonSchema7LiteralType}
+*
+* @param schema - The schema to check
+* @returns True if the schema is a {@link JsonSchema7LiteralType}, false otherwise
+*/
+function isJsonSchema7LiteralType(schema) {
+	if (isJsonSchema7PrimitiveLiteralType(schema)) return true;
+	if (!("type" in schema)) return false;
+	return schema.type === "object" || schema.type === "array";
+}
+/**
+* Type guard to check if a value is a {@link StandardJSONSchemaV1 | Standard JSON Schema}.
+*
+* @remarks
+* This function checks if the value has the structure of a Standard JSON Schema, which includes a `~standard` property with a `jsonSchema` object that has `input` and `output` functions.
+*
+* @see https://standardschema.dev/json-schema
+*
+* @param value - The value to check.
+* @returns True if the value is a {@link StandardJSONSchemaV1 | Standard JSON Schema}, false otherwise.
+*/
+function isStandardJsonSchema(value) {
+	return require_is_set_object.isSetObject(value) && "~standard" in value && require_is_set_object.isSetObject(value["~standard"]) && "jsonSchema" in value["~standard"] && require_is_set_object.isSetObject(value["~standard"].jsonSchema) && "input" in value["~standard"].jsonSchema && require_is_set_object.isFunction(value["~standard"].jsonSchema.input) && "output" in value["~standard"].jsonSchema && require_is_set_object.isFunction(value["~standard"].jsonSchema.output);
+}
+
+//#endregion
+Object.defineProperty(exports, 'isJsonSchema7AllOfType', {
+  enumerable: true,
+  get: function () {
+    return isJsonSchema7AllOfType;
+  }
+});
+Object.defineProperty(exports, 'isJsonSchema7ArrayType', {
+  enumerable: true,
+  get: function () {
+    return isJsonSchema7ArrayType;
+  }
+});
+Object.defineProperty(exports, 'isJsonSchema7LiteralType', {
+  enumerable: true,
+  get: function () {
+    return isJsonSchema7LiteralType;
+  }
+});
+Object.defineProperty(exports, 'isJsonSchema7ObjectType', {
+  enumerable: true,
+  get: function () {
+    return isJsonSchema7ObjectType;
+  }
+});
+Object.defineProperty(exports, 'isJsonSchema7PrimitiveLiteralType', {
+  enumerable: true,
+  get: function () {
+    return isJsonSchema7PrimitiveLiteralType;
+  }
+});
+Object.defineProperty(exports, 'isStandardJsonSchema', {
+  enumerable: true,
+  get: function () {
+    return isStandardJsonSchema;
+  }
+});

package/dist/schema.cjs

@@ -0,0 +1,8 @@
+const require_schema = require('./schema-Dl018Aq4.cjs');
+
+exports.isJsonSchema7AllOfType = require_schema.isJsonSchema7AllOfType;
+exports.isJsonSchema7ArrayType = require_schema.isJsonSchema7ArrayType;
+exports.isJsonSchema7LiteralType = require_schema.isJsonSchema7LiteralType;
+exports.isJsonSchema7ObjectType = require_schema.isJsonSchema7ObjectType;
+exports.isJsonSchema7PrimitiveLiteralType = require_schema.isJsonSchema7PrimitiveLiteralType;
+exports.isStandardJsonSchema = require_schema.isStandardJsonSchema;

package/dist/schema.d.cts

@@ -0,0 +1,2 @@
+import { a as isJsonSchema7PrimitiveLiteralType, i as isJsonSchema7ObjectType, n as isJsonSchema7ArrayType, o as isStandardJsonSchema, r as isJsonSchema7LiteralType, t as isJsonSchema7AllOfType } from "./schema-BO1HCrxv.cjs";
+export { isJsonSchema7AllOfType, isJsonSchema7ArrayType, isJsonSchema7LiteralType, isJsonSchema7ObjectType, isJsonSchema7PrimitiveLiteralType, isStandardJsonSchema };

package/dist/schema.d.mts

@@ -0,0 +1,3 @@
+import "./types-CPQlxauZ.mjs";
+import { a as isJsonSchema7PrimitiveLiteralType, i as isJsonSchema7ObjectType, n as isJsonSchema7ArrayType, o as isStandardJsonSchema, r as isJsonSchema7LiteralType, t as isJsonSchema7AllOfType } from "./schema-CmH1V_uI.mjs";
+export { isJsonSchema7AllOfType, isJsonSchema7ArrayType, isJsonSchema7LiteralType, isJsonSchema7ObjectType, isJsonSchema7PrimitiveLiteralType, isStandardJsonSchema };

package/dist/schema.mjs

@@ -0,0 +1,3 @@
+import { a as isJsonSchema7PrimitiveLiteralType, i as isJsonSchema7ObjectType, n as isJsonSchema7ArrayType, o as isStandardJsonSchema, r as isJsonSchema7LiteralType, t as isJsonSchema7AllOfType } from "./schema-DGmzxHja.mjs";
+
+export { isJsonSchema7AllOfType, isJsonSchema7ArrayType, isJsonSchema7LiteralType, isJsonSchema7ObjectType, isJsonSchema7PrimitiveLiteralType, isStandardJsonSchema };

package/dist/storm-json-8F9CKpXu.d.mts

@@ -0,0 +1,70 @@
+import { U as JsonSerializeOptions, W as JsonValue, d as JsonParserResult, l as JsonParseOptions, t as Class } from "./types-CPQlxauZ.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-8F9CKpXu.d.mts.map

package/dist/storm-json-8F9CKpXu.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storm-json-8F9CKpXu.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-BD6WFbrI.cjs

@@ -0,0 +1,154 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const require_is_object = require('./is-object-umGh91v1.cjs');
+const require_is_string = require('./is-string-C2RK4Gjs.cjs');
+const require_parse = require('./parse-ByDxRup5.cjs');
+const require_parse_error = require('./parse-error-N7UE-HMh.cjs');
+const require_stringify = require('./stringify-BehjrfhS.cjs');
+let jsonc_parser = require("jsonc-parser");
+let node_buffer = require("node:buffer");
+let superjson = require("superjson");
+superjson = __toESM(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.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_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_stringify.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 = (0, jsonc_parser.parse)(strData, errors, {
+			allowTrailingComma: true,
+			...options
+		});
+		if (errors.length > 0 && errors[0]) throw new Error(require_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) => typeof node_buffer.Buffer.isBuffer === "function" && node_buffer.Buffer.isBuffer(v),
+	serialize: (v) => v.toString("base64"),
+	deserialize: (v) => node_buffer.Buffer.from(v, "base64")
+}, "Bytes");
+
+//#endregion
+Object.defineProperty(exports, 'StormJSON', {
+  enumerable: true,
+  get: function () {
+    return StormJSON;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

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

@@ -0,0 +1,70 @@
+import { U as JsonSerializeOptions, W as JsonValue, d as JsonParserResult, l as JsonParseOptions, t as Class } from "./types-Bn8rC098.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-DvIEWMEH.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"storm-json-DvIEWMEH.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-nkhJgTz4.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-Dn43ZK9y.mjs";
+import { t as formatParseError } from "./parse-error-Af4zHUQ_.mjs";
+import { n as stringify } from "./stringify-CYHjAvWm.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-nkhJgTz4.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"storm-json-nkhJgTz4.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"}