json-with-bigint 2.4.1 → 3.0.0

package/__tests__/unit.js

@@ -0,0 +1,137 @@
+// ------ Unit tests ------
+const assert = require("assert");
+const { JSONStringify, JSONParse } = require("../json-with-bigint.cjs");
+
+const test1JSON = `{"zero":9007199254740998,"one":-42,"two":-9007199254740998,"test":["He was\\":[-23432432432434324324324324]",111,9007199254740998,{"test2":-9007199254740998}],"test3":["He was:[-23432432432434324324324324]",111,9007199254740998,{"test2":-9007199254740998,"float":1.9007199254740998,"float2":0.1,"float3":2.9007199254740996,"int":1,"int2":3243243432432434324324324}],"float4":[1.9007199254740998,1111111111111111111111111111111111,0.1,1,54354654654654654654656546546546546]}`;
+const test1Obj = {
+  zero: 9007199254740998n,
+  one: -42,
+  two: -9007199254740998n,
+  test: [
+    'He was":[-23432432432434324324324324]',
+    111,
+    9007199254740998n,
+    { test2: -9007199254740998n },
+  ],
+  test3: [
+    "He was:[-23432432432434324324324324]",
+    111,
+    9007199254740998n,
+    {
+      test2: -9007199254740998n,
+      float: 1.9007199254740998,
+      float2: 0.1,
+      float3: 2.9007199254740996,
+      int: 1,
+      int2: 3243243432432434324324324n,
+    },
+  ],
+  float4: [
+    1.9007199254740998,
+    1111111111111111111111111111111111n,
+    0.1,
+    1,
+    54354654654654654654656546546546546n,
+  ],
+};
+
+const test2JSON = `{
+  "test": [
+      {
+          "ID": 1035342667379599058,
+          "Timestamp": "2022-09-13 22:21:25",
+          "Contents": "broken example message",
+          "Contents2": "broken example 1035342667379599058 message",
+          "Contents3": "broken example [1035342667379599058, 1035342667379599058] message",
+          "Attachments": "",
+          "BreakingValue": 54354654654654654654656546546546546
+      },
+      1035342667379599058,
+      -1.1035342667379599058,
+      1035342667379599058
+  ],
+  "test2": {
+          "1035342667379599058": 1035342667379599058
+  }
+}`;
+// Special case, because native JSON.parse strips \n and whitespaces.
+// So technically, a true round-trip operation (including all spaces, etc.) is not possible in the case of pretty JSON without writing your own full JSON.parse implementation for this particular case.
+// In practice, though, it shouldn't cause any problems, because data will work fine even in that case, and if the backend expects a prettified JSON, you can just prettify it before sending it.
+const test2TersedJSON = `{"test":[{"ID":1035342667379599058,"Timestamp":"2022-09-13 22:21:25","Contents":"broken example message","Contents2":"broken example 1035342667379599058 message","Contents3":"broken example [1035342667379599058, 1035342667379599058] message","Attachments":"","BreakingValue":54354654654654654654656546546546546},1035342667379599058,-1.10353426673796,1035342667379599058],"test2":{"1035342667379599058":1035342667379599058}}`;
+const test2Obj = {
+  test: [
+    {
+      ID: 1035342667379599058n,
+      Timestamp: "2022-09-13 22:21:25",
+      Contents: "broken example message",
+      Contents2: "broken example 1035342667379599058 message",
+      Contents3:
+        "broken example [1035342667379599058, 1035342667379599058] message",
+      Attachments: "",
+      BreakingValue: 54354654654654654654656546546546546n,
+    },
+    1035342667379599058n,
+    -1.10353426673796,
+    1035342667379599058n,
+  ],
+  test2: { "1035342667379599058": 1035342667379599058n },
+};
+
+const test3JSON = `{"items":[{"message":"some text 17365091955960356025, some text"}]}`;
+const test3Obj = {
+  items: [{ message: "some text 17365091955960356025, some text" }],
+};
+
+const test4JSON = `9007199254740998`;
+const test4Obj = 9007199254740998n;
+
+const test5JSON = `[9007199254740998,[9007199254740998],9007199254740998]`;
+const test5Obj = [9007199254740998n, [9007199254740998n], 9007199254740998n];
+
+const test6JSON = `[9007199254740998]`;
+const test6Obj = [9007199254740998n];
+
+const test7JSON = `["0a","1b","9n","9nn",90071992547409981111,"90071992547409981111.5n"]`;
+const test7Obj = [
+  "0a",
+  "1b",
+  "9n",
+  "9nn",
+  90071992547409981111n,
+  "90071992547409981111.5n",
+];
+
+assert.deepStrictEqual(JSONParse(test1JSON), test1Obj);
+console.log("1 test parsing passed");
+assert.deepStrictEqual(JSONStringify(JSONParse(test1JSON)), test1JSON);
+console.log("1 test round-trip passed");
+
+assert.deepStrictEqual(JSONParse(test2JSON), test2Obj);
+console.log("2 test parsing passed");
+assert.deepStrictEqual(JSONStringify(JSONParse(test2JSON)), test2TersedJSON);
+console.log("2 test round-trip passed");
+
+assert.deepStrictEqual(JSONParse(test3JSON), test3Obj);
+console.log("3 test parsing passed");
+assert.deepStrictEqual(JSONStringify(JSONParse(test3JSON)), test3JSON);
+console.log("3 test round-trip passed");
+
+assert.deepStrictEqual(JSONParse(test4JSON), test4Obj);
+console.log("4 test parsing passed");
+assert.deepStrictEqual(JSONStringify(JSONParse(test4JSON)), test4JSON);
+console.log("4 test round-trip passed");
+
+assert.deepStrictEqual(JSONParse(test5JSON), test5Obj);
+console.log("5 test parsing passed");
+assert.deepStrictEqual(JSONStringify(JSONParse(test5JSON)), test5JSON);
+console.log("5 test round-trip passed");
+
+assert.deepStrictEqual(JSONParse(test6JSON), test6Obj);
+console.log("6 test parsing passed");
+assert.deepStrictEqual(JSONStringify(JSONParse(test6JSON)), test6JSON);
+console.log("6 test round-trip passed");
+
+assert.deepStrictEqual(JSONParse(test7JSON), test7Obj);
+console.log("7 test parsing passed");
+assert.deepStrictEqual(JSONStringify(JSONParse(test7JSON)), test7JSON);
+console.log("7 test round-trip passed");

package/json-with-bigint.cjs

@@ -0,0 +1,84 @@
+const noiseValue = /^-?\d+n+$/; // Noise - strings that match the custom format before being converted to it
+
+/* 
+  Function to serialize data to a JSON string.
+  Converts BigInt values to a custom format (strings with digits and "n" at the end) and then converts them to proper big integers in a JSON string.
+*/
+const JSONStringify = (data, space) => {
+  if (!data) return JSON.stringify(data);
+
+  const bigInts = /([\[:])?"(-?\d+)n"($|[,\}\]])/g;
+  const noise = /([\[:])?("-?\d+n+)n("$|"[,\}\]])/g;
+  const convertedToCustomJSON = JSON.stringify(
+    data,
+    (_, value) => {
+      const isNoise =
+        typeof value === "string" && Boolean(value.match(noiseValue));
+
+      if (isNoise) return value.toString() + "n"; // Mark noise values with additional "n" to offset the deletion of one "n" during the processing
+
+      return typeof value === "bigint" ? value.toString() + "n" : value;
+    },
+    space
+  );
+  const processedJSON = convertedToCustomJSON.replace(bigInts, "$1$2$3"); // Delete one "n" off the end of every BigInt value
+  const denoisedJSON = processedJSON.replace(noise, "$1$2$3"); // Remove one "n" off the end of every noisy string
+
+  return denoisedJSON;
+};
+
+/* 
+  Function to parse JSON.
+  If JSON has number values greater than Number.MAX_SAFE_INTEGER, we convert those values to a custom format, then parse them to BigInt values.
+  Other types of values are not affected and parsed as native JSON.parse() would parse them.
+*/
+const JSONParse = (json) => {
+  if (!json) return JSON.parse(json);
+
+  const MAX_INT = Number.MAX_SAFE_INTEGER.toString();
+  const MAX_DIGITS = MAX_INT.length;
+  const stringsOrLargeNumbers =
+    /"(?:\\.|[^"])*"|-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/g;
+  const noiseValueWithQuotes = /^"-?\d+n+"$/; // Noise - strings that match the custom format before being converted to it
+  const customFormat = /^-?\d+n$/;
+
+  // Find and mark big numbers with "n"
+  const serializedData = json.replace(
+    stringsOrLargeNumbers,
+    (text, digits, fractional, exponential) => {
+      const isString = text[0] === '"';
+      const isNoise = isString && Boolean(text.match(noiseValueWithQuotes));
+
+      if (isNoise) return text.substring(0, text.length - 1) + 'n"'; // Mark noise values with additional "n" to offset the deletion of one "n" during the processing
+
+      const isFractionalOrExponential = fractional || exponential;
+      const isLessThanMaxSafeInt =
+        digits &&
+        (digits.length < MAX_DIGITS ||
+          (digits.length === MAX_DIGITS && digits <= MAX_INT)); // With a fixed number of digits, we can correctly use lexicographical comparison to do a numeric comparison
+
+      if (isString || isFractionalOrExponential || isLessThanMaxSafeInt)
+        return text;
+
+      return '"' + text + 'n"';
+    }
+  );
+
+  // Convert marked big numbers to BigInt
+  return JSON.parse(serializedData, (_, value) => {
+    const isCustomFormatBigInt =
+      typeof value === "string" && Boolean(value.match(customFormat));
+
+    if (isCustomFormatBigInt)
+      return BigInt(value.substring(0, value.length - 1));
+
+    const isNoiseValue =
+      typeof value === "string" && Boolean(value.match(noiseValue));
+
+    if (isNoiseValue) return value.substring(0, value.length - 1); // Remove one "n" off the end of the noisy string
+
+    return value;
+  });
+};
+
+module.exports = { JSONStringify, JSONParse };

package/json-with-bigint.js

@@ -1,58 +1,82 @@
+const noiseValue = /^-?\d+n+$/; // Noise - strings that match the custom format before being converted to it
+
 /* 
-  Function to serialize data to JSON string
-  Converts BigInt values to custom format (strings with digits and "n" at the end) and then converts them to proper big integers in JSON string
+  Function to serialize data to a JSON string.
+  Converts BigInt values to a custom format (strings with digits and "n" at the end) and then converts them to proper big integers in a JSON string.
 */
 export const JSONStringify = (data, space) => {
   if (!data) return JSON.stringify(data);
 
-  const bigInts = /([\[:])?"(-?\d+)n"([,\}\]])/g;
-  const preliminaryJSON = JSON.stringify(
+  const bigInts = /([\[:])?"(-?\d+)n"($|[,\}\]])/g;
+  const noise = /([\[:])?("-?\d+n+)n("$|"[,\}\]])/g;
+  const convertedToCustomJSON = JSON.stringify(
     data,
-    (_, value) => (typeof value === "bigint" ? value.toString() + "n" : value),
+    (_, value) => {
+      const isNoise =
+        typeof value === "string" && Boolean(value.match(noiseValue));
+
+      if (isNoise) return value.toString() + "n"; // Mark noise values with additional "n" to offset the deletion of one "n" during the processing
+
+      return typeof value === "bigint" ? value.toString() + "n" : value;
+    },
     space
   );
-  const finalJSON = preliminaryJSON.replace(bigInts, "$1$2$3");
+  const processedJSON = convertedToCustomJSON.replace(bigInts, "$1$2$3"); // Delete one "n" off the end of every BigInt value
+  const denoisedJSON = processedJSON.replace(noise, "$1$2$3"); // Remove one "n" off the end of every noisy string
 
-  return finalJSON;
+  return denoisedJSON;
 };
 
 /* 
-  Function to parse JSON
-  If JSON has values presented in a lib's custom format (strings with digits and "n" character at the end), we just parse them to BigInt values (for backward compatibility with previous versions of the lib)
-  If JSON has values greater than Number.MAX_SAFE_INTEGER, we convert those values to our custom format, then parse them to BigInt values.
+  Function to parse JSON.
+  If JSON has number values greater than Number.MAX_SAFE_INTEGER, we convert those values to a custom format, then parse them to BigInt values.
   Other types of values are not affected and parsed as native JSON.parse() would parse them.
-
-  Big numbers are found and marked using a Regular Expression with these conditions:
-    
-    1. Before the match there is no . and one of the following is present: 
-      1.1 ":
-      1.2 ":[ 
-      1.3 ":[anyNumberOf(anyCharacters) 
-      1.4 , with no ":"anyNumberOf(anyCharacters) before it
-    All " required in the rule are not escaped. All whitespace and newline characters outside of string values are ignored.
-    
-    2. The match itself has more than 16 digits OR (16 digits and any digit of the number is greater than that of the Number.MAX_SAFE_INTEGER). And it may have a - sign at the start.
-    
-    3. After the match one of the following is present:
-      3.1 , without anyNumberOf(anyCharacters) "} or anyNumberOf(anyCharacters) "] after it
-      3.2 } without " after it 
-      3.3 ] without " after it
-    All whitespace and newline characters outside of string values are ignored.
 */
 export const JSONParse = (json) => {
   if (!json) return JSON.parse(json);
 
-  const numbersBiggerThanMaxInt =
-    /(?<=[^\\]":\n*\s*[\[]?|[^\\]":\n*\s*\[.*[^\.\d*]\n*\s*|(?<![^\\]"\n*\s*:\n*\s*[^\\]".*),\n*\s*)(-?\d{17,}|-?(?:[9](?:[1-9]07199254740991|0[1-9]7199254740991|00[8-9]199254740991|007[2-9]99254740991|007199[3-9]54740991|0071992[6-9]4740991|00719925[5-9]740991|007199254[8-9]40991|0071992547[5-9]0991|00719925474[1-9]991|00719925474099[2-9])))(?=,(?!.*[^\\]"(\n*\s*\}|\n*\s*\]))|\n*\s*\}[^"]?|\n*\s*\][^"])/g;
-  const serializedData = json.replace(numbersBiggerThanMaxInt, `"$1n"`);
+  const MAX_INT = Number.MAX_SAFE_INTEGER.toString();
+  const MAX_DIGITS = MAX_INT.length;
+  const stringsOrLargeNumbers =
+    /"(?:\\.|[^"])*"|-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/g;
+  const noiseValueWithQuotes = /^"-?\d+n+"$/; // Noise - strings that match the custom format before being converted to it
+  const customFormat = /^-?\d+n$/;
+
+  // Find and mark big numbers with "n"
+  const serializedData = json.replace(
+    stringsOrLargeNumbers,
+    (text, digits, fractional, exponential) => {
+      const isString = text[0] === '"';
+      const isNoise = isString && Boolean(text.match(noiseValueWithQuotes));
+
+      if (isNoise) return text.substring(0, text.length - 1) + 'n"'; // Mark noise values with additional "n" to offset the deletion of one "n" during the processing
 
+      const isFractionalOrExponential = fractional || exponential;
+      const isLessThanMaxSafeInt =
+        digits &&
+        (digits.length < MAX_DIGITS ||
+          (digits.length === MAX_DIGITS && digits <= MAX_INT)); // With a fixed number of digits, we can correctly use lexicographical comparison to do a numeric comparison
+
+      if (isString || isFractionalOrExponential || isLessThanMaxSafeInt)
+        return text;
+
+      return '"' + text + 'n"';
+    }
+  );
+
+  // Convert marked big numbers to BigInt
   return JSON.parse(serializedData, (_, value) => {
     const isCustomFormatBigInt =
-      typeof value === "string" && Boolean(value.match(/^-?\d+n$/));
+      typeof value === "string" && Boolean(value.match(customFormat));
 
     if (isCustomFormatBigInt)
       return BigInt(value.substring(0, value.length - 1));
 
+    const isNoiseValue =
+      typeof value === "string" && Boolean(value.match(noiseValue));
+
+    if (isNoiseValue) return value.substring(0, value.length - 1); // Remove one "n" off the end of the noisy string
+
     return value;
   });
 };

package/json-with-bigint.min.js

@@ -1 +1 @@
-export const JSONStringify=(n,t)=>{if(!n)return JSON.stringify(n);return JSON.stringify(n,((n,t)=>"bigint"==typeof t?t.toString()+"n":t),t).replace(/([\[:])?"(-?\d+)n"([,\}\]])/g,"$1$2$3")};export const JSONParse=n=>{if(!n)return JSON.parse(n);const t=n.replace(/(?<=[^\\]":\n*\s*[\[]?|[^\\]":\n*\s*\[.*[^\.\d*]\n*\s*|(?<![^\\]"\n*\s*:\n*\s*[^\\]".*),\n*\s*)(-?\d{17,}|-?(?:[9](?:[1-9]07199254740991|0[1-9]7199254740991|00[8-9]199254740991|007[2-9]99254740991|007199[3-9]54740991|0071992[6-9]4740991|00719925[5-9]740991|007199254[8-9]40991|0071992547[5-9]0991|00719925474[1-9]991|00719925474099[2-9])))(?=,(?!.*[^\\]"(\n*\s*\}|\n*\s*\]))|\n*\s*\}[^"]?|\n*\s*\][^"])/g,'"$1n"');return JSON.parse(t,((n,t)=>"string"==typeof t&&Boolean(t.match(/^-?\d+n$/))?BigInt(t.substring(0,t.length-1)):t))};
+const noiseValue=/^-?\d+n+$/;export const JSONStringify=(n,t)=>{if(!n)return JSON.stringify(n);return JSON.stringify(n,((n,t)=>"string"==typeof t&&Boolean(t.match(noiseValue))||"bigint"==typeof t?t.toString()+"n":t),t).replace(/([\[:])?"(-?\d+)n"($|[,\}\]])/g,"$1$2$3").replace(/([\[:])?("-?\d+n+)n("$|"[,\}\]])/g,"$1$2$3")};export const JSONParse=n=>{if(!n)return JSON.parse(n);const t=Number.MAX_SAFE_INTEGER.toString(),e=t.length,r=/^"-?\d+n+"$/,o=/^-?\d+n$/,i=n.replace(/"(?:\\.|[^"])*"|-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/g,((n,o,i,s)=>{const g='"'===n[0];if(g&&Boolean(n.match(r)))return n.substring(0,n.length-1)+'n"';const a=i||s,l=o&&(o.length<e||o.length===e&&o<=t);return g||a||l?n:'"'+n+'n"'}));return JSON.parse(i,((n,t)=>{if("string"==typeof t&&Boolean(t.match(o)))return BigInt(t.substring(0,t.length-1));return"string"==typeof t&&Boolean(t.match(noiseValue))?t.substring(0,t.length-1):t}))};

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "json-with-bigint",
-  "version": "2.4.1",
+  "version": "3.0.0",
   "description": "JS library that allows you to easily serialize and deserialize data with BigInt values",
   "type": "module",
-  "exports": "./json-with-bigint.js",
+  "exports": {
+    "import": "./json-with-bigint.js",
+    "require": "./json-with-bigint.cjs"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/Ivan-Korolenko/json-with-bigint"