@qubit-ltd/json 1.1.4

package/dist/json.mjs

@@ -0,0 +1,610 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+
+var T$1=Object.defineProperty;var C$1=(t,a)=>T$1(t,"name",{value:a,configurable:!0});/**
+ * https://github.com/jawj/json-custom-numbers
+ * @copyright Copyright (c) 2023 George MacKerron
+ * @license MIT
+ * 
+ * This file implements a non-recursive JSON parser that's intended to
+ * precisely match native `JSON.parse` behaviour but also allow for custom
+ * number parsing.
+ */const v=/[^"\\\u0000-\u001f]*/y,D$1=/-?(0|[1-9][0-9]*)([.][0-9]+)?([eE][-+]?[0-9]+)?|true|false|null/y,
+J=/[ \n\t\r]*$/y,X=/^.{0,32}\n[ \t]/,h=/[ \n\t\r]*/y,j=`........................\
+.........."............./.............................................\\......\b..\
+..\f........
+....\r..	`.split("."),x$1=C$1(()=>new Uint32Array(103),"hlArr"),k=x$1(),m=x$1(),w=x$1(),$=x$1();
+let i=0;for(;i<48;i++)k[i]=m[i]=w[i]=$[i]=65536;for(;i<58;i++)k[i]=(m[i]=(w[i]=($[i]=
+i-48)<<4)<<4)<<4;for(;i<65;i++)k[i]=m[i]=w[i]=$[i]=65536;for(;i<71;i++)k[i]=(m[i]=
+(w[i]=($[i]=i-55)<<4)<<4)<<4;for(;i<97;i++)k[i]=m[i]=w[i]=$[i]=65536;for(;i<103;i++)
+k[i]=(m[i]=(w[i]=($[i]=i-87)<<4)<<4)<<4;function O(t,a=""){if(!(t>=0))return "end\
+ of JSON input";if(t>31&&t<127)return `'${a}${String.fromCharCode(t)}'`;if(t===10)
+return "\\n";if(t===9)return "\\t";const p=t.toString(16),y="0000".slice(p.length)+
+p;return (t>31?`'${a}${String.fromCharCode(t)}' or `:"")+`\\u${y}`}C$1(O,"chDesc");
+function R(t,a){const p=Object.keys(a),y=p.length;for(let d=0;d<y;d++){const n=p[d],
+e=t.call(a,n,a[n]);e!==void 0?a[n]=e:delete a[n];}}C$1(R,"revive");function q$1(t,a,p){
+const y=p===!0?" in array":p===!1?" in object":"",d=t.slice(0,a),n=d.match(/[^\n]{0,69}$/)[0],
+e=n.length<d.length?"..."+n:n,o=a-(d.length-e.length),u=t.slice(a),r=u.match(/[^\n]{0,5}/)[0],
+c=r.length<u.length?r+"...":r,A=e+c,I=" ".repeat(o<1?0:o-1)+"^";return `${y}
+At position ${a} in JSON:
+${A}
+${I}`}C$1(q$1,"errContext");const N={maxDepth:1/0};function K$1(t,a,p,y){var U;typeof t!=
+"string"&&(t=String(t)),typeof a!="function"&&(a=void 0);const d=y===void 0?N.maxDepth:
+typeof y=="number"?y:(U=y.maxDepth)!=null?U:N.maxDepth;let n=0,e,o,u,r,c;function A(l){
+throw new SyntaxError(l+q$1(t,n,u))}C$1(A,"err");function I(){A(`JSON structure too \
+deeply nested (current max depth: ${d})`);}C$1(I,"tooDeep");function b(l){A(`Unexpe\
+cted ${O(e)}, expecting ${l}`);}C$1(b,"expected");function E(){const l=n-1;if(D$1.lastIndex=
+l,D$1.test(t)!==!0&&b("JSON value"),n=D$1.lastIndex,e<102){const g=t.slice(l,n);return p?
+p.call(o,r,g):+g}return e===110?null:e===116}C$1(E,"word");function S(){let l="";e:
+for(;;){v.lastIndex=n,v.test(t);const f=v.lastIndex;for(f>n&&(l+=t.slice(n,f),n=
+f),e=t.charCodeAt(n++);;){switch(e){case 34:return l;case 92:if(e=t.charCodeAt(n++),
+e===117){const s=k[t.charCodeAt(n++)]+m[t.charCodeAt(n++)]+w[t.charCodeAt(n++)]+
+$[t.charCodeAt(n++)];if(s<65536){l+=String.fromCharCode(s);break}A("Invalid \\uXX\
+XX escape in string");}const g=j[e];if(g!==""&&g!==void 0){l+=g;break}A(`Invalid \
+escape sequence: ${O(e,"\\")} in string`);default:e>=0||A("Unterminated string"),
+A(`Invalid unescaped ${O(e)} in string`);}if(e=t.charCodeAt(n),e!==92&&e!==34)continue e;
+n++;}}}C$1(S,"string");e:{do e=t.charCodeAt(n++);while(e<=32&&(e===32||e===10||e===
+13||e===9));switch(e){case 123:d===0&&I(),o={},r=void 0,u=!1;break;case 91:d===0&&
+I(),o=[],r=0,u=!0;break;case 34:c=S();break e;default:c=E();break e}const l=d+d-
+2,f=[],g=X.test(t);let s=0;t:for(;;)if(u===!0)for(;;){g===!0&&s>2&&(h.lastIndex=
+n,h.test(t),n=h.lastIndex);do e=t.charCodeAt(n++);while(e<=32&&(e===32||e===10||
+e===13||e===9));if(e===93){if(a!==void 0&&R(a,o),c=o,s===0)break e;if(o=f[--s],r=
+f[--s],u=typeof r=="number",u===!0){o[r++]=c;continue}else {o[r]=c;continue t}}if(r!==
+0){e!==44&&b("',' or ']' after value"),g===!0&&s>2&&(h.lastIndex=n,h.test(t),n=h.
+lastIndex);do e=t.charCodeAt(n++);while(e<=32&&(e===32||e===10||e===13||e===9))}
+switch(e){case 34:o[r++]=S();continue;case 123:s===l&&I(),f[s++]=r,f[s++]=o,o={},
+r=void 0,u=!1;continue t;case 91:s===l&&I(),f[s++]=r,f[s++]=o,o=[],r=0;continue;default:
+o[r++]=E();}}else for(;;){g===!0&&s>2&&(h.lastIndex=n,h.test(t),n=h.lastIndex);do
+e=t.charCodeAt(n++);while(e<=32&&(e===32||e===10||e===13||e===9));if(e===125){if(a!==
+void 0&&R(a,o),c=o,s===0)break e;if(o=f[--s],r=f[--s],u=typeof r=="number",u===!0){
+o[r++]=c;continue t}else {o[r]=c;continue}}if(r!==void 0){e!==44&&b("',' or '}' a\
+fter value"),g===!0&&s>2&&(h.lastIndex=n,h.test(t),n=h.lastIndex);do e=t.charCodeAt(
+n++);while(e<=32&&(e===32||e===10||e===13||e===9))}e!==34&&b("'}' or double-quot\
+ed key"),r=S();do e=t.charCodeAt(n++);while(e<=32&&(e===32||e===10||e===13||e===
+9));e!==58&&b("':' after key");do e=t.charCodeAt(n++);while(e<=32&&(e===32||e===
+10||e===13||e===9));switch(e){case 34:o[r]=S();continue;case 123:s===l&&I(),f[s++]=
+r,f[s++]=o,o={},r=void 0;continue;case 91:s===l&&I(),f[s++]=r,f[s++]=o,o=[],r=0,
+u=!0;continue t;default:o[r]=E();}}}return J.lastIndex=n,J.test(t)===!1&&A("Unexp\
+ected data after end of JSON input"),a!==void 0&&(c={"":c},R(a,c),c=c[""]),c}C$1(K$1,
+"parse");
+
+var E=Object.defineProperty;var T=Object.getOwnPropertySymbols;var F=Object.prototype.hasOwnProperty,V=Object.prototype.propertyIsEnumerable;var D=(t,e,i)=>e in t?E(t,e,{enumerable:!0,configurable:!0,writable:!0,value:i}):
+t[e]=i,u=(t,e)=>{for(var i in e||(e={}))F.call(e,i)&&D(t,i,e[i]);if(T)for(var i of T(
+e))V.call(e,i)&&D(t,i,e[i]);return t};var K=(t,e)=>E(t,"name",{value:e,configurable:!0});/**
+ * https://github.com/jawj/json-custom-numbers
+ * @copyright Copyright (c) 2023 George MacKerron
+ * @license MIT
+ * 
+ * This file implements a non-recursive JSON stringifier that's intended to
+ * precisely match native `JSON.stringify` behaviour but also allow for custom
+ * stringifying of numbers.
+ */const x=/["\\\u0000-\u001f]/,q=Object.prototype.hasOwnProperty,z={maxDepth:5e4,
+skipToJSON:!1};function C(t,e,i,j,g={}){typeof g=="number"&&(g={maxDepth:g}),g=u(
+u({},z),g);const{maxDepth:J,skipToJSON:L}=g;let O,S;e!==void 0&&(typeof e=="func\
+tion"?O=e:Array.isArray(e)&&(S=e.map(l=>String(l)))),i!==void 0&&(i=typeof i=="s\
+tring"?i.slice(0,10):typeof i=="number"?"          ".slice(0,i):void 0);const P=J*
+(i===void 0?5:6);let r,s={"":t},d=0,c=[""],h=!1,k=1,f=[],n=0,y="",b=`
+`,o,p=new Set([]);do{if(d===k){p.delete(s),i!==void 0&&(b=f[--n],y+=b),y+=c===void 0?
+"]":"}",k=f[--n],h=f[--n],c=f[--n],d=f[--n],s=f[--n];continue}let l,w;c===void 0?
+(r=String(d),t=s[d]):(r=c[d],t=s[r]);let a=typeof t;if(L===!1&&t&&a==="object"&&
+typeof t.toJSON=="function"&&(t=t.toJSON(r),a=typeof t),O!==void 0&&(t=O.call(s,
+r,t),a=typeof t),j===void 0||(o=j(r,t,a))===void 0)switch(a){case"string":o=x.test(
+t)?JSON.stringify(t):'"'+t+'"';break;case"number":o=isFinite(t)?String(t):"null";
+break;case"boolean":o=t===!0?"true":"false";break;case"object":if(t===null){o="n\
+ull";break}if(Array.isArray(t)){const m=t.length;m===0?o="[]":(o="[",l=void 0,w=
+m);break}const N=S===void 0?Object.keys(t):S.filter(m=>q.call(t,m)),A=N.length;A===
+0?o="{}":(o="{",l=N,w=A);break;case"bigint":throw new TypeError("Do not know how\
+ to serialize a BigInt: please provide a custom serializer function");default:o=
+void 0;}if(c===void 0?(d>0&&(y+=","),i!==void 0&&(y+=b),y+=o===void 0?"null":o):o!==
+void 0&&(h?y+=",":h=!0,n>0&&(y+=i===void 0?(x.test(r)?JSON.stringify(r):'"'+r+'"')+
+":":b+(x.test(r)?JSON.stringify(r):'"'+r+'"')+": "),y+=o),d++,w!==void 0){if(f[n++]=
+s,f[n++]=d,f[n++]=c,f[n++]=h,f[n++]=k,i!==void 0&&(f[n++]=b,b+=i),s=t,d=0,c=l,h=
+!1,k=w,n>P)throw new RangeError(`Maximum nesting depth exceeded (current maximum\
+ is ${J})`);if(p.has(s))throw new TypeError("Cannot stringify circular structure");
+p.add(s);}}while(n!==0);return y||void 0}K(C,"stringify");
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//    Copyright (c) 2022 - 2024.
+//    Haixing Hu, Qubit Co. Ltd.
+//
+//    All rights reserved.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A regular expression for testing whether a string represents an integer.
+ *
+ * @type {RegExp}
+ * @private
+ */
+var INTEGER_REGEX = /^[+-]?\d+$/;
+
+/**
+ * Test whether a string represents an integer.
+ *
+ * @param value
+ *     The string to test.
+ * @return {boolean}
+ *     true if the string contains an integer; false otherwise.
+ */
+function isInteger(value) {
+  return INTEGER_REGEX.test(value);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//    Copyright (c) 2022 - 2024.
+//    Haixing Hu, Qubit Co. Ltd.
+//
+//    All rights reserved.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+var EXPONENTIAL_PART_REGEX = /[eE][+-]?\d+$/;
+var LEADING_MINUS_AND_ZEROS_REGEX = /^-?(0*)?/;
+var DOT_REGEX = /\./;
+var TRAILING_ZEROS_REGEX = /0+$/;
+
+/**
+ * Get the significant digits of a number.
+ *
+ * For example:
+ * - '2.34' returns '234'
+ * - '-77' returns '77'
+ * - '0.003400' returns '34'
+ * - '120.5e+30' returns '1205'
+ *
+ * @param {string} value
+ *     The string representation of the number.
+ * @return {string}
+ *     The significant digits of the number.
+ * @private
+ */
+function extractSignificantDigits(value) {
+  return value.replace(EXPONENTIAL_PART_REGEX, '') // from "-0.250e+30" to "-0.250"
+  .replace(DOT_REGEX, '') // from "-0.250" to "-0250"
+  .replace(TRAILING_ZEROS_REGEX, '') // from "-0250" to "-025"
+  .replace(LEADING_MINUS_AND_ZEROS_REGEX, ''); // from "-025" to "25"
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//    Copyright (c) 2022 - 2024.
+//    Haixing Hu, Qubit Co. Ltd.
+//
+//    All rights reserved.
+//
+////////////////////////////////////////////////////////////////////////////////
+var DEFAULT_APPROX = false;
+var DEFAULT_REQUIRED_DIGITS = 14;
+
+/**
+ * Test whether a string can be safely represented with a number without
+ * information loss.
+ *
+ * When the argument `approx` is true, floating point numbers that lose a few
+ * digits but are still approximately equal in value are considered safe too.
+ * Integer numbers must still be exactly equal.
+ *
+ * @param {string} value
+ *     The string to test.
+ * @param {object} options
+ *     The options of the test. It may contain the following properties:
+ *     - `approx: boolean`: indicates whether to consider approximately equal
+ *       floating point numbers as safe. Default is `false`.
+ *     - `requiredDigits: number`: the number of significant digits required for
+ *        a floating point number to be considered approximately equal. Default
+ *        is `14`.
+ * @return {boolean}
+ *     true if the string can be safely represented with a number; false
+ *     otherwise.
+ */
+function isSafeNumber(value) {
+  var _options$approx;
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
+  var num = parseFloat(value);
+  var str = String(num);
+  if (value === str) {
+    return true;
+  }
+  var v = extractSignificantDigits(value);
+  var s = extractSignificantDigits(str);
+  if (v === s) {
+    return true;
+  }
+  var approx = (_options$approx = options === null || options === void 0 ? void 0 : options.approx) !== null && _options$approx !== void 0 ? _options$approx : DEFAULT_APPROX;
+  if (approx === true) {
+    var _options$requiredDigi;
+    // A value is approximately equal when:
+    // 1. it is a floating point number, not an integer
+    // 2. it has at least requiredDigits digits
+    // 3. the first requiredDigits digits are equal
+    var requiredDigits = (_options$requiredDigi = options === null || options === void 0 ? void 0 : options.requiredDigits) !== null && _options$requiredDigi !== void 0 ? _options$requiredDigi : DEFAULT_REQUIRED_DIGITS;
+    if (!isInteger(value) && s.length >= requiredDigits && v.startsWith(s.substring(0, requiredDigits))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//    Copyright (c) 2022 - 2024.
+//    Haixing Hu, Qubit Co. Ltd.
+//
+//    All rights reserved.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A regular expression for testing whether a string represents a number.
+ *
+ * @type {RegExp}
+ * @see http://stackoverflow.com/questions/13340717/json-numbers-regular-expression
+ * @private
+ */
+var NUMBER_REGEX = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+
+/**
+ * Test whether a string represents a number
+ *
+ * @param {string} value
+ *     The string to test.
+ * @return {boolean}
+ *     true if the string contains a number; false otherwise.
+ */
+function isNumber(value) {
+  return NUMBER_REGEX.test(value);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//    Copyright (c) 2022 - 2024.
+//    Haixing Hu, Qubit Co. Ltd.
+//
+//    All rights reserved.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * When the provided value is an unsafe number, describe what the reason is
+ * - `'overflow'`
+ * - `'underflow'`
+ * - `'truncate_integer'`
+ * - `'truncate_float'`
+ * - `'none'` (when the value is safe)
+ *
+ * @param {string} value
+ *     The string represents a number to test.
+ * @return {string}
+ *     The reason why the value is unsafe. Returns `'none'` when the value is safe.
+ */
+function getUnsafeReason(value) {
+  var num = parseFloat(value);
+  var str = String(num);
+  if (value === str) {
+    return 'none';
+  }
+  var v = extractSignificantDigits(value);
+  var s = extractSignificantDigits(str);
+  if (v === s) {
+    return 'none';
+  }
+  if (isInteger(value)) {
+    return 'truncate_integer';
+  }
+  if (!Number.isFinite(num)) {
+    return 'overflow';
+  }
+  if (num === 0) {
+    return 'underflow';
+  }
+  return 'truncate_float';
+}
+
+/**
+ * The class of lossless numbers, which stores its numeric value as string.
+ */
+var LosslessNumber = /*#__PURE__*/function () {
+  /**
+   * Constructs a new instance of `LosslessNumber`.
+   *
+   * @param {string} value
+   *     The string representation of the number.
+   */
+  function LosslessNumber(value) {
+    _classCallCheck(this, LosslessNumber);
+    /**
+     * The string representation of the number.
+     *
+     * @type {string}
+     */
+    _defineProperty(this, "value", '');
+    /**
+     * Whether the value is a lossless number.
+     *
+     * @type {boolean}
+     */
+    _defineProperty(this, "isLosslessNumber", true);
+    if (!isNumber(value)) {
+      throw new Error("Invalid number (value: \"".concat(value, "\")"));
+    }
+    this.value = value;
+  }
+
+  /**
+   * Get the value of the LosslessNumber as number or bigint.
+   *
+   * - a number is returned for safe numbers and decimal values that only lose
+   *   some insignificant digits;
+   * - a bigint is returned for big integer numbers;
+   * - an Error is thrown for values that will overflow or underflow;
+   *
+   * Note that you can implement your own strategy for conversion by just
+   * getting the value as string via `.toString()`, and using util functions
+   * like `isInteger`, `isSafeNumber`, `getUnsafeReason`, and `toSafeNumberOrThrow`
+   * to convert it to a numeric value.
+   *
+   * @return {number|bigint}
+   *     the numeric value of the LosslessNumber, as number or bigint.
+   */
+  return _createClass(LosslessNumber, [{
+    key: "valueOf",
+    value: function valueOf() {
+      var unsafeReason = getUnsafeReason(this.value);
+      switch (unsafeReason) {
+        case 'none':
+          return parseFloat(this.value);
+        case 'truncate_float':
+          return parseFloat(this.value);
+        case 'truncate_integer':
+          return BigInt(this.value);
+        case 'overflow':
+        case 'underflow':
+          throw new Error('Cannot safely CONVERT TO NUMBER: ' + "the value '".concat(this.value, "' would ").concat(unsafeReason, " ") + "and become ".concat(parseFloat(this.value)));
+        default:
+          throw new Error('Unknown unsafe reason');
+      }
+    }
+
+    /**
+     * Get the value of this `LosslessNumber` as string.
+     *
+     * @return {string}
+     *     the string representation of this `LosslessNumber`.
+     */
+  }, {
+    key: "toString",
+    value: function toString() {
+      return this.value;
+    }
+
+    // Note: we do NOT implement a .toJSON() method, and you should not implement
+    // or use that, it cannot safely turn the numeric value in the string into
+    // stringified JSON since it has to be parsed into a number first.
+  }]);
+}();
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//    Copyright (c) 2022 - 2024.
+//    Haixing Hu, Qubit Co. Ltd.
+//
+//    All rights reserved.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A custom function to parse a number from a string, which supports lossless
+ * number parsing.
+ *
+ * @param {string} key
+ *     The key of the property.
+ * @param {string} value
+ *     The value of the property.
+ * @return {any}
+ *     The parsed value.
+ * @private
+ */
+function parseNumber(key, value) {
+  // if (isBigInt(value)) {
+  //   return BigInt(value.slice(0, -1));
+  // }
+  if (isSafeNumber(value, {
+    approx: false
+  })) {
+    return parseFloat(value);
+  }
+  if (isInteger(value)) {
+    return BigInt(value);
+  }
+  return new LosslessNumber(value);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//    Copyright (c) 2022 - 2024.
+//    Haixing Hu, Qubit Co. Ltd.
+//
+//    All rights reserved.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Formats a number value.
+ *
+ * @param {string} key
+ *     The key of the property.
+ * @param {string} value
+ *     The value of the property.
+ * @param {string} type
+ *     The type of the value.
+ * @return {undefined|string}
+ *     The formatted value. If the value is not a number, then return undefined.
+ * @private
+ */
+function formatNumber(key, value, type) {
+  switch (type) {
+    case 'bigint':
+      return value.toString();
+    case 'object':
+      // if (value instanceof Set) {
+      //   return Array.from(value);
+      // }
+      // if (value instanceof Map) {
+      //   return Array.from(value);
+      // }
+      if (value instanceof LosslessNumber) {
+        return value.toString();
+      }
+      return undefined;
+    default:
+      return undefined;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//    Copyright (c) 2022 - 2024.
+//    Haixing Hu, Qubit Co. Ltd.
+//
+//    All rights reserved.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A JSON replacer which serialize collections as arrays.
+ *
+ * @param {string} key
+ *     The key of the property.
+ * @param {any} value
+ *     The value of the property.
+ * @param {undefined|null|function} fallbackReplacer
+ *     The fallback replacer.
+ * @return {any}
+ *     The serialized value.
+ * @private
+ */
+function collectionReplacer(key, value, fallbackReplacer) {
+  if (value instanceof Set) {
+    return Array.from(value);
+  }
+  if (value instanceof Map) {
+    return Array.from(value);
+  }
+  if (fallbackReplacer) {
+    return fallbackReplacer(key, value);
+  }
+  return value;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//    Copyright (c) 2022 - 2024.
+//    Haixing Hu, Qubit Co. Ltd.
+//
+//    All rights reserved.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A customized JSON object which supports lossless number parsing and stringifying.
+ *
+ * This object provides two methods: `parse` and `stringify`, which are the same as the
+ * `JSON.parse` and `JSON.stringify` methods, except that they support lossless number
+ * parsing and stringifying.
+ *
+ * @type {object}
+ */
+var json = {
+  parse: function parse(text, reviver) {
+    return K$1(text, reviver, parseNumber);
+  },
+  stringify: function stringify(value, replacer, space) {
+    return C(value, function (k, v) {
+      return collectionReplacer(k, v, replacer);
+    }, space, formatNumber);
+  }
+};
+json[Symbol.toStringTag] = 'JSON';
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//    Copyright (c) 2022 - 2024.
+//    Haixing Hu, Qubit Co. Ltd.
+//
+//    All rights reserved.
+//
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * A regular expression for testing whether a string represents a BigInt.
+ *
+ * @type {RegExp}
+ * @private
+ */
+var BIG_INTEGER_REGEX = /^[+-]?\d+n$/;
+
+/**
+ * Test whether a string represents a BigInt.
+ *
+ * @param value
+ *     The string to test.
+ * @return {boolean}
+ *     true if the string contains a BigInt; false otherwise.
+ */
+function isBigInt(value) {
+  return BIG_INTEGER_REGEX.test(value);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//    Copyright (c) 2022 - 2024.
+//    Haixing Hu, Qubit Co. Ltd.
+//
+//    All rights reserved.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Convert a string into a number when it is safe to do so.
+ * Throws an error otherwise, explaining the reason.
+ *
+ * @param {string} value
+ *     The string to convert into a number.
+ * @param {object} options
+ *     The options for conversion.
+ * @return {number}
+ *     The converted safe number.
+ * @throws {Error}
+ *     When the value is not safe to convert.
+ */
+function toSafeNumberOrThrow(value) {
+  var _options$approx;
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
+  var number = parseFloat(value);
+  var unsafeReason = getUnsafeReason(value);
+  if (unsafeReason === 'none') {
+    return number;
+  }
+  var approx = (_options$approx = options === null || options === void 0 ? void 0 : options.approx) !== null && _options$approx !== void 0 ? _options$approx : DEFAULT_APPROX;
+  // when approx is true, we allow truncating float values
+  if (approx && unsafeReason === 'truncate_float') {
+    return number;
+  }
+  var unsafeReasonText = unsafeReason === null || unsafeReason === void 0 ? void 0 : unsafeReason.replace(/_/, ' ');
+  throw new Error('Cannot safely convert to number: ' + "the value '".concat(value, "' would ").concat(unsafeReasonText, " and become ").concat(number));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//    Copyright (c) 2022 - 2024.
+//    Haixing Hu, Qubit Co. Ltd.
+//
+//    All rights reserved.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+export { json as Json, LosslessNumber, json as default, getUnsafeReason, isBigInt, isInteger, isNumber, isSafeNumber, toSafeNumberOrThrow };
+//# sourceMappingURL=json.mjs.map