json-brook 0.0.1

package/dist/lib/index.js

@@ -0,0 +1,788 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createJsonBrook: () => createJsonBrook
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/create-parser.ts
+function createParser() {
+  const root = {
+    type: "Root",
+    value: null
+  };
+  let currentRef = root;
+  const getRoot = () => root.value;
+  const write = (token) => {
+    switch (currentRef.type) {
+      case "Root":
+        if (currentRef.value === null) {
+          if (token.type === "Keyword") {
+            currentRef.value = {
+              type: "Literal",
+              value: token.value
+            };
+            return;
+          }
+          if (token.type === "String") {
+            currentRef.value = {
+              type: "Literal",
+              value: token.value
+            };
+            return;
+          }
+          if (token.type === "Number") {
+            currentRef.value = {
+              type: "Literal",
+              value: token.value
+            };
+            return;
+          }
+          if (token.type === "Symbol" && token.value === "[") {
+            currentRef.value = {
+              type: "Array",
+              children: [],
+              state: 0 /* Start */,
+              parent: currentRef,
+              current: null
+            };
+            currentRef = currentRef.value;
+            return;
+          }
+          if (token.type === "Symbol" && token.value === "{") {
+            currentRef.value = {
+              type: "Object",
+              children: [],
+              state: 0 /* Start */,
+              parent: currentRef,
+              current: null
+            };
+            currentRef = currentRef.value;
+            return;
+          }
+        }
+        throw new Error("解析错误");
+      case "Array":
+        switch (currentRef.state) {
+          case 0 /* Start */:
+            if (token.type === "Symbol" && token.value === "]") {
+              switch (currentRef.parent.type) {
+                case "Root":
+                  return;
+                case "Array":
+                  currentRef.parent.children.push(currentRef);
+                  currentRef.parent.current = null;
+                  currentRef = currentRef.parent;
+                  return;
+                case "Property":
+                  currentRef.parent.value = currentRef;
+                  currentRef = currentRef.parent;
+                  currentRef.parent.children.push(currentRef);
+                  currentRef.parent.current = null;
+                  currentRef = currentRef.parent;
+                  return;
+              }
+            }
+            if (token.type === "Keyword") {
+              currentRef.state = 1 /* Value */;
+              currentRef.children.push({
+                type: "Literal",
+                value: token.value
+              });
+              return;
+            }
+            if (token.type === "String") {
+              currentRef.state = 1 /* Value */;
+              currentRef.children.push({
+                type: "Literal",
+                value: token.value
+              });
+              return;
+            }
+            if (token.type === "Number") {
+              currentRef.state = 1 /* Value */;
+              currentRef.children.push({
+                type: "Literal",
+                value: token.value
+              });
+              return;
+            }
+            if (token.type === "Symbol" && token.value === "[") {
+              currentRef.state = 1 /* Value */;
+              currentRef.current = {
+                type: "Array",
+                children: [],
+                state: 0 /* Start */,
+                parent: currentRef,
+                current: null
+              };
+              currentRef = currentRef.current;
+              return;
+            }
+            if (token.type === "Symbol" && token.value === "{") {
+              currentRef.state = 1 /* Value */;
+              currentRef.current = {
+                type: "Object",
+                children: [],
+                state: 0 /* Start */,
+                parent: currentRef,
+                current: null
+              };
+              return;
+            }
+            throw new Error("解析错误");
+          case 1 /* Value */:
+            if (token.type === "Symbol" && token.value === "]") {
+              switch (currentRef.parent.type) {
+                case "Root":
+                  return;
+                case "Array":
+                  currentRef.parent.children.push(currentRef);
+                  currentRef.parent.current = null;
+                  currentRef = currentRef.parent;
+                  return;
+                case "Property":
+                  currentRef.parent.value = currentRef;
+                  currentRef = currentRef.parent;
+                  currentRef.parent.children.push(currentRef);
+                  currentRef.parent.current = null;
+                  currentRef = currentRef.parent;
+                  return;
+              }
+            }
+            if (token.type === "Symbol" && token.value === ",") {
+              currentRef.state = 2 /* Comma */;
+              return;
+            }
+            throw new Error("解析错误");
+          case 2 /* Comma */:
+            if (token.type === "Keyword") {
+              currentRef.state = 1 /* Value */;
+              currentRef.children.push({
+                type: "Literal",
+                value: token.value
+              });
+              return;
+            }
+            if (token.type === "String") {
+              currentRef.state = 1 /* Value */;
+              currentRef.children.push({
+                type: "Literal",
+                value: token.value
+              });
+              return;
+            }
+            if (token.type === "Number") {
+              currentRef.state = 1 /* Value */;
+              currentRef.children.push({
+                type: "Literal",
+                value: token.value
+              });
+              return;
+            }
+            if (token.type === "Symbol" && token.value === "[") {
+              currentRef.state = 1 /* Value */;
+              currentRef.current = {
+                type: "Array",
+                children: [],
+                state: 0 /* Start */,
+                parent: currentRef,
+                current: null
+              };
+              currentRef = currentRef.current;
+              return;
+            }
+            if (token.type === "Symbol" && token.value === "{") {
+              currentRef.state = 1 /* Value */;
+              currentRef.current = {
+                type: "Object",
+                children: [],
+                state: 0 /* Start */,
+                parent: currentRef,
+                current: null
+              };
+              return;
+            }
+            throw new Error("解析错误");
+        }
+      case "Property":
+        switch (currentRef.state) {
+          case 0 /* Key */:
+            if (token.type === "Symbol" && token.value === ":") {
+              currentRef.state = 1 /* Colon */;
+              return;
+            }
+            throw new Error("解析错误");
+          case 1 /* Colon */:
+            if (token.type === "Keyword") {
+              currentRef.state = 2 /* Value */;
+              currentRef.value = {
+                type: "Literal",
+                value: token.value
+              };
+              currentRef.parent.children.push(currentRef);
+              currentRef.parent.current = null;
+              currentRef = currentRef.parent;
+              return;
+            }
+            if (token.type === "String") {
+              currentRef.state = 2 /* Value */;
+              currentRef.value = {
+                type: "Literal",
+                value: token.value
+              };
+              currentRef.parent.children.push(currentRef);
+              currentRef.parent.current = null;
+              currentRef = currentRef.parent;
+              return;
+            }
+            if (token.type === "Number") {
+              currentRef.state = 2 /* Value */;
+              currentRef.value = {
+                type: "Literal",
+                value: token.value
+              };
+              currentRef.parent.children.push(currentRef);
+              currentRef.parent.current = null;
+              currentRef = currentRef.parent;
+              return;
+            }
+            if (token.type === "Symbol" && token.value === "[") {
+              currentRef.state = 2 /* Value */;
+              currentRef.value = {
+                type: "Array",
+                children: [],
+                state: 0 /* Start */,
+                parent: currentRef,
+                current: null
+              };
+              currentRef = currentRef.value;
+              return;
+            }
+            if (token.type === "Symbol" && token.value === "{") {
+              currentRef.state = 2 /* Value */;
+              currentRef.value = {
+                type: "Object",
+                children: [],
+                state: 0 /* Start */,
+                parent: currentRef,
+                current: null
+              };
+              currentRef = currentRef.value;
+              return;
+            }
+            throw new Error("解析错误");
+        }
+      case "Object":
+        switch (currentRef.state) {
+          case 0 /* Start */:
+            if (token.type === "String") {
+              currentRef.state = 1 /* Property */;
+              currentRef.current = {
+                type: "Property",
+                key: {
+                  type: "Identifier",
+                  value: token.value
+                },
+                value: null,
+                state: 0 /* Key */,
+                parent: currentRef
+              };
+              currentRef = currentRef.current;
+              return;
+            }
+            if (token.type === "Symbol" && token.value === "}") {
+              switch (currentRef.parent.type) {
+                case "Root":
+                  return;
+                case "Array":
+                  currentRef.parent.children.push(currentRef);
+                  currentRef.parent.current = null;
+                  currentRef = currentRef.parent;
+                  return;
+                case "Property":
+                  currentRef.parent.value = currentRef;
+                  currentRef = currentRef.parent;
+                  currentRef.parent.children.push(currentRef);
+                  currentRef.parent.current = null;
+                  currentRef = currentRef.parent;
+                  return;
+              }
+            }
+            throw new Error("解析错误");
+          case 1 /* Property */:
+            if (token.type === "Symbol" && token.value === "}") {
+              switch (currentRef.parent.type) {
+                case "Root":
+                  return;
+                case "Array":
+                  currentRef.parent.children.push(currentRef);
+                  currentRef.parent.current = null;
+                  currentRef = currentRef.parent;
+                  return;
+                case "Property":
+                  currentRef.parent.value = currentRef;
+                  currentRef = currentRef.parent;
+                  currentRef.parent.children.push(currentRef);
+                  currentRef.parent.current = null;
+                  currentRef = currentRef.parent;
+                  return;
+              }
+            }
+            if (token.type === "Symbol" && token.value === ",") {
+              currentRef.state = 2 /* Comma */;
+              return;
+            }
+            throw new Error("解析错误");
+          case 2 /* Comma */:
+            if (token.type === "String") {
+              currentRef.state = 1 /* Property */;
+              currentRef.current = {
+                type: "Property",
+                key: {
+                  type: "Identifier",
+                  value: token.value
+                },
+                value: null,
+                state: 0 /* Key */,
+                parent: currentRef
+              };
+              currentRef = currentRef.current;
+              return;
+            }
+            throw new Error("解析错误");
+        }
+    }
+  };
+  return {
+    getRoot,
+    write
+  };
+}
+
+// src/create-tokenize.ts
+var whiteSpaces = [" ", "	", "\n", "\r"];
+var symbols = ["{", "}", "[", "]", ":", ","];
+var keywords = ["true", "false", "null"];
+var keywordsStart = keywords.map((keyword) => keyword.charAt(0));
+var escapes = ['"', "\\", "/", "b", "f", "n", "r", "t"];
+var hexEscape = "u";
+var flags = ["+", "-"];
+function isDigit(char) {
+  return char >= "0" && char <= "9";
+}
+function isDigitNotZero(char) {
+  return char >= "1" && char <= "9";
+}
+function isHex(char) {
+  return isDigit(char) || char >= "a" && char <= "f" || char >= "A" && char <= "F";
+}
+function isExp(char) {
+  return char === "e" || char === "E";
+}
+function createTokenize() {
+  let current = null;
+  const write = (char) => {
+    if (current) {
+      switch (current.type) {
+        case "Keyword":
+          if (char === keywords[current.matchedIndex + 1]) {
+            current.matchedIndex++;
+            if (current.matchedIndex === current.value.length - 1) {
+              const token = {
+                type: "Keyword",
+                value: JSON.parse(current.value)
+              };
+              current = null;
+              return token;
+            }
+            return null;
+          }
+          throw new Error("解析失败");
+        case "String":
+          switch (current.state) {
+            case 0 /* Normal */:
+              switch (char) {
+                case '"': {
+                  current.value += char;
+                  const token = {
+                    type: "String",
+                    value: JSON.parse(current.value)
+                  };
+                  current = null;
+                  return token;
+                }
+                case "\\":
+                  current.state = 1 /* Escape */;
+                  current.value += char;
+                  current.escapeIndex = 0;
+                  return null;
+                default:
+                  current.value += char;
+                  return null;
+              }
+            case 1 /* Escape */: {
+              if (current.escapeIndex === 0) {
+                if (escapes.includes(char)) {
+                  current.state = 0 /* Normal */;
+                  current.value += char;
+                  return null;
+                }
+                if (char === hexEscape) {
+                  current.value += char;
+                  current.escapeIndex++;
+                  return null;
+                }
+                throw new Error("解析失败");
+              } else {
+                if (isHex(char)) {
+                  if (current.escapeIndex === 4) {
+                    current.state = 0 /* Normal */;
+                    current.value += char;
+                    return null;
+                  } else {
+                    current.value += char;
+                    current.escapeIndex++;
+                    return null;
+                  }
+                } else {
+                  throw new Error("解析失败");
+                }
+              }
+            }
+          }
+        case "Number":
+          switch (current.state) {
+            case 1 /* Negative */:
+              if (char === "0") {
+                current.state = 2 /* Zero */;
+                current.value += char;
+                current.passed = true;
+                return null;
+              }
+              if (isDigitNotZero(char)) {
+                current.state = 3 /* Digit */;
+                current.value += char;
+                current.passed = true;
+                return null;
+              }
+              throw new Error("解析失败");
+            case 2 /* Zero */:
+              if (char === ".") {
+                current.state = 4 /* Point */;
+                current.value += char;
+                current.passed = false;
+                return null;
+              }
+              if (isExp(char)) {
+                current.state = 6 /* Exp */;
+                current.value += char;
+                current.passed = false;
+                return null;
+              }
+              if (current.passed) {
+                const token = {
+                  type: "Number",
+                  value: JSON.parse(current.value)
+                };
+                current = null;
+                const next = write(char);
+                if (next) {
+                  return Array.isArray(next) ? [token, ...next] : [token, next];
+                } else {
+                  return token;
+                }
+              }
+              throw new Error("解析失败");
+            case 3 /* Digit */:
+              if (isDigit(char)) {
+                current.value += char;
+                current.passed = true;
+                return null;
+              }
+              if (char === ".") {
+                current.state = 4 /* Point */;
+                current.value += char;
+                current.passed = false;
+                return null;
+              }
+              if (isExp(char)) {
+                current.state = 6 /* Exp */;
+                current.value += char;
+                current.passed = false;
+                return null;
+              }
+              if (current.passed) {
+                const token = {
+                  type: "Number",
+                  value: JSON.parse(current.value)
+                };
+                current = null;
+                const next = write(char);
+                if (next) {
+                  return Array.isArray(next) ? [token, ...next] : [token, next];
+                } else {
+                  return token;
+                }
+              }
+              throw new Error("解析失败");
+            case 4 /* Point */:
+              if (isDigit(char)) {
+                current.state = 5 /* DigitFraction */;
+                current.value += char;
+                current.passed = true;
+                return null;
+              }
+              if (current.passed) {
+                const token = {
+                  type: "Number",
+                  value: JSON.parse(current.value)
+                };
+                current = null;
+                const next = write(char);
+                if (next) {
+                  return Array.isArray(next) ? [token, ...next] : [token, next];
+                } else {
+                  return token;
+                }
+              }
+              throw new Error("解析失败");
+            case 5 /* DigitFraction */:
+              if (isDigit(char)) {
+                current.value += char;
+                current.passed = true;
+                return null;
+              }
+              if (isExp(char)) {
+                current.state = 6 /* Exp */;
+                current.value += char;
+                current.passed = false;
+                return null;
+              }
+              if (current.passed) {
+                const token = {
+                  type: "Number",
+                  value: JSON.parse(current.value)
+                };
+                current = null;
+                const next = write(char);
+                if (next) {
+                  return Array.isArray(next) ? [token, ...next] : [token, next];
+                } else {
+                  return token;
+                }
+              }
+              throw new Error("解析失败");
+            case 6 /* Exp */:
+              if (flags.includes(char)) {
+                current.state = 7 /* ExpDigitOrSign */;
+                current.value += char;
+                current.passed = false;
+                return null;
+              }
+              if (isDigit(char)) {
+                current.state = 7 /* ExpDigitOrSign */;
+                current.value += char;
+                current.passed = true;
+                return null;
+              }
+              if (current.passed) {
+                const token = {
+                  type: "Number",
+                  value: JSON.parse(current.value)
+                };
+                current = null;
+                const next = write(char);
+                if (next) {
+                  return Array.isArray(next) ? [token, ...next] : [token, next];
+                } else {
+                  return token;
+                }
+              }
+              throw new Error("解析失败");
+            case 7 /* ExpDigitOrSign */:
+              if (isDigit(char)) {
+                current.value += char;
+                current.passed = true;
+                return null;
+              }
+              if (current.passed) {
+                const token = {
+                  type: "Number",
+                  value: JSON.parse(current.value)
+                };
+                current = null;
+                const next = write(char);
+                if (next) {
+                  return Array.isArray(next) ? [token, ...next] : [token, next];
+                } else {
+                  return token;
+                }
+              }
+              throw new Error("解析失败");
+          }
+      }
+    } else {
+      if (whiteSpaces.includes(char)) {
+        return null;
+      }
+      if (symbols.includes(char)) {
+        return {
+          type: "Symbol",
+          value: char
+        };
+      }
+      const keywordIndex = keywordsStart.indexOf(char);
+      if (keywordIndex >= 0) {
+        current = {
+          type: "Keyword",
+          value: keywords[keywordIndex],
+          matchedIndex: 0
+        };
+        return null;
+      }
+      if (char === '"') {
+        current = {
+          type: "String",
+          state: 0 /* Normal */,
+          value: '"',
+          escapeIndex: 0
+        };
+        return null;
+      }
+      if (char === "-") {
+        current = {
+          type: "Number",
+          state: 1 /* Negative */,
+          value: char,
+          passed: false
+        };
+        return null;
+      }
+      if (char === "0") {
+        current = {
+          type: "Number",
+          state: 2 /* Zero */,
+          value: char,
+          passed: true
+        };
+        return null;
+      }
+      if (isDigitNotZero(char)) {
+        current = {
+          type: "Number",
+          state: 3 /* Digit */,
+          value: char,
+          passed: true
+        };
+        return null;
+      }
+      throw new Error("解析失败");
+    }
+  };
+  const end = () => {
+    if (current) {
+      switch (current.type) {
+        case "Keyword":
+        case "String":
+          throw new Error("解析失败");
+        case "Number":
+          if (current.passed) {
+            const token = {
+              type: "Number",
+              value: JSON.parse(current.value)
+            };
+            current = null;
+            return token;
+          }
+          return null;
+      }
+    }
+    return null;
+  };
+  return {
+    write,
+    end
+  };
+}
+
+// src/create-json-brook.ts
+function getValueFromNode(node) {
+  switch (node.type) {
+    case "Literal":
+      return node.value;
+    case "Array":
+      return (node.current ? [...node.children, node.current] : node.children).map((child) => getValueFromNode(child));
+    case "Object":
+      return (node.current ? [...node.children, node.current] : node.children).reduce(
+        (obj, property) => {
+          if (property.value) {
+            obj[property.key.value] = getValueFromNode(property.value);
+          }
+          return obj;
+        },
+        // biome-ignore lint/suspicious/noExplicitAny: 可以返回的类型不确定
+        {}
+      );
+  }
+}
+function createJsonBrook() {
+  const tokenize = createTokenize();
+  const parser = createParser();
+  const write = (str) => {
+    for (const char of str) {
+      const token = tokenize.write(char);
+      if (token) {
+        if (Array.isArray(token)) {
+          for (const t of token) {
+            parser.write(t);
+          }
+        } else {
+          parser.write(token);
+        }
+      }
+    }
+  };
+  const end = () => {
+    const token = tokenize.end();
+    if (token) {
+      parser.write(token);
+    }
+  };
+  const getCurrent = () => {
+    const root = parser.getRoot();
+    if (root) {
+      return getValueFromNode(root);
+    } else {
+      return void 0;
+    }
+  };
+  return {
+    getCurrent,
+    write,
+    end
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createJsonBrook
+});