@stryke/json 0.0.1

package/dist/pointer/index.cjs

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _findReference = require("./find-reference.cjs");
+Object.keys(_findReference).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _findReference[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _findReference[key];
+    }
+  });
+});
+var _parse = require("./parse.cjs");
+Object.keys(_parse).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _parse[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _parse[key];
+    }
+  });
+});

package/dist/pointer/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./find-reference";
+export * from "./parse";

package/dist/pointer/index.mjs

@@ -0,0 +1 @@
+export*from"./find-reference";export*from"./parse";

package/dist/pointer/parse.cjs

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.escapePointerSegment = escapePointerSegment;
+exports.formatJsonPointer = formatJsonPointer;
+exports.isRoot = exports.isInteger = void 0;
+exports.isValidIndex = isValidIndex;
+exports.parent = parent;
+exports.parseJsonPointer = parseJsonPointer;
+exports.unescapePointerSegment = unescapePointerSegment;
+var _isNumber = require("@stryke/types/type-checks/is-number");
+const i = /~1/g,
+  s = /~0/g,
+  u = /~/g,
+  c = /\//g;
+function escapePointerSegment(n) {
+  return !n.includes("/") && !n.includes("~") ? n : n.replace(u, "~0").replace(c, "~1");
+}
+function unescapePointerSegment(n) {
+  return n.includes("~") ? n.replace(i, "/").replace(s, "~") : n;
+}
+function parseJsonPointer(n) {
+  return n ? n.slice(1).split("/").map(t => unescapePointerSegment(t)) : [];
+}
+function formatJsonPointer(n) {
+  return isRoot(n) ? "" : "/" + n.map(t => escapePointerSegment(String(t))).join("/");
+}
+const isRoot = n => n.length === 0;
+exports.isRoot = isRoot;
+function parent(n) {
+  if (n.length === 0) throw new Error("NO_PARENT");
+  return n.slice(0, -1);
+}
+function isValidIndex(n) {
+  if ((0, _isNumber.isNumber)(n)) return !0;
+  const t = Number.parseInt(n, 10);
+  return String(t) === n && t >= 0;
+}
+const isInteger = n => {
+  const t = n.length;
+  let r = 0,
+    e;
+  for (; r < t;) {
+    if (e = n.codePointAt(r), e >= 48 && e <= 57) {
+      r++;
+      continue;
+    }
+    return !1;
+  }
+  return !0;
+};
+exports.isInteger = isInteger;

package/dist/pointer/parse.d.ts

@@ -0,0 +1,38 @@
+import type { JsonPointerPath } from "@stryke/types/utility-types/json";
+/**
+ * Escapes a JSON pointer path segment.
+ *
+ * @param segment - JSON pointer path segment.
+ * @returns Escaped JSON pointer path segment.
+ */
+export declare function escapePointerSegment(segment: string): string;
+/**
+ * Unescapes a JSON pointer path segment.
+ *
+ * @param segment - JSON pointer path segment.
+ * @returns Unescaped JSON pointer path segment.
+ */
+export declare function unescapePointerSegment(segment: string): string;
+/**
+ * Convert JSON pointer like "/foo/bar" to array like ["", "foo", "bar"], while
+ * also un-escaping reserved characters.
+ */
+export declare function parseJsonPointer(pointer: string): JsonPointerPath;
+/**
+ * Escape and format a path array like ["", "foo", "bar"] to JSON pointer
+ * like "/foo/bar".
+ */
+export declare function formatJsonPointer(path: JsonPointerPath): string;
+/**
+ * Returns true if JSON Pointer points to root value, false otherwise.
+ */
+export declare const isRoot: (path: string | number) => boolean;
+/**
+ * Returns parent path, e.g. for ['foo', 'bar', 'baz'] returns ['foo', 'bar'].
+ */
+export declare function parent(path: JsonPointerPath): JsonPointerPath;
+/**
+ * Check if path component can be a valid array index.
+ */
+export declare function isValidIndex(index: string | number): boolean;
+export declare const isInteger: (str: string) => boolean;

package/dist/pointer/parse.mjs

@@ -0,0 +1 @@
+import{isNumber as o}from"@stryke/types/type-checks/is-number";const i=/~1/g,s=/~0/g,u=/~/g,c=/\//g;export function escapePointerSegment(n){return!n.includes("/")&&!n.includes("~")?n:n.replace(u,"~0").replace(c,"~1")}export function unescapePointerSegment(n){return n.includes("~")?n.replace(i,"/").replace(s,"~"):n}export function parseJsonPointer(n){return n?n.slice(1).split("/").map(t=>unescapePointerSegment(t)):[]}export function formatJsonPointer(n){return isRoot(n)?"":"/"+n.map(t=>escapePointerSegment(String(t))).join("/")}export const isRoot=n=>n.length===0;export function parent(n){if(n.length===0)throw new Error("NO_PARENT");return n.slice(0,-1)}export function isValidIndex(n){if(o(n))return!0;const t=Number.parseInt(n,10);return String(t)===n&&t>=0}export const isInteger=n=>{const t=n.length;let r=0,e;for(;r<t;){if(e=n.codePointAt(r),e>=48&&e<=57){r++;continue}return!1}return!0};

package/dist/storm-json.cjs

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StormJSON = void 0;
+var _isObject = require("@stryke/types/type-checks/is-object");
+var _isString = require("@stryke/types/type-checks/is-string");
+var _buffer = require("buffer/");
+var _jsoncParser = require("jsonc-parser");
+var _superjson = _interopRequireDefault(require("superjson"));
+var _parseError = require("./utils/parse-error.cjs");
+var _stringify = require("./utils/stringify.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class StormJSON extends _superjson.default {
+  static #e;
+  static get instance() {
+    return StormJSON.#e || (StormJSON.#e = new StormJSON()), StormJSON.#e;
+  }
+  static deserialize(e) {
+    return StormJSON.instance.deserialize(e);
+  }
+  static serialize(e) {
+    return StormJSON.instance.serialize(e);
+  }
+  static parse(e) {
+    return StormJSON.instance.parse(e);
+  }
+  static stringify(e) {
+    const r = StormJSON.instance.customTransformerRegistry.findApplicable(e);
+    let s = e;
+    return r && (s = r.serialize(s)), (0, _stringify.stringify)(s);
+  }
+  static stringifyJson(e, r) {
+    const s = StormJSON.instance.customTransformerRegistry.findApplicable(e);
+    let t = e;
+    return s && (t = s.serialize(t)), (0, _stringify.stringify)(t, r?.spaces ?? 2);
+  }
+  static parseJson(e, r) {
+    try {
+      if (r?.expectComments === !1) return StormJSON.instance.parse(e);
+    } catch {}
+    const s = [],
+      t = {
+        allowTrailingComma: !0,
+        ...r
+      },
+      o = (0, _jsoncParser.parse)(e, s, t);
+    if (s.length > 0 && s[0]) throw new Error((0, _parseError.formatParseError)(e, s[0]));
+    return o;
+  }
+  static register(e, r, s, t) {
+    StormJSON.instance.registerCustom({
+      isApplicable: t,
+      serialize: r,
+      deserialize: s
+    }, e);
+  }
+  static registerClass(e, r) {
+    StormJSON.instance.registerClass(e, {
+      identifier: (0, _isString.isString)(r) ? r : r?.identifier || e.name,
+      allowProps: r && (0, _isObject.isObject)(r) && r?.allowProps && Array.isArray(r.allowProps) ? r.allowProps : ["__typename"]
+    });
+  }
+  constructor() {
+    super({
+      dedupe: !0
+    });
+  }
+}
+exports.StormJSON = StormJSON;
+StormJSON.instance.registerCustom({
+  isApplicable: i => _buffer.Buffer.isBuffer(i),
+  serialize: i => i.toString("base64"),
+  deserialize: i => _buffer.Buffer.from(i, "base64")
+}, "Bytes");

package/dist/storm-json.d.ts

@@ -0,0 +1,71 @@
+import SuperJSON from "superjson";
+import type { Class, JsonParseOptions, JsonParserResult, JsonSerializeOptions, JsonValue } from "./types";
+/**
+ * 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.
+ */
+export 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;
+    /**
+     * Stringify the given value with superjson
+     *
+     */
+    static stringify(obj: any): string;
+    /**
+     * 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 json - Object which should be serialized to JSON
+     * @param options - JSON serialize options
+     * @returns the formatted JSON representation of the object
+     */
+    static stringifyJson(json: any, 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();
+}

package/dist/storm-json.mjs

@@ -0,0 +1 @@
+import{isObject as l}from"@stryke/types/type-checks/is-object";import{isString as c}from"@stryke/types/type-checks/is-string";import{Buffer as a}from"buffer/";import{parse as u}from"jsonc-parser";import p from"superjson";import{formatParseError as f}from"./utils/parse-error";import{stringify as n}from"./utils/stringify";export class StormJSON extends p{static#e;static get instance(){return StormJSON.#e||(StormJSON.#e=new StormJSON),StormJSON.#e}static deserialize(e){return StormJSON.instance.deserialize(e)}static serialize(e){return StormJSON.instance.serialize(e)}static parse(e){return StormJSON.instance.parse(e)}static stringify(e){const r=StormJSON.instance.customTransformerRegistry.findApplicable(e);let s=e;return r&&(s=r.serialize(s)),n(s)}static stringifyJson(e,r){const s=StormJSON.instance.customTransformerRegistry.findApplicable(e);let t=e;return s&&(t=s.serialize(t)),n(t,r?.spaces??2)}static parseJson(e,r){try{if(r?.expectComments===!1)return StormJSON.instance.parse(e)}catch{}const s=[],t={allowTrailingComma:!0,...r},o=u(e,s,t);if(s.length>0&&s[0])throw new Error(f(e,s[0]));return o}static register(e,r,s,t){StormJSON.instance.registerCustom({isApplicable:t,serialize:r,deserialize:s},e)}static registerClass(e,r){StormJSON.instance.registerClass(e,{identifier:c(r)?r:r?.identifier||e.name,allowProps:r&&l(r)&&r?.allowProps&&Array.isArray(r.allowProps)?r.allowProps:["__typename"]})}constructor(){super({dedupe:!0})}}StormJSON.instance.registerCustom({isApplicable:i=>a.isBuffer(i),serialize:i=>i.toString("base64"),deserialize:i=>a.from(i,"base64")},"Bytes");

package/dist/types.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/types.d.ts

@@ -0,0 +1,64 @@
+import type { ParseOptions } from "jsonc-parser";
+export type PrimitiveJsonValue = string | number | boolean | undefined | null;
+export type Class = {
+    new (...args: any[]): any;
+};
+export type JsonValue = PrimitiveJsonValue | JsonArray | JsonObject;
+export type JsonArray = Array<JsonValue>;
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+export type ClassInstance = any;
+export type SerializableJsonValue = symbol | Set<JsonValue> | Map<JsonValue, JsonValue> | undefined | bigint | Date | ClassInstance | RegExp;
+export type Tree<T> = InnerNode<T> | Leaf<T>;
+export type Leaf<T> = [T];
+export type InnerNode<T> = [T, Record<string, Tree<T>>];
+export type PrimitiveTypeAnnotation = "number" | "undefined" | "bigint";
+export type LeafTypeAnnotation = PrimitiveTypeAnnotation | "regexp" | "Date" | "Error" | "URL";
+export type TypedArrayAnnotation = ["typed-array", string];
+export type ClassTypeAnnotation = ["class", string];
+export type SymbolTypeAnnotation = ["symbol", string];
+export type CustomTypeAnnotation = ["custom", string];
+export type SimpleTypeAnnotation = LeafTypeAnnotation | "map" | "set";
+export type CompositeTypeAnnotation = TypedArrayAnnotation | ClassTypeAnnotation | SymbolTypeAnnotation | CustomTypeAnnotation;
+export type TypeAnnotation = SimpleTypeAnnotation | CompositeTypeAnnotation;
+export interface JsonParseOptions extends ParseOptions {
+    /**
+     * Expect JSON with javascript-style
+     *
+     * @defaultValue false
+     */
+    expectComments?: boolean;
+    /**
+     * Disallow javascript-style
+     *
+     * @defaultValue false
+     */
+    disallowComments?: boolean;
+    /**
+     * Allow trailing commas in the JSON content
+     */
+    allowTrailingComma?: boolean;
+}
+export interface JsonSerializeOptions {
+    /**
+     * the whitespaces to add as indentation to make the output more readable.
+     *
+     * @defaultValue 2
+     */
+    spaces?: number;
+}
+export interface JsonParserResult {
+    json: JsonValue;
+    meta?: {
+        values?: Tree<TypeAnnotation> | Record<string, Tree<TypeAnnotation>> | undefined;
+        referentialEqualities?: Record<string, string[]> | [string[]] | [string[], Record<string, string[]>];
+    };
+}
+export interface IJsonParser {
+    parse: <TData = any>(strData: string) => TData;
+    stringify: <TData = any>(data: TData) => string;
+    serialize: (object: JsonValue) => JsonParserResult;
+    deserialize: <TData = any>(payload: JsonParserResult) => TData;
+    register: <TData = any, TJsonValue extends JsonValue = JsonValue>(name: string, serialize: (object: JsonValue) => TJsonValue, deserialize: (payload: TJsonValue) => TData, isApplicable: (data: any) => data is TData) => void;
+}

package/dist/utils/code-frames.cjs

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.codeFrameColumns = codeFrameColumns;
+const p = /\r\n|[\n\r\u2028\u2029]/;
+function N(s, l, a = {}) {
+  const c = {
+      column: 0,
+      line: -1,
+      ...s.start
+    },
+    m = {
+      ...c,
+      ...s.end
+    },
+    {
+      linesAbove: h = 2,
+      linesBelow: f = 3
+    } = a || {},
+    o = c.line,
+    t = c.column,
+    b = m.line,
+    i = m.column;
+  let d = Math.max(o - (h + 1), 0),
+    u = Math.min(l.length, b + f);
+  o === -1 && (d = 0), b === -1 && (u = l.length);
+  const L = b - o,
+    e = {};
+  if (L) for (let n = 0; n <= L; n++) {
+    const r = n + o;
+    if (!t) e[r] = !0;else if (n === 0) {
+      const g = l[r - 1]?.length ?? 0;
+      e[r] = [t, g - t + 1];
+    } else if (n === L) e[r] = [0, i];else {
+      const g = l[r - n]?.length ?? 0;
+      e[r] = [0, g];
+    }
+  } else t === i ? e[o] = t ? [t, 0] : !0 : e[o] = [t, i - t];
+  return {
+    start: d,
+    end: u,
+    markerLines: e
+  };
+}
+function codeFrameColumns(s, l, a = {}) {
+  const c = s.split(p),
+    {
+      start: m,
+      end: h,
+      markerLines: f
+    } = N(l, c, a),
+    o = String(h).length;
+  return (a.highlight ? a.highlight(s) : s).split(p).slice(m, h).map((i, d) => {
+    const u = m + 1 + d,
+      e = ` ${` ${u}`.slice(-o)} | `,
+      n = !!(f[u] ?? !1);
+    if (n) {
+      let r = "";
+      if (Array.isArray(n)) {
+        const g = i.slice(0, Math.max(n[0] - 1, 0)).replace(/[^\t]/g, " "),
+          k = n[1] || 1;
+        r = [`
+ `, e.replace(/\d/g, " "), g, "^".repeat(k)].join("");
+      }
+      return [">", e, i, r].join("");
+    }
+    return ` ${e}${i}`;
+  }).join(`
+`);
+}

package/dist/utils/code-frames.d.ts

@@ -0,0 +1,14 @@
+type Location = {
+    column: number;
+    line: number;
+};
+type NodeLocation = {
+    end?: Location;
+    start?: Location;
+};
+export declare function codeFrameColumns(rawLines: string, loc: NodeLocation, opts?: {
+    linesAbove?: number;
+    linesBelow?: number;
+    highlight?: (rawLines: string) => string;
+}): string;
+export {};

package/dist/utils/code-frames.mjs

@@ -0,0 +1,3 @@
+const p=/\r\n|[\n\r\u2028\u2029]/;function N(s,l,a={}){const c={column:0,line:-1,...s.start},m={...c,...s.end},{linesAbove:h=2,linesBelow:f=3}=a||{},o=c.line,t=c.column,b=m.line,i=m.column;let d=Math.max(o-(h+1),0),u=Math.min(l.length,b+f);o===-1&&(d=0),b===-1&&(u=l.length);const L=b-o,e={};if(L)for(let n=0;n<=L;n++){const r=n+o;if(!t)e[r]=!0;else if(n===0){const g=l[r-1]?.length??0;e[r]=[t,g-t+1]}else if(n===L)e[r]=[0,i];else{const g=l[r-n]?.length??0;e[r]=[0,g]}}else t===i?e[o]=t?[t,0]:!0:e[o]=[t,i-t];return{start:d,end:u,markerLines:e}}export function codeFrameColumns(s,l,a={}){const c=s.split(p),{start:m,end:h,markerLines:f}=N(l,c,a),o=String(h).length;return(a.highlight?a.highlight(s):s).split(p).slice(m,h).map((i,d)=>{const u=m+1+d,e=` ${` ${u}`.slice(-o)} | `,n=!!(f[u]??!1);if(n){let r="";if(Array.isArray(n)){const g=i.slice(0,Math.max(n[0]-1,0)).replace(/[^\t]/g," "),k=n[1]||1;r=[`
+ `,e.replace(/\d/g," "),g,"^".repeat(k)].join("")}return[">",e,i,r].join("")}return` ${e}${i}`}).join(`
+`)}

package/dist/utils/index.cjs

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _codeFrames = require("./code-frames.cjs");
+Object.keys(_codeFrames).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _codeFrames[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _codeFrames[key];
+    }
+  });
+});
+var _parseError = require("./parse-error.cjs");
+Object.keys(_parseError).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _parseError[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _parseError[key];
+    }
+  });
+});
+var _stringify = require("./stringify.cjs");
+Object.keys(_stringify).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _stringify[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _stringify[key];
+    }
+  });
+});
+var _stripComments = require("./strip-comments.cjs");
+Object.keys(_stripComments).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _stripComments[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _stripComments[key];
+    }
+  });
+});

package/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./code-frames";
+export * from "./parse-error";
+export * from "./stringify";
+export * from "./strip-comments";

package/dist/utils/index.mjs

@@ -0,0 +1 @@
+export*from"./code-frames";export*from"./parse-error";export*from"./stringify";export*from"./strip-comments";

package/dist/utils/parse-error.cjs

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatParseError = formatParseError;
+var _jsoncParser = require("jsonc-parser");
+var _linesAndColumns = require("lines-and-columns");
+var _codeFrames = require("./code-frames.cjs");
+function formatParseError(e, t) {
+  const {
+    error: m,
+    offset: s,
+    length: l
+  } = t;
+  let n = new _linesAndColumns.LinesAndColumns(e).locationForIndex(s),
+    r = n?.line ?? 0,
+    o = n?.column ?? 0;
+  return r++, o++, `${(0, _jsoncParser.printParseErrorCode)(m)} in JSON at ${r}:${o}
+` + (0, _codeFrames.codeFrameColumns)(e, {
+    start: {
+      line: r,
+      column: o
+    },
+    end: {
+      line: r,
+      column: o + l
+    }
+  }) + `
+`;
+}

package/dist/utils/parse-error.d.ts

@@ -0,0 +1,9 @@
+import type { ParseError } from "jsonc-parser";
+/**
+ * Nicely formats a JSON error with context
+ *
+ * @param input - JSON content as string
+ * @param parseError - jsonc ParseError
+ * @returns
+ */
+export declare function formatParseError(input: string, parseError: ParseError): string;

package/dist/utils/parse-error.mjs

@@ -0,0 +1,3 @@
+import{printParseErrorCode as i}from"jsonc-parser";import{LinesAndColumns as a}from"lines-and-columns";import{codeFrameColumns as c}from"./code-frames";export function formatParseError(e,t){const{error:m,offset:s,length:l}=t;let n=new a(e).locationForIndex(s),r=n?.line??0,o=n?.column??0;return r++,o++,`${i(m)} in JSON at ${r}:${o}
+`+c(e,{start:{line:r,column:o},end:{line:r,column:o+l}})+`
+`}

package/dist/utils/stringify.cjs

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stringify = void 0;
+var _isNumber = require("@stryke/types/type-checks/is-number");
+const stringify = (r, t = " ") => {
+  const n = (0, _isNumber.isNumber)(t) ? " ".repeat(t) : t;
+  switch (r) {
+    case null:
+      return "!n";
+    case void 0:
+      return "!u";
+    case !0:
+      return "!t";
+    case !1:
+      return "!f";
+  }
+  if (Array.isArray(r)) return `[${n}${r.map(e => stringify(e, n)).join("," + n)}${n}]`;
+  if (r instanceof Uint8Array) return `${r}`;
+  switch (typeof r) {
+    case "number":
+      return `${r}`;
+    case "string":
+      return JSON.stringify(r);
+    case "object":
+      {
+        const e = Object.keys(r);
+        return `{${n}${e.map(s => `${s}${n}=${n}${stringify(r[s], n)}`).join("," + n)}${n}}`;
+      }
+  }
+  return "?";
+};
+exports.stringify = stringify;

package/dist/utils/stringify.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Stringify a value to a JSON-like string.
+ *
+ * @param value - The value to stringify
+ * @param spacing - The spacing to use for the stringification
+ * @returns The stringified value
+ */
+export declare const stringify: (value: unknown, spacing?: string | number) => string;

package/dist/utils/stringify.mjs

@@ -0,0 +1 @@
+import{isNumber as i}from"@stryke/types/type-checks/is-number";export const stringify=(r,t=" ")=>{const n=i(t)?" ".repeat(t):t;switch(r){case null:return"!n";case void 0:return"!u";case!0:return"!t";case!1:return"!f"}if(Array.isArray(r))return`[${n}${r.map(e=>stringify(e,n)).join(","+n)}${n}]`;if(r instanceof Uint8Array)return`${r}`;switch(typeof r){case"number":return`${r}`;case"string":return JSON.stringify(r);case"object":{const e=Object.keys(r);return`{${n}${e.map(s=>`${s}${n}=${n}${stringify(r[s],n)}`).join(","+n)}${n}}`}}return"?"};

package/dist/utils/strip-comments.cjs

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "stripComments", {
+  enumerable: true,
+  get: function () {
+    return _jsoncParser.stripComments;
+  }
+});
+var _jsoncParser = require("jsonc-parser");

package/dist/utils/strip-comments.d.ts

@@ -0,0 +1 @@
+export { stripComments } from "jsonc-parser";

package/dist/utils/strip-comments.mjs

@@ -0,0 +1 @@
+export{stripComments}from"jsonc-parser";