json-with-bigint 2.4.2 → 3.1.0

package/README.md

@@ -8,7 +8,7 @@ JS library that allows you to easily serialize and deserialize data with BigInt
 
 1. You need to convert some data to/from JSON and it includes BigInt values
 2. Native JSON.stringify() and JSON.parse() methods in JS can't work with BigInt
-3. Other libraries and pieces of code that you'll find either can't solve this problem while supporting consistent round-trip operations (meaning, you will not get the same BigInt values if you serialize and then deserialize them) or requires you to change your JSON or the way you want to work with your data
+3. Other libraries and pieces of code that you'll find either can't solve this problem while supporting consistent round-trip operations (meaning, you will not get the same BigInt values if you serialize and then deserialize them) or requires you to specify which properties in JSON include BigInt values, or to change your JSON or the way you want to work with your data
 
 ## Good things about JSON-with-BigInt
 
@@ -20,9 +20,13 @@ JSONStringify(data) // '{"bigNumber":9007199254740992}'
 JSONParse(JSONStringify(data)).bigNumber === 9007199254740992n // true
 ```
 
+✔️ No need to specify which properties in JSON include BigInt values. Library will find them itself
+
 ✔️ No need to change your JSON or the way you want to work with your data
 
-✔️ Parses and stringifies all other values other than big numbers the same way as native JSON methods in JS do
+✔️ You don't have to memorize this library's API, you already know it. Just skip the dot, use camelCase and that's it (JSONParse(), JSONStringify())
+
+✔️ Parses and stringifies all other values other than big numbers the same way as native JSON methods in JS do. You can just replace every `JSON.parse` and `JSON.stringify` call in your project with functions from this library and it'll work.
 
 ✔️ Correctly parses float numbers and negative numbers
 
@@ -30,14 +34,16 @@ JSONParse(JSONStringify(data)).bigNumber === 9007199254740992n // true
 
 ✔️ Does not contaminate your global space (unlike monkey-patching solution)
 
-✔️ You don't have to memorize this library's API, you already know it. Just skip the dot, use camelCase and that's it (JSONParse(), JSONStringify())
-
 ✔️ Can be used in both JavaScript and TypeScript projects (.d.ts file included)
 
-✔️ Size: 762 bytes (minified and gzipped)
+✔️ Can be used as both ESM and CommonJS module
+
+✔️ Size: 624 bytes (minified and gzipped)
 
 ✔️ No dependencies
 
+✔️ Covered by tests
+
 ## Getting Started
 
 This library has no default export. [Why it's a good thing](https://humanwhocodes.com/blog/2019/01/stop-using-default-exports-javascript-module/)

package/__tests__/performance.js

@@ -0,0 +1,141 @@
+// ------ Performance tests ------
+const { performance } = require("perf_hooks");
+const { JSONParse, JSONStringify } = require("../json-with-bigint.cjs");
+
+const fs = require("fs").promises;
+const https = require("https");
+
+// JSON is located in a separate GitHub repo here (click Raw to see the URL below):
+// https://github.com/Ivan-Korolenko/json-with-bigint.performance.json/blob/main/performance.json
+const JSON_URL =
+  "https://raw.githubusercontent.com/Ivan-Korolenko/json-with-bigint.performance.json/refs/heads/main/performance.json";
+const JSON_LOCAL_FILEPATH = "__tests__/performance.json";
+
+async function fetchJSON(url, maxRetries = 3, delay = 1000) {
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await new Promise((resolve, reject) => {
+        https
+          .get(url, (res) => {
+            if (res.statusCode >= 500 && res.statusCode < 600) {
+              reject(new Error(`Server error ${res.statusCode}: Retrying...`));
+            } else if (res.statusCode !== 200) {
+              reject(
+                new Error(
+                  `Request failed with status ${res.statusCode} ${res.statusMessage}`
+                )
+              );
+            }
+
+            let data = "";
+            res.on("data", (chunk) => {
+              data += chunk;
+            });
+            res.on("end", () => resolve(data));
+          })
+          .on("error", reject);
+      });
+
+      return JSON.parse(response);
+    } catch (error) {
+      if (attempt < maxRetries) {
+        console.warn(`Attempt ${attempt} failed: ${error.message}`);
+        await new Promise((res) =>
+          setTimeout(res, delay * Math.pow(2, attempt - 1))
+        ); // Exponential backoff
+      } else {
+        console.error("Max retries reached. Fetch failed:", error);
+        throw error;
+      }
+    }
+  }
+}
+
+async function saveJSONToFile(filePath, data) {
+  try {
+    const jsonString = JSON.stringify(data, null, 2);
+    const tempPath = `${filePath}.tmp`;
+
+    await fs.writeFile(tempPath, jsonString, "utf8");
+    await fs.rename(tempPath, filePath); // Atomic write
+    console.log(`✅ JSON data saved to ${filePath}`);
+  } catch (error) {
+    console.error("Error saving JSON to file:", error);
+    throw error;
+  }
+}
+
+async function fetchAndSaveJSON(url, filePath) {
+  try {
+    const jsonData = await fetchJSON(url);
+
+    await saveJSONToFile(filePath, jsonData);
+  } catch (error) {
+    console.error("❌ Operation failed:", error);
+  }
+}
+
+// If the file was downloaded earlier, use it. Otherwise, download
+// After n attempts, give up and throw an error
+async function readPerformanceJSON(
+  filePath,
+  encoding,
+  maxAttempts = 3,
+  attempt = 0
+) {
+  if (attempt === maxAttempts)
+    throw new Error(
+      `Reading performance JSON failed after ${attempt} attempts. Check download URL, file availability on that URL, and local filepath`
+    );
+
+  try {
+    const data = await fs.readFile(filePath, encoding);
+
+    return data;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      console.log(
+        `File not found. Downloading... (Attempt ${attempt + 1}/${maxAttempts})`
+      );
+      await fetchAndSaveJSON(JSON_URL, filePath);
+
+      return await readPerformanceJSON(
+        filePath,
+        encoding,
+        maxAttempts,
+        attempt + 1
+      );
+    } else {
+      console.error("Error reading file:", error);
+      throw error; // Re-throw to avoid silent failures
+    }
+  }
+}
+
+const measureExecTime = (fn) => {
+  const startTime = performance.now();
+
+  fn();
+
+  const endTime = performance.now();
+
+  console.log("Time: ", endTime - startTime);
+};
+
+async function main() {
+  const data = await readPerformanceJSON(JSON_LOCAL_FILEPATH, "utf8");
+
+  measureExecTime(() => {
+    console.log("___________");
+    console.log("Performance test. One-way");
+    JSONParse(data);
+  });
+
+  measureExecTime(() => {
+    console.log("___________");
+    console.log("Performance test. Round-trip");
+    JSONStringify(JSONParse(data));
+  });
+}
+
+main();

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.2",
+  "version": "3.1.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"