@fluixi/utils 1.0.0-alpha.83 → 1.0.0-alpha.84

package/dist/lib/primitive/string/parser-2.mjs

@@ -1,8 +1,522 @@
-var w=class extends Error{constructor(U,p,s,n){super(`${U} at line ${s}, column ${n} (position ${p})`);this.position=p;this.line=s;this.column=n;this.name="ParseError"}};function K(f,I={}){if(typeof f!="string")throw new TypeError("Input must be a string");if(f.trim().length===0)throw new w("Input string is empty",0,1,1);let p={...{allowUnquotedKeys:!0,allowTrailingCommas:!0,allowSingleQuotes:!0,allowComments:!0,allowUndefined:!1,allowSpecialNumbers:!1,reviver:void 0,strict:!1,maxDepth:100},...I},s=0,n=f[0],k=1,y=1,b=0,u=p,g=f.length,c=()=>s>=g,i=()=>{n===`
-`?(k++,y=1):y++,s++,s<g?n=f[s]:n=""},h=(r=1)=>{let e=s+r;return e<g?f[e]:""},a=r=>new w(r,s,k,y),O=()=>{for(;!c()&&(n===" "||n==="	"||n===`
-`||n==="\r");)i()},q=()=>{for(i();!c()&&n!==`
-`&&n!=="\r";)i()},E=()=>{for(i();!c();){if(n==="*"&&h()==="/"){i(),i();return}i()}throw a("Unterminated block comment")},d=()=>{for(;!c();){let r=s;if(O(),u.allowComments&&n==="/"){let e=h();if(e==="/"){q();continue}else if(e==="*"){E();continue}}if(s===r)break}},C=()=>{if(b++,b>u.maxDepth)throw a(`Maximum nesting depth (${u.maxDepth}) exceeded`);if(d(),c())throw a("Unexpected end of input");let r,e=n;return e==="{"?r=T():e==="["?r=A():e==='"'||e==="'"?r=S():e==="-"||e>="0"&&e<="9"?r=R():e==="t"||e==="f"||e==="n"||e==="u"&&u.allowUndefined?r=v():(e==="I"||e==="N")&&u.allowSpecialNumbers&&(r=j()),b--,r},T=()=>{let r={};if(i(),d(),n==="}")return i(),r;for(;!c();){d();let e,t=n;if(t==='"'||t==="'")e=S();else if(u.allowUnquotedKeys&&(t>="a"&&t<="z"||t>="A"&&t<="Z"||t==="_"||t==="$")){let l=s;for(;!c()&&(n>="a"&&n<="z"||n>="A"&&n<="Z"||n>="0"&&n<="9"||n==="_"||n==="$");)i();if(e=f.slice(l,s),e==="true"||e==="false"||e==="null"||u.allowUndefined&&e==="undefined")throw a(`Keyword "${e}" cannot be used as unquoted property name`)}else throw a(`Expected property name, got "${n}"`);d(),i(),d(),r[e]=C(),d();let o=n;if(o==="}")return i(),r;if(o===","){if(i(),d(),n==="}"){if(u.allowTrailingCommas)return i(),r;throw a("Trailing comma not allowed")}continue}}throw a("Unexpected end of input in object")},A=()=>{let r=[];if(i(),d(),n==="]")return i(),r;for(;!c();){r.push(C()),d();let e=n;if(e==="]")return i(),r;if(e===","){if(i(),d(),n==="]"){if(u.allowTrailingCommas)return i(),r;throw a("Trailing comma not allowed")}continue}throw a(`Expected comma or closing bracket, got "${e}"`)}throw a("Unexpected end of input in array")},S=()=>{let r=n,e=s;if(r==="'"&&!u.allowSingleQuotes)throw a("Single quotes are not allowed");i();let t="";for(;!c();){let o=n;if(o==="\\"){if(i(),c())throw a("Unterminated escape sequence");t+=P(r)}else{if(o===r)return i(),t;if(o===`
-`||o==="\r")throw a("Unterminated string literal");t+=o,i()}}throw a(`Unterminated string literal starting at position ${e}`)},P=r=>{let e=n;if(e==="b")return i(),"\b";if(e==="f")return i(),"\f";if(e==="n")return i(),`
-`;if(e==="r")return i(),"\r";if(e==="t")return i(),"	";if(e==="v")return i(),"\v";if(e==="0")return i(),"\0";if(e==="x")return i(),$(2);if(e==="u")return i(),F();if(e===`
-`)return i(),"";if(e==="\r")return h()===`
-`&&i(),i(),"";{let t=e;return i(),t}},$=r=>{let e="";for(let t=0;t<r;t++){let o=n,l=o>="0"&&o<="9"||o>="a"&&o<="f"||o>="A"&&o<="F";if(c()||!l)throw a("Invalid hex escape sequence");e+=o,i()}return String.fromCharCode(parseInt(e,16))},F=()=>{if(n==="{"){i();let e="";for(;!c()&&n!=="}";){let o=n;if(!(o>="0"&&o<="9"||o>="a"&&o<="f"||o>="A"&&o<="F"))throw a("Invalid Unicode code point");e+=o,i()}if(n!=="}")throw a("Unterminated Unicode code point escape");i();let t=parseInt(e,16);if(isNaN(t)||t>1114111)throw a("Invalid Unicode code point");return String.fromCodePoint(t)}return $(4)},R=()=>{let r=s,e="";if(n==="-"&&(e+=n,i()),u.allowSpecialNumbers){if(n==="I"){if(f.slice(s,s+8)==="Infinity"){for(let l=0;l<8;l++)i();return e==="-"?-1/0:1/0}}else if(n==="N"&&f.slice(s,s+3)==="NaN"){for(let l=0;l<3;l++)i();return NaN}}if(n==="0"&&(e+=n,i(),u.allowUnquotedKeys)){let o=e.charAt(1);if(o==="x"||o==="X")return i(),x(16);if(o==="o"||o==="O")return i(),x(8);if(o==="b"||o==="B")return i(),x(2)}for(;!c()&&n>="0"&&n<="9";)e+=n,i();if(n==="."){if(e+=n,i(),!(n>="0"&&n<="9"))throw a("Expected digit after decimal point");for(;!c()&&n>="0"&&n<="9";)e+=n,i()}if(n==="e"||n==="E"){if(e+=n,i(),(h()==="+"||h()==="-")&&(e+=n,i()),!(n>="0"&&n<="9"))throw a("Expected digit in exponent");for(;!c()&&n>="0"&&n<="9";)e+=n,i()}let t=parseFloat(e);if(isNaN(t))throw a(`Invalid number "${e}"`);return t},x=r=>{let e="";for(;!c();){let t=n,o=!1;if(r===16?o=t>="0"&&t<="9"||t>="a"&&t<="f"||t>="A"&&t<="F":r===8?o=t>="0"&&t<="7":r===2&&(o=t==="0"||t==="1"),!o)break;e+=t,i()}if(e.length===0)throw a(`Invalid ${r===16?"hexadecimal":r===8?"octal":"binary"} number`);return parseInt(e,r)},j=()=>{if(n==="I"&&f.slice(s,s+8)==="Infinity"){for(let r=0;r<8;r++)i();return 1/0}else if(n==="N"&&f.slice(s,s+3)==="NaN"){for(let r=0;r<3;r++)i();return NaN}else if(n==="-"&&f.slice(s,s+9)==="-Infinity"){for(let r=0;r<9;r++)i();return-1/0}throw a("Invalid special number")},v=()=>{let r=s,e="";for(;!c();){let t=n;if(!(t>="a"&&t<="z"||t>="A"&&t<="Z"||t>="0"&&t<="9"||t==="_"||t==="$"))break;e+=t,i()}if(e==="true")return!0;if(e==="false")return!1;if(e==="null")return null;if(e==="undefined"&&u.allowUndefined)return;throw a(`Unknown keyword "${e}"`)},N=(r,e,t,o)=>{if(t&&typeof t=="object"){if(Array.isArray(t))for(let l=0;l<t.length;l++){let m=N(t,l.toString(),t[l],o);m===void 0?(t.splice(l,1),l--):t[l]=m}else for(let l in t)if(Object.prototype.hasOwnProperty.call(t,l)){let m=N(t,l,t[l],o);m===void 0?delete t[l]:t[l]=m}}return o.call(r,e,t)};try{d();let r=C();if(d(),!c())throw a(`Unexpected trailing content: "${f.slice(s,s+20)}"`);return p.reviver?N({"":r},"",r,p.reviver):r}catch(r){if(!p.strict&&r instanceof w)try{return p.reviver?JSON.parse(f,p.reviver):JSON.parse(f)}catch{throw r}throw r}}export{K as parseObjectLiteral};
+// src/lib/primitive/string/parser-2.ts
+var ParseError = class extends Error {
+  constructor(message, position, line, column) {
+    super(`${message} at line ${line}, column ${column} (position ${position})`);
+    this.position = position;
+    this.line = line;
+    this.column = column;
+    this.name = "ParseError";
+  }
+};
+function parseObjectLiteral(str, options = {}) {
+  if (typeof str !== "string") {
+    throw new TypeError("Input must be a string");
+  }
+  if (str.trim().length === 0) {
+    throw new ParseError("Input string is empty", 0, 1, 1);
+  }
+  const defaultOptions = {
+    allowUnquotedKeys: true,
+    allowTrailingCommas: true,
+    allowSingleQuotes: true,
+    allowComments: true,
+    allowUndefined: false,
+    allowSpecialNumbers: false,
+    reviver: void 0,
+    strict: false,
+    maxDepth: 100
+  };
+  const mergedOptions = {
+    ...defaultOptions,
+    ...options
+  };
+  let index = 0;
+  let char = str[0];
+  let line = 1;
+  let column = 1;
+  let depth = 0;
+  const optionsRef = mergedOptions;
+  const maxLength = str.length;
+  const isEnd = () => index >= maxLength;
+  const advance = () => {
+    if (char === "\n") {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+    index++;
+    if (index < maxLength) {
+      char = str[index];
+    } else {
+      char = "";
+    }
+  };
+  const peek = (offset = 1) => {
+    const peekIndex = index + offset;
+    return peekIndex < maxLength ? str[peekIndex] : "";
+  };
+  const createError = (message) => {
+    return new ParseError(message, index, line, column);
+  };
+  const skipWhitespace = () => {
+    while (!isEnd() && (char === " " || char === "	" || char === "\n" || char === "\r")) {
+      advance();
+    }
+  };
+  const skipLineComment = () => {
+    advance();
+    while (!isEnd() && char !== "\n" && char !== "\r") {
+      advance();
+    }
+  };
+  const skipBlockComment = () => {
+    advance();
+    while (!isEnd()) {
+      if (char === "*" && peek() === "/") {
+        advance();
+        advance();
+        return;
+      }
+      advance();
+    }
+    throw createError("Unterminated block comment");
+  };
+  const skipWhitespaceAndComments = () => {
+    while (!isEnd()) {
+      const prevIndex = index;
+      skipWhitespace();
+      if (optionsRef.allowComments && char === "/") {
+        const nextChar = peek();
+        if (nextChar === "/") {
+          skipLineComment();
+          continue;
+        } else if (nextChar === "*") {
+          skipBlockComment();
+          continue;
+        }
+      }
+      if (index === prevIndex) {
+        break;
+      }
+    }
+  };
+  const parseValue = () => {
+    depth++;
+    if (depth > optionsRef.maxDepth) {
+      throw createError(`Maximum nesting depth (${optionsRef.maxDepth}) exceeded`);
+    }
+    skipWhitespaceAndComments();
+    if (isEnd()) {
+      throw createError("Unexpected end of input");
+    }
+    let value;
+    const currentChar = char;
+    if (currentChar === "{") {
+      value = parseObject();
+    } else if (currentChar === "[") {
+      value = parseArray();
+    } else if (currentChar === '"' || currentChar === "'") {
+      value = parseString();
+    } else if (currentChar === "-" || currentChar >= "0" && currentChar <= "9") {
+      value = parseNumber();
+    } else if (currentChar === "t" || currentChar === "f" || currentChar === "n") {
+      value = parseKeyword();
+    } else if (currentChar === "u" && optionsRef.allowUndefined) {
+      value = parseKeyword();
+    } else if ((currentChar === "I" || currentChar === "N") && optionsRef.allowSpecialNumbers) {
+      value = parseSpecialNumber();
+    } else {
+    }
+    depth--;
+    return value;
+  };
+  const parseObject = () => {
+    const obj = {};
+    advance();
+    skipWhitespaceAndComments();
+    if (char === "}") {
+      advance();
+      return obj;
+    }
+    while (!isEnd()) {
+      skipWhitespaceAndComments();
+      let key;
+      const currentChar = char;
+      if (currentChar === '"' || currentChar === "'") {
+        key = parseString();
+      } else if (optionsRef.allowUnquotedKeys && (currentChar >= "a" && currentChar <= "z" || currentChar >= "A" && currentChar <= "Z" || currentChar === "_" || currentChar === "$")) {
+        const start = index;
+        while (!isEnd() && (char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char >= "0" && char <= "9" || char === "_" || char === "$")) {
+          advance();
+        }
+        key = str.slice(start, index);
+        if (key === "true" || key === "false" || key === "null" || optionsRef.allowUndefined && key === "undefined") {
+          throw createError(`Keyword "${key}" cannot be used as unquoted property name`);
+        }
+      } else {
+        throw createError(`Expected property name, got "${char}"`);
+      }
+      skipWhitespaceAndComments();
+      advance();
+      skipWhitespaceAndComments();
+      obj[key] = parseValue();
+      skipWhitespaceAndComments();
+      const nextChar = char;
+      if (nextChar === "}") {
+        advance();
+        return obj;
+      }
+      if (nextChar === ",") {
+        advance();
+        skipWhitespaceAndComments();
+        const afterCommaChar = char;
+        if (afterCommaChar === "}") {
+          if (optionsRef.allowTrailingCommas) {
+            advance();
+            return obj;
+          } else {
+            throw createError("Trailing comma not allowed");
+          }
+        }
+        continue;
+      }
+      continue;
+    }
+    throw createError("Unexpected end of input in object");
+  };
+  const parseArray = () => {
+    const arr = [];
+    advance();
+    skipWhitespaceAndComments();
+    if (char === "]") {
+      advance();
+      return arr;
+    }
+    while (!isEnd()) {
+      arr.push(parseValue());
+      skipWhitespaceAndComments();
+      const nextChar = char;
+      if (nextChar === "]") {
+        advance();
+        return arr;
+      }
+      if (nextChar === ",") {
+        advance();
+        skipWhitespaceAndComments();
+        const afterCommaChar = char;
+        if (afterCommaChar === "]") {
+          if (optionsRef.allowTrailingCommas) {
+            advance();
+            return arr;
+          } else {
+            throw createError("Trailing comma not allowed");
+          }
+        }
+        continue;
+      }
+      throw createError(`Expected comma or closing bracket, got "${nextChar}"`);
+    }
+    throw createError("Unexpected end of input in array");
+  };
+  const parseString = () => {
+    const quoteChar = char;
+    const startPos = index;
+    if (quoteChar === "'" && !optionsRef.allowSingleQuotes) {
+      throw createError("Single quotes are not allowed");
+    }
+    advance();
+    let result = "";
+    while (!isEnd()) {
+      const currentChar = char;
+      if (currentChar === "\\") {
+        advance();
+        if (isEnd()) {
+          throw createError("Unterminated escape sequence");
+        }
+        result += parseEscapeSequence(quoteChar);
+      } else if (currentChar === quoteChar) {
+        advance();
+        return result;
+      } else if (currentChar === "\n" || currentChar === "\r") {
+        throw createError("Unterminated string literal");
+      } else {
+        result += currentChar;
+        advance();
+      }
+    }
+    throw createError(`Unterminated string literal starting at position ${startPos}`);
+  };
+  const parseEscapeSequence = (quoteChar) => {
+    const escapeChar = char;
+    if (escapeChar === "b") {
+      advance();
+      return "\b";
+    } else if (escapeChar === "f") {
+      advance();
+      return "\f";
+    } else if (escapeChar === "n") {
+      advance();
+      return "\n";
+    } else if (escapeChar === "r") {
+      advance();
+      return "\r";
+    } else if (escapeChar === "t") {
+      advance();
+      return "	";
+    } else if (escapeChar === "v") {
+      advance();
+      return "\v";
+    } else if (escapeChar === "0") {
+      advance();
+      return "\0";
+    } else if (escapeChar === "x") {
+      advance();
+      return parseHexEscape(2);
+    } else if (escapeChar === "u") {
+      advance();
+      return parseUnicodeEscape();
+    } else if (escapeChar === "\n") {
+      advance();
+      return "";
+    } else if (escapeChar === "\r") {
+      if (peek() === "\n") {
+        advance();
+        advance();
+      } else {
+        advance();
+      }
+      return "";
+    } else {
+      const charToReturn = escapeChar;
+      advance();
+      return charToReturn;
+    }
+  };
+  const parseHexEscape = (length) => {
+    let hex = "";
+    for (let i = 0; i < length; i++) {
+      const currentChar = char;
+      const isHex = currentChar >= "0" && currentChar <= "9" || currentChar >= "a" && currentChar <= "f" || currentChar >= "A" && currentChar <= "F";
+      if (isEnd() || !isHex) {
+        throw createError("Invalid hex escape sequence");
+      }
+      hex += currentChar;
+      advance();
+    }
+    return String.fromCharCode(parseInt(hex, 16));
+  };
+  const parseUnicodeEscape = () => {
+    const currentChar = char;
+    if (currentChar === "{") {
+      advance();
+      let hex = "";
+      while (!isEnd() && char !== "}") {
+        const currentHexChar = char;
+        const isHex = currentHexChar >= "0" && currentHexChar <= "9" || currentHexChar >= "a" && currentHexChar <= "f" || currentHexChar >= "A" && currentHexChar <= "F";
+        if (!isHex) {
+          throw createError("Invalid Unicode code point");
+        }
+        hex += currentHexChar;
+        advance();
+      }
+      if (char !== "}") {
+        throw createError("Unterminated Unicode code point escape");
+      }
+      advance();
+      const codePoint = parseInt(hex, 16);
+      if (isNaN(codePoint) || codePoint > 1114111) {
+        throw createError("Invalid Unicode code point");
+      }
+      return String.fromCodePoint(codePoint);
+    }
+    return parseHexEscape(4);
+  };
+  const parseNumber = () => {
+    const start = index;
+    let numberStr = "";
+    if (char === "-") {
+      numberStr += char;
+      advance();
+    }
+    if (optionsRef.allowSpecialNumbers) {
+      if (char === "I") {
+        const word = str.slice(index, index + 8);
+        if (word === "Infinity") {
+          for (let i = 0; i < 8; i++) advance();
+          return numberStr === "-" ? -Infinity : Infinity;
+        }
+      } else if (char === "N") {
+        const word = str.slice(index, index + 3);
+        if (word === "NaN") {
+          for (let i = 0; i < 3; i++) advance();
+          return NaN;
+        }
+      }
+    }
+    if (char === "0") {
+      numberStr += char;
+      advance();
+      if (optionsRef.allowUnquotedKeys) {
+        const radixChar = numberStr.charAt(1);
+        if (radixChar === "x" || radixChar === "X") {
+          advance();
+          return parseNonDecimalNumber(16);
+        } else if (radixChar === "o" || radixChar === "O") {
+          advance();
+          return parseNonDecimalNumber(8);
+        } else if (radixChar === "b" || radixChar === "B") {
+          advance();
+          return parseNonDecimalNumber(2);
+        }
+      }
+    }
+    while (!isEnd() && char >= "0" && char <= "9") {
+      numberStr += char;
+      advance();
+    }
+    if (char === ".") {
+      numberStr += char;
+      advance();
+      if (!(char >= "0" && char <= "9")) {
+        throw createError("Expected digit after decimal point");
+      }
+      while (!isEnd() && char >= "0" && char <= "9") {
+        numberStr += char;
+        advance();
+      }
+    }
+    if (char === "e" || char === "E") {
+      numberStr += char;
+      advance();
+      if (peek() === "+" || peek() === "-") {
+        numberStr += char;
+        advance();
+      }
+      if (!(char >= "0" && char <= "9")) {
+        throw createError("Expected digit in exponent");
+      }
+      while (!isEnd() && char >= "0" && char <= "9") {
+        numberStr += char;
+        advance();
+      }
+    }
+    const num = parseFloat(numberStr);
+    if (isNaN(num)) {
+      throw createError(`Invalid number "${numberStr}"`);
+    }
+    return num;
+  };
+  const parseNonDecimalNumber = (radix) => {
+    let digits = "";
+    while (!isEnd()) {
+      const currentChar = char;
+      let isValid = false;
+      if (radix === 16) {
+        isValid = currentChar >= "0" && currentChar <= "9" || currentChar >= "a" && currentChar <= "f" || currentChar >= "A" && currentChar <= "F";
+      } else if (radix === 8) {
+        isValid = currentChar >= "0" && currentChar <= "7";
+      } else if (radix === 2) {
+        isValid = currentChar === "0" || currentChar === "1";
+      }
+      if (!isValid) {
+        break;
+      }
+      digits += currentChar;
+      advance();
+    }
+    if (digits.length === 0) {
+      const baseName = radix === 16 ? "hexadecimal" : radix === 8 ? "octal" : "binary";
+      throw createError(`Invalid ${baseName} number`);
+    }
+    return parseInt(digits, radix);
+  };
+  const parseSpecialNumber = () => {
+    if (char === "I" && str.slice(index, index + 8) === "Infinity") {
+      for (let i = 0; i < 8; i++) advance();
+      return Infinity;
+    } else if (char === "N" && str.slice(index, index + 3) === "NaN") {
+      for (let i = 0; i < 3; i++) advance();
+      return NaN;
+    } else if (char === "-" && str.slice(index, index + 9) === "-Infinity") {
+      for (let i = 0; i < 9; i++) advance();
+      return -Infinity;
+    }
+    throw createError("Invalid special number");
+  };
+  const parseKeyword = () => {
+    const start = index;
+    let keyword = "";
+    while (!isEnd()) {
+      const currentChar = char;
+      const isIdentifierChar = currentChar >= "a" && currentChar <= "z" || currentChar >= "A" && currentChar <= "Z" || currentChar >= "0" && currentChar <= "9" || currentChar === "_" || currentChar === "$";
+      if (!isIdentifierChar) {
+        break;
+      }
+      keyword += currentChar;
+      advance();
+    }
+    if (keyword === "true") {
+      return true;
+    } else if (keyword === "false") {
+      return false;
+    } else if (keyword === "null") {
+      return null;
+    } else if (keyword === "undefined" && optionsRef.allowUndefined) {
+      return void 0;
+    } else {
+      throw createError(`Unknown keyword "${keyword}"`);
+    }
+  };
+  const applyReviver = (holder, key, value, reviver) => {
+    if (value && typeof value === "object") {
+      if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+          const transformed = applyReviver(value, i.toString(), value[i], reviver);
+          if (transformed === void 0) {
+            value.splice(i, 1);
+            i--;
+          } else {
+            value[i] = transformed;
+          }
+        }
+      } else {
+        for (const k in value) {
+          if (Object.prototype.hasOwnProperty.call(value, k)) {
+            const transformed = applyReviver(value, k, value[k], reviver);
+            if (transformed === void 0) {
+              delete value[k];
+            } else {
+              value[k] = transformed;
+            }
+          }
+        }
+      }
+    }
+    return reviver.call(holder, key, value);
+  };
+  try {
+    skipWhitespaceAndComments();
+    const result = parseValue();
+    skipWhitespaceAndComments();
+    if (!isEnd()) {
+      throw createError(`Unexpected trailing content: "${str.slice(index, index + 20)}"`);
+    }
+    if (mergedOptions.reviver) {
+      return applyReviver({ "": result }, "", result, mergedOptions.reviver);
+    }
+    return result;
+  } catch (error) {
+    if (!mergedOptions.strict && error instanceof ParseError) {
+      try {
+        return mergedOptions.reviver ? JSON.parse(str, mergedOptions.reviver) : JSON.parse(str);
+      } catch {
+        throw error;
+      }
+    }
+    throw error;
+  }
+}
+export {
+  parseObjectLiteral
+};