cjk-number 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tse-Wei Chen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,124 @@
+# cjk-number
+
+Convert numbers to and from CJK numeral systems, including traditional/simplified formats, heavenly stems, earthly branches, decimals, negatives, and very large BigInt values.
+
+## Install
+
+```sh
+npm install cjk-number
+```
+
+## Quick Start
+
+```js
+import {
+  cjkIdeographic,
+  cjkHeavenlyStem,
+  cjkEarthlyBranch,
+  tradChineseFormal,
+  tradChineseInformal,
+  simpChineseInformal,
+  simpChineseFormal,
+  tradFormalPositionalUnits,
+  integer
+} from "cjk-number";
+
+integer.parseInt("一千零二十三"); // 1023
+integer.parseInt("壹仟零貳拾參"); // 1023
+integer.parseInt("癸"); // 10
+integer.parseInt("亥"); // 12
+
+tradChineseFormal.parse(1023); // "壹仟零貳拾參"
+simpChineseFormal.parse(1023); // "壹仟零贰拾叁"
+cjkHeavenlyStem.parse(10); // "癸"
+cjkEarthlyBranch.parse(12); // "亥"
+
+tradFormalPositionalUnits[68]; // "無量大數"
+```
+
+## API
+
+### integer.parseInt(input, options?)
+
+Parses CJK string to number or bigint.
+
+Options:
+
+- strict?: boolean
+- preferBigInt?: boolean
+- heavenlyStemMode?: "fixed" | "cyclic"
+- earthlyBranchMode?: "fixed" | "cyclic"
+
+Examples:
+
+```js
+integer.parseInt("負一百零二"); // -102
+integer.parseInt("一點二三"); // 1.23
+integer.parseInt("九千零七兆一", { preferBigInt: true }); // 9007000000000001n
+integer.parseInt("一無量大數", { preferBigInt: true }); // 10n ** 68n
+```
+
+### Formatter.parse(value)
+
+Available formatters:
+
+- cjkIdeographic
+- tradChineseInformal
+- tradChineseFormal
+- simpChineseInformal
+- simpChineseFormal
+- cjkHeavenlyStem
+- cjkEarthlyBranch
+
+Examples:
+
+```js
+tradChineseInformal.parse(-320); // "負三百二十"
+simpChineseInformal.parse(12.34); // "十二點三四"
+tradChineseFormal.parse(10n ** 68n); // "壹無量大數"
+simpChineseFormal.parse(10n ** 64n); // "壹不可思议"
+
+cjkHeavenlyStem.parse(11, { mode: "cyclic" }); // "甲"
+cjkEarthlyBranch.parse(13, { mode: "cyclic" }); // "子"
+```
+
+## Supported Large Units
+
+Traditional:
+
+萬, 億, 兆, 京, 垓, 秭, 穰, 溝, 澗, 正, 載, 極, 恆河沙, 阿僧祇, 那由他, 不可思議, 無量大數
+
+Simplified:
+
+万, 亿, 兆, 京, 垓, 秭, 穰, 沟, 涧, 正, 载, 极, 恒河沙, 阿僧祇, 那由他, 不可思议, 无量大数
+
+## Development
+
+```sh
+npm install
+npm run typecheck
+npm test
+npm run build
+```
+
+Property-style test environment variables:
+
+- CJK_TEST_SEED (default: 20260327)
+- CJK_TEST_SAMPLES (default: 100)
+- CJK_TEST_MAX_DIGITS (default: 69)
+
+Example:
+
+```sh
+CJK_TEST_SEED=42 CJK_TEST_SAMPLES=1000 CJK_TEST_MAX_DIGITS=69 npm test
+```
+
+## Notes
+
+- Decimal parsing currently returns number.
+- Very large integers can return bigint when preferBigInt is enabled.
+- Heavenly stem and earthly branch parsing is auto-detected by symbol.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+export type CyclicMode = "fixed" | "cyclic";
+export interface SystemParseOptions {
+    mode?: CyclicMode;
+}
+export interface IntegerParseOptions {
+    strict?: boolean;
+    preferBigInt?: boolean;
+    heavenlyStemMode?: CyclicMode;
+    earthlyBranchMode?: CyclicMode;
+}
+type IntegerLike = number | bigint;
+export declare const tradFormalPositionalUnits: string[];
+export declare const integer: {
+    parseInt(input: string, options?: IntegerParseOptions): number | bigint;
+};
+export declare const cjkIdeographic: {
+    parse(value: IntegerLike): string;
+};
+export declare const tradChineseInformal: {
+    parse(value: IntegerLike): string;
+};
+export declare const tradChineseFormal: {
+    parse(value: IntegerLike): string;
+};
+export declare const simpChineseInformal: {
+    parse(value: IntegerLike): string;
+};
+export declare const simpChineseFormal: {
+    parse(value: IntegerLike): string;
+};
+export declare const cjkHeavenlyStem: {
+    parse(value: IntegerLike, options?: SystemParseOptions): string;
+};
+export declare const cjkEarthlyBranch: {
+    parse(value: IntegerLike, options?: SystemParseOptions): string;
+};
+export declare const systems: {
+    heavenlyStem: readonly ["甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"];
+    earthlyBranch: readonly ["子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥"];
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC;AAE5C,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,UAAU,CAAC;IAC9B,iBAAiB,CAAC,EAAE,UAAU,CAAC;CAChC;AAED,KAAK,WAAW,GAAG,MAAM,GAAG,MAAM,CAAC;AAwGnC,eAAO,MAAM,yBAAyB,UAA6C,CAAC;AAqXpF,eAAO,MAAM,OAAO;oBACF,MAAM,YAAY,mBAAmB,GAAG,MAAM,GAAG,MAAM;CAGxE,CAAC;AAEF,eAAO,MAAM,cAAc;iBACZ,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,mBAAmB;iBACjB,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,iBAAiB;iBACf,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,mBAAmB;iBACjB,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,iBAAiB;iBACf,WAAW,GAAG,MAAM;CAMlC,CAAC;AAEF,eAAO,MAAM,eAAe;iBACb,WAAW,YAAW,kBAAkB,GAAQ,MAAM;CAGpE,CAAC;AAEF,eAAO,MAAM,gBAAgB;iBACd,WAAW,YAAW,kBAAkB,GAAQ,MAAM;CAGpE,CAAC;AAEF,eAAO,MAAM,OAAO;;;CAGnB,CAAC"}

package/dist/index.js

@@ -0,0 +1,444 @@
+const STEMS = ["甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"];
+const BRANCHES = ["子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥"];
+const CANONICAL_DIGITS = {
+    "零": 0,
+    "〇": 0,
+    "○": 0,
+    "一": 1,
+    "壹": 1,
+    "二": 2,
+    "貳": 2,
+    "贰": 2,
+    "兩": 2,
+    "两": 2,
+    "三": 3,
+    "參": 3,
+    "叁": 3,
+    "四": 4,
+    "肆": 4,
+    "五": 5,
+    "伍": 5,
+    "六": 6,
+    "陸": 6,
+    "陆": 6,
+    "七": 7,
+    "柒": 7,
+    "八": 8,
+    "捌": 8,
+    "九": 9,
+    "玖": 9
+};
+const SMALL_UNITS = {
+    十: 10n,
+    拾: 10n,
+    百: 100n,
+    佰: 100n,
+    千: 1000n,
+    仟: 1000n
+};
+const TRAD_BIG_UNITS = [
+    "萬",
+    "億",
+    "兆",
+    "京",
+    "垓",
+    "秭",
+    "穰",
+    "溝",
+    "澗",
+    "正",
+    "載",
+    "極",
+    "恆河沙",
+    "阿僧祇",
+    "那由他",
+    "不可思議",
+    "無量大數"
+];
+const SIMP_BIG_UNITS = [
+    "万",
+    "亿",
+    "兆",
+    "京",
+    "垓",
+    "秭",
+    "穰",
+    "沟",
+    "涧",
+    "正",
+    "载",
+    "极",
+    "恒河沙",
+    "阿僧祇",
+    "那由他",
+    "不可思议",
+    "无量大数"
+];
+function buildFormalPositionalUnits(bigUnits) {
+    const result = [""];
+    for (const unit of bigUnits) {
+        result.push("拾", "佰", "仟", unit);
+    }
+    return result;
+}
+function createBigUnitOrder(units) {
+    return units
+        .map((unit, index) => [unit, 10n ** BigInt((index + 1) * 4)])
+        .reverse();
+}
+export const tradFormalPositionalUnits = buildFormalPositionalUnits(TRAD_BIG_UNITS);
+const TRAD_INFORMAL_SET = {
+    zero: "零",
+    digits: ["一", "二", "三", "四", "五", "六", "七", "八", "九"],
+    smallUnits: ["十", "百", "千"],
+    bigUnits: [...TRAD_BIG_UNITS]
+};
+const TRAD_FORMAL_SET = {
+    zero: "零",
+    digits: ["壹", "貳", "參", "肆", "伍", "陸", "柒", "捌", "玖"],
+    smallUnits: ["拾", "佰", "仟"],
+    bigUnits: [...TRAD_BIG_UNITS]
+};
+const SIMP_INFORMAL_SET = {
+    zero: "零",
+    digits: ["一", "二", "三", "四", "五", "六", "七", "八", "九"],
+    smallUnits: ["十", "百", "千"],
+    bigUnits: [...SIMP_BIG_UNITS]
+};
+const SIMP_FORMAL_SET = {
+    zero: "零",
+    digits: ["壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"],
+    smallUnits: ["拾", "佰", "仟"],
+    bigUnits: [...SIMP_BIG_UNITS]
+};
+const BIG_UNIT_ORDER = createBigUnitOrder(SIMP_BIG_UNITS);
+function normalizeInput(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        throw new SyntaxError("Empty string is not a valid number");
+    }
+    return trimmed
+        .replace(/負|负/g, "-")
+        .replace(/點|点/g, ".")
+        .replace(/無量大數/g, "无量大数")
+        .replace(/不可思議/g, "不可思议")
+        .replace(/恆河沙/g, "恒河沙")
+        .replace(/載/g, "载")
+        .replace(/極/g, "极")
+        .replace(/溝/g, "沟")
+        .replace(/澗/g, "涧")
+        .replace(/億/g, "亿")
+        .replace(/萬/g, "万")
+        .replace(/拾/g, "十")
+        .replace(/佰/g, "百")
+        .replace(/仟/g, "千");
+}
+function toBigInt(value) {
+    if (typeof value === "bigint") {
+        return value;
+    }
+    if (!Number.isFinite(value) || !Number.isInteger(value)) {
+        throw new RangeError("Expected an integer value");
+    }
+    return BigInt(value);
+}
+function parseDigitsOnly(input) {
+    let result = "";
+    for (const ch of input) {
+        const digit = CANONICAL_DIGITS[ch];
+        if (digit === undefined) {
+            throw new SyntaxError(`Unexpected character ${ch} in digit sequence`);
+        }
+        result += String(digit);
+    }
+    return BigInt(result || "0");
+}
+function parseSection(section) {
+    if (!section) {
+        return 0n;
+    }
+    if (/^[0-9]+$/.test(section)) {
+        return BigInt(section);
+    }
+    const hasSmallUnit = /十|百|千/.test(section);
+    if (!hasSmallUnit) {
+        return parseDigitsOnly(section);
+    }
+    let total = 0n;
+    let currentDigit = null;
+    for (const ch of section) {
+        if (ch in CANONICAL_DIGITS) {
+            currentDigit = BigInt(CANONICAL_DIGITS[ch]);
+            continue;
+        }
+        const unit = SMALL_UNITS[ch];
+        if (!unit) {
+            throw new SyntaxError(`Unexpected character ${ch} in section`);
+        }
+        const effectiveDigit = currentDigit ?? 1n;
+        total += effectiveDigit * unit;
+        currentDigit = null;
+    }
+    if (currentDigit !== null) {
+        total += currentDigit;
+    }
+    return total;
+}
+function parseChineseInteger(raw) {
+    if (/^[0-9]+$/.test(raw)) {
+        return BigInt(raw);
+    }
+    let rest = raw;
+    let total = 0n;
+    for (const [unitChar, unitValue] of BIG_UNIT_ORDER) {
+        const index = rest.indexOf(unitChar);
+        if (index < 0) {
+            continue;
+        }
+        const left = rest.slice(0, index);
+        const right = rest.slice(index + unitChar.length);
+        const sectionValue = left ? parseSection(left) : 1n;
+        total += sectionValue * unitValue;
+        rest = right;
+    }
+    total += parseSection(rest);
+    return total;
+}
+function parseFractionDigits(raw) {
+    if (!raw) {
+        throw new SyntaxError("Fraction part cannot be empty");
+    }
+    let decimal = "";
+    for (const ch of raw) {
+        if (/[0-9]/.test(ch)) {
+            decimal += ch;
+            continue;
+        }
+        const digit = CANONICAL_DIGITS[ch];
+        if (digit === undefined) {
+            throw new SyntaxError(`Unexpected character ${ch} in fraction part`);
+        }
+        decimal += String(digit);
+    }
+    return Number(`0.${decimal}`);
+}
+function toBestNumeric(value, preferBigInt) {
+    if (preferBigInt) {
+        return value;
+    }
+    if (value > BigInt(Number.MAX_SAFE_INTEGER) || value < BigInt(Number.MIN_SAFE_INTEGER)) {
+        return value;
+    }
+    return Number(value);
+}
+function validateStrictCharacters(input) {
+    const allowed = /^[0-9零〇○一二三四五六七八九十百千萬万億亿兆京垓秭穰溝沟澗涧正載载極极恆恒河沙阿僧祇那由他不思議议可無无量大數数點点壹貳贰參叁肆伍陸陆柒捌玖兩两拾佰仟負负.-]+$/;
+    if (!allowed.test(input)) {
+        throw new SyntaxError("Input contains unsupported characters in strict mode");
+    }
+}
+function fromCycle(value, chars, mode) {
+    const asBigInt = toBigInt(value);
+    const length = BigInt(chars.length);
+    if (mode === "fixed") {
+        if (asBigInt < 1n || asBigInt > length) {
+            throw new RangeError(`Value must be in 1..${chars.length} when mode is fixed`);
+        }
+        return chars[Number(asBigInt - 1n)];
+    }
+    const normalized = ((asBigInt - 1n) % length + length) % length;
+    return chars[Number(normalized)];
+}
+function parseCycle(input, chars, mode) {
+    const index = chars.indexOf(input);
+    if (index < 0) {
+        throw new SyntaxError(`Unknown symbol ${input}`);
+    }
+    const value = index + 1;
+    if (mode === "fixed") {
+        return value;
+    }
+    return value;
+}
+function formatSection(section, set) {
+    if (section === 0) {
+        return "";
+    }
+    const values = [1000, 100, 10, 1];
+    const units = [set.smallUnits[2], set.smallUnits[1], set.smallUnits[0], ""];
+    let output = "";
+    let pendingZero = false;
+    for (let i = 0; i < values.length; i += 1) {
+        const value = values[i];
+        const digit = Math.floor(section / value) % 10;
+        if (digit === 0) {
+            if (output) {
+                pendingZero = true;
+            }
+            continue;
+        }
+        if (pendingZero) {
+            output += set.zero;
+            pendingZero = false;
+        }
+        const isTenPosition = value === 10;
+        const canDropOne = isTenPosition && digit === 1 && output.length === 0;
+        if (!canDropOne) {
+            output += set.digits[digit - 1];
+        }
+        output += units[i];
+    }
+    return output;
+}
+function formatChineseInteger(value, set) {
+    const raw = toBigInt(value);
+    if (raw === 0n) {
+        return set.zero;
+    }
+    const negative = raw < 0n;
+    let n = negative ? -raw : raw;
+    const sections = [];
+    while (n > 0n) {
+        sections.push(Number(n % 10000n));
+        n /= 10000n;
+    }
+    let output = "";
+    let pendingZero = false;
+    for (let i = sections.length - 1; i >= 0; i -= 1) {
+        const section = sections[i];
+        if (section === 0) {
+            if (output) {
+                pendingZero = true;
+            }
+            continue;
+        }
+        if (output && (pendingZero || section < 1000)) {
+            output += set.zero;
+        }
+        output += formatSection(section, set);
+        if (i > 0) {
+            const unit = set.bigUnits[i - 1];
+            if (!unit) {
+                throw new RangeError("Value exceeds supported big unit range");
+            }
+            output += unit;
+        }
+        pendingZero = false;
+    }
+    return negative ? `負${output}` : output;
+}
+function formatDecimal(value, set) {
+    if (!Number.isFinite(value)) {
+        throw new RangeError("Expected a finite number");
+    }
+    if (Number.isInteger(value)) {
+        return formatChineseInteger(value, set);
+    }
+    const negative = value < 0;
+    const source = String(Math.abs(value));
+    const [intPart, fracPart] = source.split(".");
+    if (!fracPart) {
+        return formatChineseInteger(value, set);
+    }
+    const intText = formatChineseInteger(BigInt(intPart), set);
+    let fracText = "";
+    for (const ch of fracPart) {
+        const digit = Number(ch);
+        fracText += digit === 0 ? set.zero : set.digits[digit - 1];
+    }
+    const withSign = `${intText}點${fracText}`;
+    return negative ? `負${withSign}` : withSign;
+}
+function parseValue(input, options = {}) {
+    const modeStem = options.heavenlyStemMode ?? "fixed";
+    const modeBranch = options.earthlyBranchMode ?? "fixed";
+    const stemIndex = STEMS.indexOf(input);
+    if (stemIndex >= 0) {
+        return parseCycle(input, STEMS, modeStem);
+    }
+    const branchIndex = BRANCHES.indexOf(input);
+    if (branchIndex >= 0) {
+        return parseCycle(input, BRANCHES, modeBranch);
+    }
+    const normalized = normalizeInput(input);
+    if (options.strict) {
+        validateStrictCharacters(normalized);
+    }
+    const negative = normalized.startsWith("-");
+    const body = negative ? normalized.slice(1) : normalized;
+    if (!body) {
+        throw new SyntaxError("Missing numeric content");
+    }
+    if (body.includes(".")) {
+        const [intRaw, fracRaw] = body.split(".");
+        const intValue = intRaw ? parseChineseInteger(intRaw) : 0n;
+        const fracValue = parseFractionDigits(fracRaw ?? "");
+        if (intValue > BigInt(Number.MAX_SAFE_INTEGER)) {
+            throw new RangeError("Decimal parse does not support integer part above MAX_SAFE_INTEGER");
+        }
+        const composed = Number(intValue) + fracValue;
+        return negative ? -composed : composed;
+    }
+    const parsed = parseChineseInteger(body);
+    const signed = negative ? -parsed : parsed;
+    return toBestNumeric(signed, options.preferBigInt ?? false);
+}
+export const integer = {
+    parseInt(input, options) {
+        return parseValue(input, options);
+    }
+};
+export const cjkIdeographic = {
+    parse(value) {
+        if (typeof value === "number" && !Number.isInteger(value)) {
+            return formatDecimal(value, TRAD_INFORMAL_SET);
+        }
+        return formatChineseInteger(value, TRAD_INFORMAL_SET);
+    }
+};
+export const tradChineseInformal = {
+    parse(value) {
+        if (typeof value === "number" && !Number.isInteger(value)) {
+            return formatDecimal(value, TRAD_INFORMAL_SET);
+        }
+        return formatChineseInteger(value, TRAD_INFORMAL_SET);
+    }
+};
+export const tradChineseFormal = {
+    parse(value) {
+        if (typeof value === "number" && !Number.isInteger(value)) {
+            return formatDecimal(value, TRAD_FORMAL_SET);
+        }
+        return formatChineseInteger(value, TRAD_FORMAL_SET);
+    }
+};
+export const simpChineseInformal = {
+    parse(value) {
+        if (typeof value === "number" && !Number.isInteger(value)) {
+            return formatDecimal(value, SIMP_INFORMAL_SET);
+        }
+        return formatChineseInteger(value, SIMP_INFORMAL_SET);
+    }
+};
+export const simpChineseFormal = {
+    parse(value) {
+        if (typeof value === "number" && !Number.isInteger(value)) {
+            return formatDecimal(value, SIMP_FORMAL_SET);
+        }
+        return formatChineseInteger(value, SIMP_FORMAL_SET);
+    }
+};
+export const cjkHeavenlyStem = {
+    parse(value, options = {}) {
+        return fromCycle(value, STEMS, options.mode ?? "fixed");
+    }
+};
+export const cjkEarthlyBranch = {
+    parse(value, options = {}) {
+        return fromCycle(value, BRANCHES, options.mode ?? "fixed");
+    }
+};
+export const systems = {
+    heavenlyStem: STEMS,
+    earthlyBranch: BRANCHES
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "cjk-number",
+  "version": "0.1.0",
+  "description": "Convert between numbers and CJK number systems",
+  "author": "gary2",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gary2/cjk-number.git"
+  },
+  "bugs": {
+    "url": "https://github.com/gary2/cjk-number/issues"
+  },
+  "homepage": "https://github.com/gary2/cjk-number#readme",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "dev:test": "vitest",
+    "pack:check": "npm pack --dry-run",
+    "release:check": "npm run typecheck && npm run test && npm run build && npm run pack:check",
+    "prepublishOnly": "npm run typecheck && npm run test && npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "cjk",
+    "chinese",
+    "number"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^5.8.3",
+    "vitest": "^4.1.2"
+  }
+}