@qubit-ltd/json 1.1.4 → 1.2.1

package/README.md

@@ -6,26 +6,26 @@
 [![CircleCI](https://dl.circleci.com/status-badge/img/gh/Haixing-Hu/js-json/tree/master.svg?style=shield)](https://dl.circleci.com/status-badge/redirect/gh/Haixing-Hu/js-json/tree/master)
 [![Coverage Status](https://coveralls.io/repos/github/Haixing-Hu/js-json/badge.svg?branch=master)](https://coveralls.io/github/Haixing-Hu/js-json?branch=master)
 
-[@qubit-ltd/json]  is a JavaScript library that extends the functionality of the
+[@qubit-ltd/json] is a JavaScript library that extends the functionality of the
 standard JSON object, providing robust support for working with numbers that 
-exceed JavaScript’s safe range. It offers enhanced parsing and stringifying 
+exceed JavaScript's safe range. It offers enhanced parsing and stringifying 
 capabilities, making it ideal for handling large datasets and complex numerical 
-operations while adhering to JSON’s structure.
+operations while adhering to JSON's structure.
 
 ## Key Features
 
-- `BigInt` Support: When parsing JSON strings, numbers outside JavaScript’s safe 
+- **`BigInt` Support**: When parsing JSON strings, numbers outside JavaScript's safe 
   integer range are automatically converted to the native `BigInt`, ensuring 
   precision is maintained.
-- `LosslessNumber` Handling: For floating-point numbers that cannot be accurately
+- **`LosslessNumber` Handling**: For floating-point numbers that cannot be accurately
   represented in JavaScript, this library introduces the `LosslessNumber` object. 
   This lightweight object preserves the full precision of the number as a string,
   allowing flexible conversion to number or `BigInt` for mathematical operations.
-- Accurate Stringification: During the stringify process, `BigInt` values are
-  serialized as strings without the “n” suffix, maintaining compatibility with 
+- **Accurate Stringification**: During the stringify process, `BigInt` values are
+  serialized as strings without the "n" suffix, maintaining compatibility with 
   the standard JSON format. Similarly, `LosslessNumber` objects are serialized
   using their internal string representation.
-- Collection Serialization: JavaScript’s native collections like `Set` and `Map`
+- **Collection Serialization**: JavaScript's native collections like `Set` and `Map`
   are seamlessly serialized as arrays, allowing for better compatibility with
   JSON structures.
 
@@ -55,42 +55,86 @@ collections like Set and Map.
 ```javascript
 import Json from '@qubit-ltd/json';
 
-// parse numbers outside the safe range
+// Parse numbers outside the safe range
 const str1 = '{"decimal":2.370,"big_int":9123372036854000123,"big_float":2.3e+500}';
-const obj1 = Json.parse(text);
+const obj1 = Json.parse(str1);
 console.log(obj1.decimal);   // 2.37
 console.log(obj1.big_int);   // 9123372036854000123n
 console.log(obj1.big_float); // LosslessNumber { value: '2.3e+500', isLosslessNumber: true }
 console.log(String(obj1.big_float)); // '2.3e+500'
 
-// stringify numbers outside the safe range
+// Stringify numbers outside the safe range
 const json1 = Json.stringify(obj1);
 console.log(json1); // '{"decimal":2.37,"big_int":9123372036854000123,"big_float":"2.3e+500"}'
 
-// stringify collections
+// Stringify collections
 const obj2 = { 
   x: new Set([{ a: 1 }, { b: 2 }, { c: 3 }]),
   y: new Map([[1, { a: 2 }], [2, { b: 4 }]]),
 };
-const json2 = Json.stringify(obj);
+const json2 = Json.stringify(obj2);
 console.log(json2); // '{"x":[{"a":1},{"b":2},{"c":3}],"y":[[1,{"a":2}],[2,{"b":4}]]}'
 
-const json3 = Json.stringify(obj, null, 2);
-console.log(json3); // 
+// Pretty-print with indentation
+const json3 = Json.stringify(obj2, null, 2);
+console.log(json3);
+/* Output:
+{
+  "x": [
+    {
+      "a": 1
+    },
+    {
+      "b": 2
+    },
+    {
+      "c": 3
+    }
+  ],
+  "y": [
+    [
+      1,
+      {
+        "a": 2
+      }
+    ],
+    [
+      2,
+      {
+        "b": 4
+      }
+    ]
+  ]
+}
+*/
 ```
 
 ### LosslessNumber Class
 
-The LosslessNumber class is used to handle floating-point numbers with full
+The `LosslessNumber` class is used to handle floating-point numbers with full
 precision, avoiding truncation or rounding issues.
 
 ```javascript
 import Json from '@qubit-ltd/json';
+import { LosslessNumber } from '@qubit-ltd/json';
+
+// Parse a number with high precision
 const parsed = Json.parse('{"float": 1.234567891234567891234}');
 console.log(parsed.float);  // LosslessNumber { value: '1.234567891234567891234' }
 
 // Convert LosslessNumber to standard number
-console.log(parsed.float.valueOf());  // 1.2345678912345679 (standard JS number)
+console.log(parsed.float.valueOf());  // 1.2345678912345679 (standard JS number, precision loss)
+
+// Create a LosslessNumber directly
+const largeNumber = new LosslessNumber('9876543210.123456789012345678901234567890');
+console.log(largeNumber.toString());  // '9876543210.123456789012345678901234567890'
+console.log(largeNumber.valueOf());   // 9876543210.123457 (standard JS number with precision loss)
+
+// Mathematical operations
+const num1 = new LosslessNumber('1234567890.123456789');
+const num2 = 100;
+// For math operations, LosslessNumber is converted to standard number (with potential precision loss)
+console.log(num1 * num2);  // 123456789012.34578
 ```
 
 ### Utility Functions
@@ -100,7 +144,7 @@ numbers and ensure safe conversions.
 
 #### `isBigInt(value)`
 
-Checks if a string represents a `BigInt` (i.e., ends with an “n” suffix).
+Checks if a string represents a `BigInt` (i.e., ends with an "n" suffix).
 
 ```javascript
 import { isBigInt } from '@qubit-ltd/json';
@@ -118,6 +162,8 @@ import { isInteger } from '@qubit-ltd/json';
 
 console.log(isInteger('12345'));  // true
 console.log(isInteger('123.45')); // false
+console.log(isInteger('123e5'));  // true (12300000 is an integer)
+console.log(isInteger('123e-5')); // false (0.00123 is not an integer)
 ```
 
 #### `isNumber(value)`
@@ -131,19 +177,26 @@ console.log(isNumber('12345'));     // true
 console.log(isNumber('-123.45'));   // true
 console.log(isNumber('1.23e-11'));  // true
 console.log(isNumber('abc'));       // false
+console.log(isNumber('123abc'));    // false
+console.log(isNumber('0xFF'));      // false (hexadecimal notation not supported)
 ```
 
 #### `isSafeNumber(value, options)`
 
-Checks if a string represents a number within JavaScript’s safe range.
+Checks if a string represents a number within JavaScript's safe range.
 
 ```javascript
 import { isSafeNumber } from '@qubit-ltd/json';
 
 console.log(isSafeNumber('12345'));     // true
-console.log(isSafeNumber('12345678901234567890')); // false
-console.log(isSafeNumber('123.45678901234567890')); // false
-console.log(isSafeNumber('123.45678901234567890', { approx: true, requiredDigits: 16 })); // true
+console.log(isSafeNumber('12345678901234567890')); // false (too large for JavaScript's number type)
+console.log(isSafeNumber('123.45678901234567890')); // false (too many significant digits)
+
+// With options
+console.log(isSafeNumber('123.45678901234567890', { 
+  approx: true,         // Allow approximate representation
+  requiredDigits: 16    // Require at least 16 digits of precision
+})); // true
 ``` 
 
 #### `getUnsafeReason(value)`
@@ -151,11 +204,11 @@ console.log(isSafeNumber('123.45678901234567890', { approx: true, requiredDigits
 Explains why a number represented by a string is unsafe, returning one of the 
 following reasons:
 
-- `'overflow'`
-- `'underflow'`
-- `'truncate_integer'`
-- `'truncate_float'`
-- `'none'`: when the value is safe
+- `'overflow'`: The number is too large to be represented in JavaScript
+- `'underflow'`: The number is too small to be represented in JavaScript
+- `'truncate_integer'`: The integer part would be truncated if converted to a JavaScript number
+- `'truncate_float'`: The floating-point part would lose precision if converted to a JavaScript number
+- `'none'`: The value is safe to convert to a JavaScript number
 
 ```javascript
 import { getUnsafeReason } from '@qubit-ltd/json';
@@ -170,7 +223,7 @@ console.log(getUnsafeReason('1e-324'));     // Output: 'underflow'
 #### `toSafeNumberOrThrow(value, options)`
 
 Converts a string into a number if it is safe to do so. Throws an error if the 
-number is unsafe, explaining the reason.
+number is unsafe, explaining the reason. This is useful for validating numeric inputs.
 
 ```javascript
 import { toSafeNumberOrThrow } from '@qubit-ltd/json';
@@ -181,7 +234,93 @@ try {
   console.error(e.message);  // Output: 'Cannot safely convert to number: the value '-12345678901234567890' would truncate integer and become -12345678901234567000'
 }
 
+// Safe conversion example
 console.log(toSafeNumberOrThrow('9007199254740991'));  // Output: 9007199254740991
+
+// With options
+try {
+  console.log(toSafeNumberOrThrow('123.45678901234567890', { 
+    approx: false,        // Do not allow approximate representation
+    requiredDigits: 20    // Require at least 20 digits of precision
+  }));
+} catch (e) {
+  console.error(e.message);  // Will throw error about precision loss
+}
+```
+
+## Advanced Usage
+
+### Custom Parsing Options
+
+You can customize how numbers are parsed using options:
+
+```javascript
+import Json from '@qubit-ltd/json';
+
+const json = '{"bigInt": 9007199254740993, "largeFloat": 1.234567890123456789}';
+
+// Use custom parsing options
+const result = Json.parse(json, {
+  useBigInt: true,  // Default is true - convert large integers to BigInt
+  losslessNumbers: true,  // Default is true - use LosslessNumber for high-precision floats
+});
+
+console.log(typeof result.bigInt);  // 'bigint'
+console.log(result.bigInt);         // 9007199254740993n
+console.log(result.largeFloat);     // LosslessNumber { value: '1.234567890123456789' }
+
+// Disable custom number handling
+const standardResult = Json.parse(json, {
+  useBigInt: false,
+  losslessNumbers: false,
+});
+
+console.log(typeof standardResult.bigInt);  // 'number'
+console.log(standardResult.bigInt);         // 9007199254740992 (precision loss!)
+console.log(standardResult.largeFloat);     // 1.2345678901234568 (precision loss!)
+```
+
+### Custom Stringification Options
+
+You can customize how values are stringified:
+
+```javascript
+import Json from '@qubit-ltd/json';
+
+const data = {
+  bigInt: BigInt('9007199254740993'),
+  largeFloat: new LosslessNumber('1.234567890123456789'),
+  set: new Set([1, 2, 3]),
+  map: new Map([['a', 1], ['b', 2]]),
+};
+
+// Default stringification (handles BigInt, LosslessNumber, Set, Map)
+console.log(Json.stringify(data));
+// '{"bigInt":9007199254740993,"largeFloat":"1.234567890123456789","set":[1,2,3],"map":[["a",1],["b",2]]}'
+
+// With custom options and indentation
+console.log(Json.stringify(data, null, 2));
+/* Output:
+{
+  "bigInt": 9007199254740993,
+  "largeFloat": "1.234567890123456789",
+  "set": [
+    1,
+    2,
+    3
+  ],
+  "map": [
+    [
+      "a",
+      1
+    ],
+    [
+      "b",
+      2
+    ]
+  ]
+}
+*/
 ```
 
 ## <span id="contributing">Contributing</span>
@@ -189,6 +328,45 @@ console.log(toSafeNumberOrThrow('9007199254740991'));  // Output: 90071992547409
 If you find any issues or have suggestions for improvements, please feel free
 to open an issue or submit a pull request to the [GitHub repository].
 
+### Development Setup
+
+1. Clone the repository:
+   ```sh
+   git clone https://github.com/Haixing-Hu/js-json.git
+   cd js-json
+   ```
+
+2. Install dependencies:
+   ```sh
+   yarn install
+   ```
+
+3. Run tests:
+   ```sh
+   yarn test
+   ```
+
+4. Build the library:
+   ```sh
+   yarn build
+   ```
+
+### Release Process
+
+1. Update version in package.json
+2. Run tests and linting:
+   ```sh
+   yarn lint && yarn test
+   ```
+3. Build the library:
+   ```sh
+   yarn build:all
+   ```
+4. Publish to npm:
+   ```sh
+   yarn deploy
+   ```
+
 ## <span id="license">License</span>
 
 [@qubit-ltd/json] is distributed under the Apache 2.0 license.

package/README.zh_CN.md

@@ -16,7 +16,7 @@
   确保精度不丢失。
 - **`LosslessNumber` 处理**：对于无法在 JavaScript 中准确表示的浮点数，该库引入了 `LosslessNumber` 对象。
   这个轻量级对象以字符串形式保存完整的数值精度，允许灵活地转换为数字或 `BigInt` 进行数学运算。
-- **精确的字符串化**：在字符串化过程中，`BigInt` 值会作为字符串序列化，不带 “n” 后缀，以保持与标准 JSON 格式的兼容性。
+- **精确的字符串化**：在字符串化过程中，`BigInt` 值会作为字符串序列化，不带 "n" 后缀，以保持与标准 JSON 格式的兼容性。
   同样，`LosslessNumber` 对象使用其内部字符串表示进行序列化。
 - **集合序列化**：JavaScript 原生的集合类型如 `Set` 和 `Map` 会无缝地序列化为数组，以便更好地与 JSON 结构兼容。
 
@@ -43,28 +43,58 @@ yarn add @qubit-ltd/json
 ```javascript
 import Json from '@qubit-ltd/json';
 
-// parse numbers outside the safe range
+// 解析超出安全范围的数字
 const str1 = '{"decimal":2.370,"big_int":9123372036854000123,"big_float":2.3e+500}';
-const obj1 = Json.parse(text);
+const obj1 = Json.parse(str1);
 console.log(obj1.decimal);   // 2.37
 console.log(obj1.big_int);   // 9123372036854000123n
 console.log(obj1.big_float); // LosslessNumber { value: '2.3e+500', isLosslessNumber: true }
 console.log(String(obj1.big_float)); // '2.3e+500'
 
-// stringify numbers outside the safe range
+// 序列化超出安全范围的数字
 const json1 = Json.stringify(obj1);
 console.log(json1); // '{"decimal":2.37,"big_int":9123372036854000123,"big_float":"2.3e+500"}'
 
-// stringify collections
+// 序列化集合类型
 const obj2 = { 
   x: new Set([{ a: 1 }, { b: 2 }, { c: 3 }]),
   y: new Map([[1, { a: 2 }], [2, { b: 4 }]]),
 };
-const json2 = Json.stringify(obj);
+const json2 = Json.stringify(obj2);
 console.log(json2); // '{"x":[{"a":1},{"b":2},{"c":3}],"y":[[1,{"a":2}],[2,{"b":4}]]}'
 
-const json3 = Json.stringify(obj, null, 2);
-console.log(json3); // 
+// 格式化输出（带缩进）
+const json3 = Json.stringify(obj2, null, 2);
+console.log(json3);
+/* 输出:
+{
+  "x": [
+    {
+      "a": 1
+    },
+    {
+      "b": 2
+    },
+    {
+      "c": 3
+    }
+  ],
+  "y": [
+    [
+      1,
+      {
+        "a": 2
+      }
+    ],
+    [
+      2,
+      {
+        "b": 4
+      }
+    ]
+  ]
+}
+*/
 ```
 
 ### LosslessNumber 类
@@ -73,11 +103,25 @@ console.log(json3); //
 
 ```javascript
 import Json from '@qubit-ltd/json';
+import { LosslessNumber } from '@qubit-ltd/json';
+
+// 解析高精度数字
 const parsed = Json.parse('{"float": 1.234567891234567891234}');
 console.log(parsed.float);  // LosslessNumber { value: '1.234567891234567891234' }
 
-// Convert LosslessNumber to standard number
-console.log(parsed.float.valueOf());  // 1.2345678912345679 (standard JS number)
+// 将 LosslessNumber 转换为标准数字
+console.log(parsed.float.valueOf());  // 1.2345678912345679（标准 JS 数字，有精度损失）
+
+// 直接创建 LosslessNumber
+const largeNumber = new LosslessNumber('9876543210.123456789012345678901234567890');
+console.log(largeNumber.toString());  // '9876543210.123456789012345678901234567890'
+console.log(largeNumber.valueOf());   // 9876543210.123457（标准 JS 数字，有精度损失）
+
+// 数学运算
+const num1 = new LosslessNumber('1234567890.123456789');
+const num2 = 100;
+// 对于数学运算，LosslessNumber 会转换为标准数字（可能有精度损失）
+console.log(num1 * num2);  // 123456789012.34578
 ```
 
 ### 实用函数
@@ -104,6 +148,8 @@ import { isInteger } from '@qubit-ltd/json';
 
 console.log(isInteger('12345'));  // true
 console.log(isInteger('123.45')); // false
+console.log(isInteger('123e5'));  // true（12300000 是整数）
+console.log(isInteger('123e-5')); // false（0.00123 不是整数）
 ```
 
 #### `isNumber(value)`
@@ -117,6 +163,8 @@ console.log(isNumber('12345'));     // true
 console.log(isNumber('-123.45'));   // true
 console.log(isNumber('1.23e-11'));  // true
 console.log(isNumber('abc'));       // false
+console.log(isNumber('123abc'));    // false
+console.log(isNumber('0xFF'));      // false（不支持十六进制表示法）
 ```
 
 #### `isSafeNumber(value, options)`
@@ -127,34 +175,39 @@ console.log(isNumber('abc'));       // false
 import { isSafeNumber } from '@qubit-ltd/json';
 
 console.log(isSafeNumber('12345'));     // true
-console.log(isSafeNumber('12345678901234567890')); // false
-console.log(isSafeNumber('123.45678901234567890')); // false
-console.log(isSafeNumber('123.45678901234567890', { approx: true, requiredDigits: 16 })); // true
+console.log(isSafeNumber('12345678901234567890')); // false（对于 JavaScript 的数字类型来说太大）
+console.log(isSafeNumber('123.45678901234567890')); // false（有效数字太多）
+
+// 使用选项
+console.log(isSafeNumber('123.45678901234567890', { 
+  approx: true,         // 允许近似表示
+  requiredDigits: 16    // 要求至少保留 16 位有效数字精度
+})); // true
 ``` 
 
 #### `getUnsafeReason(value)`
 
 解释为什么由字符串表示的数字不安全，返回以下原因之一：
 
-- `'overflow'`（溢出）
-- `'underflow'`（下溢）
-- `'truncate_integer'`（整数截断）
-- `'truncate_float'`（浮点数截断）
-- `'none'`：当值是安全时
+- `'overflow'`（溢出）：数字太大，超出了 JavaScript 可表示的范围
+- `'underflow'`（下溢）：数字太小，低于 JavaScript 可表示的范围
+- `'truncate_integer'`（整数截断）：如果转换为 JavaScript 数字，整数部分会被截断
+- `'truncate_float'`（浮点数截断）：如果转换为 JavaScript 数字，浮点部分会失去精度
+- `'none'`：值是安全的，可以安全地转换为 JavaScript 数字
 
 ```javascript
 import { getUnsafeReason } from '@qubit-ltd/json';
 
-console.log(getUnsafeReason('12345'));     // Output: 'none'
-console.log(getUnsafeReason('12345678901234567890')); // Output: 'truncate_integer'
-console.log(getUnsafeReason('-12345678901234567890.123'));  //  Output: 'truncate_float'
-console.log(getUnsafeReason('-1e+1000'));   // Output: 'overflow'
-console.log(getUnsafeReason('1e-324'));     // Output: 'underflow'
+console.log(getUnsafeReason('12345'));     // 输出: 'none'
+console.log(getUnsafeReason('12345678901234567890')); // 输出: 'truncate_integer'
+console.log(getUnsafeReason('-12345678901234567890.123'));  //  输出: 'truncate_float'
+console.log(getUnsafeReason('-1e+1000'));   // 输出: 'overflow'
+console.log(getUnsafeReason('1e-324'));     // 输出: 'underflow'
 ```
 
 #### `toSafeNumberOrThrow(value, options)`
 
-如果可以安全转换，将字符串转换为数字。如果数字不安全，则抛出错误并解释原因。
+如果可以安全转换，将字符串转换为数字。如果数字不安全，则抛出错误并解释原因。这对于验证数字输入非常有用。
 
 ```javascript
 import { toSafeNumberOrThrow } from '@qubit-ltd/json';
@@ -162,16 +215,141 @@ import { toSafeNumberOrThrow } from '@qubit-ltd/json';
 try {
   console.log(toSafeNumberOrThrow('-12345678901234567890'));
 } catch (e) {
-  console.error(e.message);  // Output: 'Cannot safely convert to number: the value '-12345678901234567890' would truncate integer and become -12345678901234567000'
+  console.error(e.message);  // 输出: 'Cannot safely convert to number: the value '-12345678901234567890' would truncate integer and become -12345678901234567000'
 }
 
-console.log(toSafeNumberOrThrow('9007199254740991'));  // Output: 9007199254740991
+// 安全转换示例
+console.log(toSafeNumberOrThrow('9007199254740991'));  // 输出: 9007199254740991
+
+// 使用选项
+try {
+  console.log(toSafeNumberOrThrow('123.45678901234567890', { 
+    approx: false,        // 不允许近似表示
+    requiredDigits: 20    // 要求至少保留 20 位有效数字精度
+  }));
+} catch (e) {
+  console.error(e.message);  // 将抛出关于精度损失的错误
+}
+```
+
+## 高级用法
+
+### 自定义解析选项
+
+您可以使用选项自定义数字的解析方式：
+
+```javascript
+import Json from '@qubit-ltd/json';
+
+const json = '{"bigInt": 9007199254740993, "largeFloat": 1.234567890123456789}';
+
+// 使用自定义解析选项
+const result = Json.parse(json, {
+  useBigInt: true,  // 默认为 true - 将大整数转换为 BigInt
+  losslessNumbers: true,  // 默认为 true - 为高精度浮点数使用 LosslessNumber
+});
+
+console.log(typeof result.bigInt);  // 'bigint'
+console.log(result.bigInt);         // 9007199254740993n
+console.log(result.largeFloat);     // LosslessNumber { value: '1.234567890123456789' }
+
+// 禁用自定义数字处理
+const standardResult = Json.parse(json, {
+  useBigInt: false,
+  losslessNumbers: false,
+});
+
+console.log(typeof standardResult.bigInt);  // 'number'
+console.log(standardResult.bigInt);         // 9007199254740992（精度损失！）
+console.log(standardResult.largeFloat);     // 1.2345678901234568（精度损失！）
+```
+
+### 自定义字符串化选项
+
+您可以自定义值的字符串化方式：
+
+```javascript
+import Json from '@qubit-ltd/json';
+
+const data = {
+  bigInt: BigInt('9007199254740993'),
+  largeFloat: new LosslessNumber('1.234567890123456789'),
+  set: new Set([1, 2, 3]),
+  map: new Map([['a', 1], ['b', 2]]),
+};
+
+// 默认字符串化（处理 BigInt、LosslessNumber、Set、Map）
+console.log(Json.stringify(data));
+// '{"bigInt":9007199254740993,"largeFloat":"1.234567890123456789","set":[1,2,3],"map":[["a",1],["b",2]]}'
+
+// 使用自定义选项和缩进
+console.log(Json.stringify(data, null, 2));
+/* 输出:
+{
+  "bigInt": 9007199254740993,
+  "largeFloat": "1.234567890123456789",
+  "set": [
+    1,
+    2,
+    3
+  ],
+  "map": [
+    [
+      "a",
+      1
+    ],
+    [
+      "b",
+      2
+    ]
+  ]
+}
+*/
 ```
 
 ## <span id="contributing">贡献</span>
 
 如果您发现任何问题或有改进建议，请随时在 [GitHub 仓库] 上提交 issue 或 pull request。
 
+### 开发设置
+
+1. 克隆仓库：
+   ```sh
+   git clone https://github.com/Haixing-Hu/js-json.git
+   cd js-json
+   ```
+
+2. 安装依赖：
+   ```sh
+   yarn install
+   ```
+
+3. 运行测试：
+   ```sh
+   yarn test
+   ```
+
+4. 构建库：
+   ```sh
+   yarn build
+   ```
+
+### 发布流程
+
+1. 更新 package.json 中的版本号
+2. 运行测试和 lint 检查：
+   ```sh
+   yarn lint && yarn test
+   ```
+3. 构建库：
+   ```sh
+   yarn build:all
+   ```
+4. 发布到 npm：
+   ```sh
+   yarn deploy
+   ```
+
 ## <span id="license">许可证</span>
 
 [@qubit-ltd/json] 根据 Apache 2.0 许可证分发。详情请参阅 [LICENSE](LICENSE) 文件。
@@ -187,7 +365,7 @@ console.log(toSafeNumberOrThrow('9007199254740991'));  // Output: 90071992547409
 我们对这些贡献者的工作表示感谢，这些工作对本库功能的实现起到了至关重要的作用。
 
 [@qubit-ltd/json]: https://npmjs.com/package/@qubit-ltd/json
-[GitHub repository]: https://github.com/Haixing-Hu/js-json
+[GitHub 仓库]: https://github.com/Haixing-Hu/js-json
 [Why does JSON.parse corrupt large numbers and how to solve this?]: https://jsoneditoronline.org/indepth/parse/why-does-json-parse-corrupt-large-numbers/
 [json-bigint]: https://github.com/sidorares/json-bigint
 [lossless-json]: https://github.com/josdejong/lossless-json