@bhsd/common 1.1.0 → 1.3.0

package/dist/index.d.ts

@@ -1,8 +1,14 @@
 declare interface JsonError {
+    severity: 'error' | 'warning';
     message: string;
-    line: number | null;
-    column: number | null;
-    position: number | null;
+    line: number;
+    column: number;
+    endLine?: number;
+    endColumn?: number;
+    from: number;
+    to?: number;
+    /** @deprecated */
+    position: number;
 }
 export type RegexGetter<T = string> = (s: T) => RegExp;
 export declare const wmf = "wiktionary|wiki(?:pedia|books|news|quote|source|versity|voyage)";
@@ -39,6 +45,17 @@ export declare function getRegex<T extends object>(f: RegexGetter<T>): RegexGett
  * @deprecated 需要改为使用`getRegex`
  */
 export declare const getObjRegex: typeof getRegex;
+/**
+ * 按行分割字符串并记录每行的起止位置
+ * @param str 字符串
+ */
+export declare const splitLines: (str: string) => [string, number, number][];
+/**
+ * 使用`JSON.parse()`诊断JSON字符串中的语法错误
+ * @param str JSON字符串
+ * @param force 是否强制诊断
+ */
+export declare const lintJSONNative: (str: string, force?: boolean) => JsonError[];
 /**
  * 诊断JSON字符串中的语法错误
  * @param str JSON字符串

package/dist/index.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lintJSON = exports.getObjRegex = exports.sanitizeInlineStyle = exports.splitColors = exports.numToHex = exports.rawurldecode = exports.wmf = void 0;
+exports.lintJSON = exports.lintJSONNative = exports.splitLines = exports.getObjRegex = exports.sanitizeInlineStyle = exports.splitColors = exports.numToHex = exports.rawurldecode = exports.wmf = void 0;
 exports.getRegex = getRegex;
+const json_parse_js_1 = require("./json_parse.js");
 exports.wmf = 'wiktionary|wiki(?:pedia|books|news|quote|source|versity|voyage)';
 /**
  * PHP的`rawurldecode`函数的JavaScript实现
@@ -72,23 +73,99 @@ function getRegex(f) {
  * @deprecated 需要改为使用`getRegex`
  */
 exports.getObjRegex = getRegex;
+/**
+ * 按行分割字符串并记录每行的起止位置
+ * @param str 字符串
+ */
+const splitLines = (str) => {
+    const lines = [];
+    let start = 0;
+    for (const line of str.split('\n')) {
+        const end = start + line.length;
+        lines.push([line, start, end]);
+        start = end + 1;
+    }
+    return lines;
+};
+exports.splitLines = splitLines;
 const mt2num = (mt) => mt && Number(mt[1]);
+const formatJsonError = (str, errors) => {
+    let lines;
+    const offsetToPosition = (offset) => {
+        lines ??= (0, exports.splitLines)(str);
+        const line = lines.findIndex(([, , end]) => offset <= end) + 1;
+        return {
+            line,
+            column: offset - lines[line - 1][1] + 1,
+        };
+    };
+    for (const error of errors) {
+        const { line, column, from, to } = error;
+        if (from === null || from === undefined) {
+            if (line) {
+                lines ??= (0, exports.splitLines)(str);
+                error.column ??= 1;
+                error.from = lines[line - 1][1] + (error.column - 1);
+            }
+            else {
+                error.from = 0;
+                error.line = 1;
+                error.column = 1;
+            }
+        }
+        else if (!line || !column) {
+            Object.assign(error, offsetToPosition(from));
+        }
+        if (to !== undefined) {
+            ({ line: error.endLine, column: error.endColumn } = offsetToPosition(to));
+        }
+        error.position = error.from;
+    }
+    return errors;
+};
+/**
+ * 使用`JSON.parse()`诊断JSON字符串中的语法错误
+ * @param str JSON字符串
+ * @param force 是否强制诊断
+ */
+const lintJSONNative = (str, force) => {
+    if (force || str.trim()) {
+        try {
+            JSON.parse(str);
+        }
+        catch (e) {
+            const { message } = e, line = mt2num(/\bline (\d+)/u.exec(message)), column = mt2num(/\bcolumn (\d+)/u.exec(message)), from = mt2num(/\bposition (\d+)/u.exec(message));
+            return formatJsonError(str, [{ message, line, column, from, severity: 'error' }]);
+        }
+    }
+    return [];
+};
+exports.lintJSONNative = lintJSONNative;
 /**
  * 诊断JSON字符串中的语法错误
  * @param str JSON字符串
  */
 const lintJSON = (str) => {
+    if (!str.trim()) {
+        return [];
+    }
+    let errors;
     try {
-        if (str.trim()) {
-            JSON.parse(str);
-        }
+        (0, json_parse_js_1.json_parse)(str);
     }
     catch (e) {
-        if (e instanceof SyntaxError) {
-            const { message } = e, line = mt2num(/\bline (\d+)/u.exec(message)), column = mt2num(/\bcolumn (\d+)/u.exec(message)), position = mt2num(/\bposition (\d+)/u.exec(message));
-            return [{ message, line, column, position }];
+        if (!(e instanceof Error)) {
+            const { warnings, ...error } = e;
+            if (error.message) {
+                warnings.push(error);
+            }
+            errors = formatJsonError(str, warnings);
+            if (error.message) {
+                return errors;
+            }
         }
     }
-    return [];
+    const nativeErrors = (0, exports.lintJSONNative)(str);
+    return errors ? [...nativeErrors, ...errors] : nativeErrors;
 };
 exports.lintJSON = lintJSON;

package/dist/index.mjs

@@ -1,14 +1,293 @@
-const wmf = "wiktionary|wiki(?:pedia|books|news|quote|source|versity|voyage)";
-const rawurldecode = (str) => decodeURIComponent(str.replace(/%(?![\da-f]{2})/giu, "%25"));
-const numToHex = (d) => Math.round(d * 255).toString(16).padStart(2, "0");
-const regex = /* @__PURE__ */ (() => {
+// src/json_parse.ts
+var escapee = {
+  '"': '"',
+  "\\": "\\",
+  "/": "/",
+  b: "\b",
+  f: "\f",
+  n: "\n",
+  r: "\r",
+  t: "	"
+};
+var spaces = /* @__PURE__ */ new Set([" ", "	", "\n", "\r"]);
+var stringify = (c) => {
+  if (c === "") {
+    return "end of input";
+  }
+  return c === '"' ? `'"'` : JSON.stringify(c);
+};
+var json_parse = /* @__PURE__ */ (() => {
+  let at;
+  let ch;
+  let text;
+  let warnings;
+  const prepareError = (e, from, to) => {
+    if (from === void 0) {
+      e.from = at - 1;
+    } else {
+      e.from = from;
+      e.to = to ?? at - 1;
+    }
+  };
+  const warn = (message, from, to) => {
+    const warning = {
+      message,
+      severity: "warning"
+    };
+    prepareError(warning, from, to);
+    warnings.push(warning);
+  };
+  const error = (message, from, to) => {
+    const e = {
+      warnings,
+      message,
+      severity: "error"
+    };
+    prepareError(e, from, to);
+    throw e;
+  };
+  const next = (c) => {
+    if (c && c !== ch) {
+      error(`Expected ${stringify(c)} instead of ${stringify(ch)}`);
+    }
+    ch = text.charAt(at);
+    at++;
+    return ch;
+  };
+  const number = () => {
+    let string2 = "";
+    const from = at - 1;
+    if (ch === "-") {
+      string2 = "-";
+      next();
+    }
+    if (ch === "0") {
+      string2 += ch;
+      next();
+      if (ch >= "0" && ch <= "9") {
+        error("Bad number");
+      }
+    } else if (ch >= "1" && ch <= "9") {
+      while (ch >= "0" && ch <= "9") {
+        string2 += ch;
+        next();
+      }
+    } else {
+      error("No number after minus sign");
+    }
+    if (ch !== "." && ch !== "e" && ch !== "E") {
+      const value3 = Number(string2);
+      if (!Number.isSafeInteger(value3)) {
+        warn("Not a safe integer", from);
+      }
+      return;
+    }
+    if (ch === ".") {
+      string2 += ".";
+      next();
+      if (ch < "0" || ch > "9") {
+        error("Unterminated fractional number");
+      }
+      while (ch >= "0" && ch <= "9") {
+        string2 += ch;
+        next();
+      }
+    }
+    if (ch === "e" || ch === "E") {
+      string2 += ch;
+      next();
+      if (ch === "-" || ch === "+") {
+        string2 += ch;
+        next();
+      }
+      while (ch >= "0" && ch <= "9") {
+        string2 += ch;
+        next();
+      }
+    }
+    const value2 = Number(string2);
+    if (!Number.isFinite(value2)) {
+      error("Bad number");
+    }
+  };
+  const string = () => {
+    let value2 = "";
+    if (ch === '"') {
+      while (next()) {
+        if (ch === '"') {
+          next();
+          return value2;
+        }
+        const from = at - 1;
+        if (ch === "\\") {
+          next();
+          if (ch === "u") {
+            let i = 0;
+            let uffff = 0;
+            for (; i < 4; i++) {
+              const hex = parseInt(next(), 16);
+              if (!isFinite(hex)) {
+                break;
+              }
+              uffff = uffff * 16 + hex;
+            }
+            if (i < 4) {
+              error("Bad unicode escape", from);
+            }
+            value2 += String.fromCharCode(uffff);
+          } else if (typeof escapee[ch] === "string") {
+            value2 += escapee[ch];
+          } else {
+            error("Bad escaped character", from, at);
+          }
+        } else if (ch < " ") {
+          error("Bad control character", from, at);
+        } else {
+          value2 += ch;
+        }
+      }
+    } else {
+      error(`Expected '"' instead of ${JSON.stringify(ch)}`);
+    }
+    return error("Unterminated string");
+  };
+  const white = () => {
+    while (ch && spaces.has(ch)) {
+      next();
+    }
+  };
+  const word = () => {
+    switch (ch) {
+      case "t":
+        next();
+        next("r");
+        next("u");
+        next("e");
+        return;
+      case "f":
+        next();
+        next("a");
+        next("l");
+        next("s");
+        next("e");
+        return;
+      case "n":
+        next();
+        next("u");
+        next("l");
+        next("l");
+        return;
+      default:
+        error(`Unexpected ${JSON.stringify(ch)}`);
+    }
+  };
+  const array = () => {
+    next();
+    white();
+    if (ch === "]") {
+      next();
+      return;
+    }
+    let from;
+    while (ch) {
+      if (ch === "]") {
+        error("Trailing comma in array", from, from + 1);
+      }
+      value();
+      white();
+      if (ch === "]") {
+        next();
+        return;
+      } else if (ch === ",") {
+        from = at - 1;
+        next();
+        white();
+      } else {
+        error(`Expected "," or "]" instead of ${stringify(ch)}`);
+      }
+    }
+    error("Unterminated array");
+  };
+  const object = () => {
+    const keys = /* @__PURE__ */ new Set();
+    next();
+    white();
+    if (ch === "}") {
+      next();
+      return;
+    }
+    let from;
+    while (ch) {
+      if (ch === "}") {
+        error("Trailing comma in object", from, from + 1);
+      }
+      from = at;
+      const key = string();
+      const to = at - 2;
+      white();
+      next(":");
+      if (keys.has(key)) {
+        warn(`Duplicate key ${stringify(key)}`, from, to);
+      } else {
+        keys.add(key);
+      }
+      value();
+      white();
+      if (ch === "}") {
+        next();
+        return;
+      } else if (ch === ",") {
+        from = at - 1;
+        next();
+        white();
+      } else {
+        error(`Expected "," or "}" instead of ${stringify(ch)}`);
+      }
+    }
+    error(`Expected '"'`);
+  };
+  const value = () => {
+    white();
+    switch (ch) {
+      case "{":
+        return object();
+      case "[":
+        return array();
+      case '"':
+        return string();
+      case "-":
+        return number();
+      default:
+        return ch >= "0" && ch <= "9" ? number() : word();
+    }
+  };
+  return (source) => {
+    text = source;
+    warnings = [];
+    at = 0;
+    ch = " ";
+    value();
+    white();
+    if (ch) {
+      error("Syntax error");
+    } else if (warnings.length > 0) {
+      throw { warnings };
+    }
+  };
+})();
+
+// src/index.ts
+var wmf = "wiktionary|wiki(?:pedia|books|news|quote|source|versity|voyage)";
+var rawurldecode = (str) => decodeURIComponent(str.replace(/%(?![\da-f]{2})/giu, "%25"));
+var numToHex = (d) => Math.round(d * 255).toString(16).padStart(2, "0");
+var regex = /* @__PURE__ */ (() => {
   const hexColor = String.raw`#(?:[\da-f]{3,4}|(?:[\da-f]{2}){3,4})(?![\p{L}\p{N}_])`, rgbValue = String.raw`(?:\d*\.)?\d+%?`, hue = String.raw`(?:\d*\.)?\d+(?:deg|grad|rad|turn)?`, rgbColor = String.raw`rgba?\(\s*(?:${String.raw`${new Array(3).fill(rgbValue).join(String.raw`\s+`)}(?:\s*\/\s*${rgbValue})?`}|${String.raw`${new Array(3).fill(rgbValue).join(String.raw`\s*,\s*`)}(?:\s*,\s*${rgbValue})?`})\s*\)`, hslColor = String.raw`hsla?\(\s*(?:${String.raw`${hue}\s+${rgbValue}\s+${rgbValue}(?:\s*\/\s*${rgbValue})?`}|${String.raw`${hue}${String.raw`\s*,\s*(?:\d*\.)?\d+%`.repeat(2)}(?:\s*,\s*${rgbValue})?`})\s*\)`;
   return {
     full: new RegExp(String.raw`(^|[^\p{L}\p{N}_])(${hexColor}|${rgbColor}|${hslColor})`, "giu"),
     rgb: new RegExp(String.raw`(^|[^\p{L}\p{N}_])(${hexColor}|${rgbColor})`, "giu")
   };
 })();
-const splitColors = (str, hsl = true) => {
+var splitColors = (str, hsl = true) => {
   const pieces = [], re = regex[hsl ? "full" : "rgb"];
   re.lastIndex = 0;
   let mt = re.exec(str), lastIndex = 0;
@@ -26,7 +305,7 @@ const splitColors = (str, hsl = true) => {
   }
   return pieces;
 };
-const sanitizeInlineStyle = (style) => style.replace(/[{}]/gu, (p) => p === "{" ? "｛" : "｝");
+var sanitizeInlineStyle = (style) => style.replace(/[{}]/gu, (p) => p === "{" ? "｛" : "｝");
 function getRegex(f) {
   const map = /* @__PURE__ */ new Map(), weakMap = /* @__PURE__ */ new WeakMap();
   return (s) => {
@@ -41,28 +320,92 @@ function getRegex(f) {
     return re;
   };
 }
-const getObjRegex = getRegex;
-const mt2num = (mt) => mt && Number(mt[1]);
-const lintJSON = (str) => {
-  try {
-    if (str.trim()) {
+var getObjRegex = getRegex;
+var splitLines = (str) => {
+  const lines = [];
+  let start = 0;
+  for (const line of str.split("\n")) {
+    const end = start + line.length;
+    lines.push([line, start, end]);
+    start = end + 1;
+  }
+  return lines;
+};
+var mt2num = (mt) => mt && Number(mt[1]);
+var formatJsonError = (str, errors) => {
+  let lines;
+  const offsetToPosition = (offset) => {
+    lines ??= splitLines(str);
+    const line = lines.findIndex(([, , end]) => offset <= end) + 1;
+    return {
+      line,
+      column: offset - lines[line - 1][1] + 1
+    };
+  };
+  for (const error of errors) {
+    const { line, column, from, to } = error;
+    if (from === null || from === void 0) {
+      if (line) {
+        lines ??= splitLines(str);
+        error.column ??= 1;
+        error.from = lines[line - 1][1] + (error.column - 1);
+      } else {
+        error.from = 0;
+        error.line = 1;
+        error.column = 1;
+      }
+    } else if (!line || !column) {
+      Object.assign(error, offsetToPosition(from));
+    }
+    if (to !== void 0) {
+      ({ line: error.endLine, column: error.endColumn } = offsetToPosition(to));
+    }
+    error.position = error.from;
+  }
+  return errors;
+};
+var lintJSONNative = (str, force) => {
+  if (force || str.trim()) {
+    try {
       JSON.parse(str);
+    } catch (e) {
+      const { message } = e, line = mt2num(/\bline (\d+)/u.exec(message)), column = mt2num(/\bcolumn (\d+)/u.exec(message)), from = mt2num(/\bposition (\d+)/u.exec(message));
+      return formatJsonError(str, [{ message, line, column, from, severity: "error" }]);
     }
+  }
+  return [];
+};
+var lintJSON = (str) => {
+  if (!str.trim()) {
+    return [];
+  }
+  let errors;
+  try {
+    json_parse(str);
   } catch (e) {
-    if (e instanceof SyntaxError) {
-      const { message } = e, line = mt2num(/\bline (\d+)/u.exec(message)), column = mt2num(/\bcolumn (\d+)/u.exec(message)), position = mt2num(/\bposition (\d+)/u.exec(message));
-      return [{ message, line, column, position }];
+    if (!(e instanceof Error)) {
+      const { warnings, ...error } = e;
+      if (error.message) {
+        warnings.push(error);
+      }
+      errors = formatJsonError(str, warnings);
+      if (error.message) {
+        return errors;
+      }
     }
   }
-  return [];
+  const nativeErrors = lintJSONNative(str);
+  return errors ? [...nativeErrors, ...errors] : nativeErrors;
 };
 export {
   getObjRegex,
   getRegex,
   lintJSON,
+  lintJSONNative,
   numToHex,
   rawurldecode,
   sanitizeInlineStyle,
   splitColors,
+  splitLines,
   wmf
 };

package/dist/json_parse.js

@@ -0,0 +1,344 @@
+"use strict";
+/*
+    json_parse.js
+    2016-05-02
+
+    Public Domain.
+
+    NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
+
+    This file creates a json_parse function.
+
+        json_parse(text)
+            This method parses a JSON text and throws a SyntaxError exception.
+
+    This is a reference implementation. You are free to copy, modify, or redistribute.
+
+    Original source:
+        https://github.com/douglascrockford/JSON-js/blob/107fc93c94aa3a9c7b48548631593ecf3aac60d2/json_parse.js
+
+    Modifications:
+        - Only returns errors and warnings instead of the parsed value.
+        - Better agreement with JSON specification.
+        - Warnings for duplicate object keys and unsafe integers.
+
+    This code should be minified before deployment.
+    See http://javascript.crockford.com/jsmin.html
+
+    USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO NOT CONTROL.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.json_parse = void 0;
+const escapee = {
+    '"': '"',
+    "\\": "\\",
+    "/": "/",
+    b: "\b",
+    f: "\f",
+    n: "\n",
+    r: "\r",
+    t: "\t",
+};
+const spaces = new Set([" ", "\t", "\n", "\r"]);
+const stringify = (c) => {
+    if (c === "") {
+        return "end of input";
+    }
+    return c === '"' ? `'"'` : JSON.stringify(c);
+};
+exports.json_parse = (() => {
+    // This is a function that can parse a JSON text.
+    // It is a simple, recursive descent parser.
+    // It does not use eval or regular expressions,
+    // so it can be used as a model for implementing a JSON parser in other languages.
+    // We are defining the function inside of another function to avoid creating global variables.
+    let at; // The index of the current character
+    let ch; // The current character
+    let text;
+    let warnings;
+    const prepareError = (e, from, to) => {
+        if (from === undefined) {
+            e.from = at - 1;
+        }
+        else {
+            e.from = from;
+            e.to = to ?? at - 1;
+        }
+    };
+    const warn = (message, from, to) => {
+        // Log warning when something is wrong.
+        const warning = {
+            message,
+            severity: "warning",
+        };
+        prepareError(warning, from, to);
+        warnings.push(warning);
+    };
+    const error = (message, from, to) => {
+        // Call error when something is wrong.
+        const e = {
+            warnings,
+            message,
+            severity: "error",
+        };
+        prepareError(e, from, to);
+        throw e;
+    };
+    const next = (c) => {
+        // If a c parameter is provided, verify that it matches the current character.
+        if (c && c !== ch) {
+            error(`Expected ${stringify(c)} instead of ${stringify(ch)}`);
+        }
+        // Get the next character. When there are no more characters, return the empty string.
+        ch = text.charAt(at);
+        at++;
+        return ch;
+    };
+    const number = () => {
+        // Parse a number value.
+        let string = "";
+        const from = at - 1;
+        if (ch === "-") {
+            string = "-";
+            next();
+        }
+        if (ch === "0") {
+            string += ch;
+            next();
+            if (ch >= "0" && ch <= "9") {
+                error("Bad number");
+            }
+        }
+        else if (ch >= "1" && ch <= "9") {
+            while (ch >= "0" && ch <= "9") {
+                string += ch;
+                next();
+            }
+        }
+        else {
+            error("No number after minus sign");
+        }
+        if (ch !== "." && ch !== "e" && ch !== "E") {
+            const value = Number(string);
+            if (!Number.isSafeInteger(value)) {
+                warn("Not a safe integer", from);
+            }
+            return;
+        }
+        if (ch === ".") {
+            string += ".";
+            next();
+            if (ch < "0" || ch > "9") {
+                error("Unterminated fractional number");
+            }
+            while (ch >= "0" && ch <= "9") {
+                string += ch;
+                next();
+            }
+        }
+        if (ch === "e" || ch === "E") {
+            string += ch;
+            next();
+            // @ts-expect-error `ch` modified
+            if (ch === "-" || ch === "+") {
+                string += ch;
+                next();
+            }
+            while (ch >= "0" && ch <= "9") {
+                string += ch;
+                next();
+            }
+        }
+        const value = Number(string);
+        if (!Number.isFinite(value)) {
+            error("Bad number");
+        }
+    };
+    const string = () => {
+        // Parse a string value.
+        let value = "";
+        // When parsing for string values, we must look for " and \ characters.
+        if (ch === '"') {
+            while (next()) {
+                if (ch === '"') {
+                    next();
+                    return value;
+                }
+                const from = at - 1;
+                if (ch === "\\") {
+                    next();
+                    if (ch === "u") {
+                        let i = 0;
+                        let uffff = 0;
+                        for (; i < 4; i++) {
+                            const hex = parseInt(next(), 16);
+                            if (!isFinite(hex)) {
+                                break;
+                            }
+                            uffff = uffff * 16 + hex;
+                        }
+                        if (i < 4) {
+                            error("Bad unicode escape", from);
+                        }
+                        value += String.fromCharCode(uffff);
+                    }
+                    else if (typeof escapee[ch] === "string") {
+                        value += escapee[ch];
+                    }
+                    else {
+                        error("Bad escaped character", from, at);
+                    }
+                }
+                else if (ch < " ") {
+                    error("Bad control character", from, at);
+                }
+                else {
+                    value += ch;
+                }
+            }
+        }
+        else {
+            error(`Expected '"' instead of ${JSON.stringify(ch)}`);
+        }
+        return error("Unterminated string");
+    };
+    const white = () => {
+        // Skip whitespace.
+        while (ch && spaces.has(ch)) {
+            next();
+        }
+    };
+    const word = () => {
+        // true, false, or null.
+        switch (ch) {
+            case "t":
+                next();
+                next("r");
+                next("u");
+                next("e");
+                return;
+            case "f":
+                next();
+                next("a");
+                next("l");
+                next("s");
+                next("e");
+                return;
+            case "n":
+                next();
+                next("u");
+                next("l");
+                next("l");
+                return;
+            default:
+                error(`Unexpected ${JSON.stringify(ch)}`);
+        }
+    };
+    const array = () => {
+        // Parse an array value.
+        next();
+        white();
+        if (ch === "]") {
+            next();
+            return; // empty array
+        }
+        let from;
+        while (ch) {
+            if (ch === "]") {
+                error("Trailing comma in array", from, from + 1);
+            }
+            value();
+            white();
+            if (ch === "]") {
+                next();
+                return;
+            }
+            else if (ch === ",") {
+                from = at - 1;
+                next();
+                white();
+            }
+            else {
+                error(`Expected "," or "]" instead of ${stringify(ch)}`);
+            }
+        }
+        error("Unterminated array");
+    };
+    const object = () => {
+        // Parse an object value.
+        const keys = new Set();
+        next();
+        white();
+        if (ch === "}") {
+            next();
+            return; // empty object
+        }
+        let from;
+        while (ch) {
+            if (ch === "}") {
+                error("Trailing comma in object", from, from + 1);
+            }
+            from = at;
+            const key = string();
+            const to = at - 2;
+            white();
+            next(":");
+            if (keys.has(key)) {
+                warn(`Duplicate key ${stringify(key)}`, from, to);
+            }
+            else {
+                keys.add(key);
+            }
+            value();
+            white();
+            if (ch === "}") {
+                next();
+                return;
+            }
+            else if (ch === ",") {
+                from = at - 1;
+                next();
+                white();
+            }
+            else {
+                error(`Expected "," or "}" instead of ${stringify(ch)}`);
+            }
+        }
+        error(`Expected '"'`);
+    };
+    const value = () => {
+        // Parse a JSON value. It could be an object, an array, a string, a number,
+        // or a word.
+        white();
+        switch (ch) {
+            case "{":
+                return object();
+            case "[":
+                return array();
+            case '"':
+                return string();
+            case "-":
+                return number();
+            default:
+                return ch >= "0" && ch <= "9"
+                    ? number()
+                    : word();
+        }
+    };
+    // Return the json_parse function. It will have access to all of the above
+    // functions and variables.
+    return (source) => {
+        text = source;
+        warnings = [];
+        at = 0;
+        ch = " ";
+        value();
+        white();
+        if (ch) {
+            error("Syntax error");
+        }
+        else if (warnings.length > 0) {
+            throw { warnings };
+        }
+    };
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@bhsd/common",
-	"version": "1.1.0",
+	"version": "1.3.0",
 	"homepage": "https://github.com/bhsd-harry/common#readme",
 	"bugs": {
 		"url": "https://github.com/bhsd-harry/common/issues"
@@ -8,7 +8,9 @@
 	"license": "MIT",
 	"author": "Bhsd",
 	"files": [
-		"/dist/"
+		"/dist/*.js",
+		"/dist/index.mjs",
+		"/dist/index.d.ts"
 	],
 	"exports": {
 		".": {
@@ -21,13 +23,15 @@
 	"sideEffects": false,
 	"scripts": {
 		"prepublishOnly": "npm run build",
-		"build": "tsc && esbuild src/index.ts --charset=utf8 --target=es2024 --format=esm --outfile=dist/index.mjs",
+		"build": "tsc && esbuild src/index.ts --charset=utf8 --target=es2024 --bundle --format=esm --outfile=dist/index.mjs && cp dist/index.d.ts dist/index.d.mts",
 		"lint:ts": "tsc --noEmit && eslint --cache .",
-		"lint": "npm run lint:ts"
+		"lint": "npm run lint:ts",
+		"test": "mocha"
 	},
 	"devDependencies": {
 		"@bhsd/code-standard": "^1.3.2",
 		"@stylistic/eslint-plugin": "^5.5.0",
+		"@types/mocha": "^10.0.10",
 		"@typescript-eslint/eslint-plugin": "^8.46.4",
 		"@typescript-eslint/parser": "^8.46.4",
 		"esbuild": "^0.25.12",
@@ -39,6 +43,7 @@
 		"eslint-plugin-promise": "^7.2.1",
 		"eslint-plugin-regexp": "^2.10.0",
 		"eslint-plugin-unicorn": "^62.0.0",
+		"mocha": "^11.7.5",
 		"typescript": "^5.9.3"
 	},
 	"engines": {