@fluixi/utils 1.0.0-alpha.53

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

@@ -0,0 +1,656 @@
+class ParseError extends Error {
+    position;
+    line;
+    column;
+    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';
+    }
+}
+/**
+ * Robust state machine parser for JavaScript object literals
+ */
+export function parseObjectLiteral(str, options = {}) {
+    // Validate input
+    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);
+    }
+    // Set defaults
+    const defaultOptions = {
+        allowUnquotedKeys: true,
+        allowTrailingCommas: true,
+        allowSingleQuotes: true,
+        allowComments: true,
+        allowUndefined: false,
+        allowSpecialNumbers: false,
+        reviver: undefined,
+        strict: false,
+        maxDepth: 100,
+    };
+    const mergedOptions = {
+        ...defaultOptions,
+        ...options,
+    };
+    // Parse state
+    let index = 0;
+    let char = str[0];
+    let line = 1;
+    let column = 1;
+    let depth = 0;
+    const optionsRef = mergedOptions;
+    const maxLength = str.length;
+    // Helper functions
+    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 === '\t' || char === '\n' || char === '\r')) {
+            advance();
+        }
+    };
+    const skipLineComment = () => {
+        // We're at the first '/' of '//'
+        advance(); // Skip second '/'
+        while (!isEnd() && char !== '\n' && char !== '\r') {
+            advance();
+        }
+    };
+    const skipBlockComment = () => {
+        // We're at the first '/' of '/*'
+        advance(); // Skip '*'
+        while (!isEnd()) {
+            if (char === '*' && peek() === '/') {
+                advance(); // Skip '*'
+                advance(); // Skip '/'
+                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;
+            }
+        }
+    };
+    // ====================
+    // Parsing Functions
+    // ====================
+    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;
+        // Parse based on current character
+        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 {
+            // throw createError(`Unexpected character "${currentChar}"`);
+        }
+        depth--;
+        return value;
+    };
+    const parseObject = () => {
+        const obj = {};
+        // Skip opening brace
+        advance();
+        skipWhitespaceAndComments();
+        // Handle empty object
+        if (char === '}') {
+            advance();
+            return obj;
+        }
+        // Parse object properties
+        while (!isEnd()) {
+            skipWhitespaceAndComments();
+            // Parse key
+            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);
+                // Validate it's not a keyword
+                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();
+            // Expect colon
+            // if (char !== ':') {
+            //   throw createError('Expected colon after property name');
+            // }
+            advance();
+            skipWhitespaceAndComments();
+            // Parse value
+            obj[key] = parseValue();
+            skipWhitespaceAndComments();
+            // Check what comes next
+            const nextChar = char;
+            if (nextChar === '}') {
+                advance();
+                return obj;
+            }
+            if (nextChar === ',') {
+                advance();
+                skipWhitespaceAndComments();
+                // Check if the next thing is a closing brace (trailing comma)
+                const afterCommaChar = char;
+                if (afterCommaChar === '}') {
+                    if (optionsRef.allowTrailingCommas) {
+                        advance();
+                        return obj;
+                    }
+                    else {
+                        throw createError('Trailing comma not allowed');
+                    }
+                }
+                // Continue to next property
+                continue;
+            }
+            // throw createError(`Expected comma or closing brace, got "${nextChar}"`);
+            continue;
+        }
+        throw createError('Unexpected end of input in object');
+    };
+    const parseArray = () => {
+        const arr = [];
+        // Skip opening bracket
+        advance();
+        skipWhitespaceAndComments();
+        // Handle empty array
+        if (char === ']') {
+            advance();
+            return arr;
+        }
+        // Parse array elements
+        while (!isEnd()) {
+            // Parse element
+            arr.push(parseValue());
+            skipWhitespaceAndComments();
+            // Check what comes next
+            const nextChar = char;
+            if (nextChar === ']') {
+                advance();
+                return arr;
+            }
+            if (nextChar === ',') {
+                advance();
+                skipWhitespaceAndComments();
+                // Check if the next thing is a closing bracket (trailing comma)
+                const afterCommaChar = char;
+                if (afterCommaChar === ']') {
+                    if (optionsRef.allowTrailingCommas) {
+                        advance();
+                        return arr;
+                    }
+                    else {
+                        throw createError('Trailing comma not allowed');
+                    }
+                }
+                // Continue to next element
+                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');
+        }
+        // Skip opening quote
+        advance();
+        let result = '';
+        while (!isEnd()) {
+            const currentChar = char;
+            if (currentChar === '\\') {
+                // Handle escape sequence
+                advance();
+                if (isEnd()) {
+                    throw createError('Unterminated escape sequence');
+                }
+                result += parseEscapeSequence(quoteChar);
+            }
+            else if (currentChar === quoteChar) {
+                // End of string
+                advance();
+                return result;
+            }
+            else if (currentChar === '\n' || currentChar === '\r') {
+                // Newline in string (not allowed unless escaped)
+                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 '\t';
+        }
+        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') {
+            // Line continuation
+            advance();
+            return '';
+        }
+        else if (escapeChar === '\r') {
+            // Windows line continuation
+            if (peek() === '\n') {
+                advance(); // Skip \r
+                advance(); // Skip \n
+            }
+            else {
+                advance();
+            }
+            return '';
+        }
+        else {
+            // Return the character itself (for \\, \", \', etc.)
+            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 = () => {
+        // Check for Unicode code point escape \u{...}
+        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(); // Skip '}'
+            const codePoint = parseInt(hex, 16);
+            if (isNaN(codePoint) || codePoint > 0x10FFFF) {
+                throw createError('Invalid Unicode code point');
+            }
+            return String.fromCodePoint(codePoint);
+        }
+        // Regular 4-digit hex escape
+        return parseHexEscape(4);
+    };
+    const parseNumber = () => {
+        const start = index;
+        let numberStr = '';
+        // Optional sign
+        if (char === '-') {
+            numberStr += char;
+            advance();
+        }
+        // Check for special numbers first
+        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;
+                }
+            }
+        }
+        // Integer part
+        if (char === '0') {
+            numberStr += char;
+            advance();
+            // Check for non-decimal literals (only if allowUnquotedKeys is true)
+            if (optionsRef.allowUnquotedKeys) {
+                // const radixChar = char;
+                const radixChar = numberStr.charAt(1);
+                if (radixChar === 'x' || radixChar === 'X') {
+                    // Hexadecimal
+                    advance();
+                    return parseNonDecimalNumber(16);
+                }
+                else if (radixChar === 'o' || radixChar === 'O') {
+                    // Octal
+                    advance();
+                    return parseNonDecimalNumber(8);
+                }
+                else if (radixChar === 'b' || radixChar === 'B') {
+                    // Binary
+                    advance();
+                    return parseNonDecimalNumber(2);
+                }
+            }
+        }
+        // Collect integer digits
+        while (!isEnd() && char >= '0' && char <= '9') {
+            numberStr += char;
+            advance();
+        }
+        // Fraction part
+        if (char === '.') {
+            numberStr += char;
+            advance();
+            // Must have at least one digit after decimal point
+            if (!(char >= '0' && char <= '9')) {
+                throw createError('Expected digit after decimal point');
+            }
+            while (!isEnd() && char >= '0' && char <= '9') {
+                numberStr += char;
+                advance();
+            }
+        }
+        // Exponent part
+        if (char === 'e' || char === 'E') {
+            numberStr += char;
+            advance();
+            // Optional exponent sign
+            if (peek() === '+' || peek() === '-') {
+                numberStr += char;
+                advance();
+            }
+            // Must have at least one digit in exponent
+            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 undefined;
+        }
+        else {
+            throw createError(`Unknown keyword "${keyword}"`);
+        }
+    };
+    // Apply reviver function
+    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 === undefined) {
+                        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 === undefined) {
+                            delete value[k];
+                        }
+                        else {
+                            value[k] = transformed;
+                        }
+                    }
+                }
+            }
+        }
+        return reviver.call(holder, key, value);
+    };
+    // ====================
+    // Main Parsing Logic
+    // ====================
+    try {
+        // Start parsing
+        skipWhitespaceAndComments();
+        const result = parseValue();
+        // Ensure we consumed everything
+        skipWhitespaceAndComments();
+        if (!isEnd()) {
+            throw createError(`Unexpected trailing content: "${str.slice(index, index + 20)}"`);
+        }
+        // Apply reviver if provided
+        if (mergedOptions.reviver) {
+            return applyReviver({ '': result }, '', result, mergedOptions.reviver);
+        }
+        return result;
+    }
+    catch (error) {
+        // Fallback to JSON.parse if not strict
+        if (!mergedOptions.strict && error instanceof ParseError) {
+            try {
+                return mergedOptions.reviver
+                    ? JSON.parse(str, mergedOptions.reviver)
+                    : JSON.parse(str);
+            }
+            catch {
+                throw error; // Re-throw original error
+            }
+        }
+        throw error;
+    }
+}

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

@@ -0,0 +1,8 @@
+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};

package/dist/lib/primitive/string/parser.cjs

@@ -0,0 +1,3 @@
+"use strict";var d=Object.defineProperty;var S=Object.getOwnPropertyDescriptor;var m=Object.getOwnPropertyNames;var x=Object.prototype.hasOwnProperty;var b=(f,s)=>{for(var o in s)d(f,o,{get:s[o],enumerable:!0})},C=(f,s,o,h)=>{if(s&&typeof s=="object"||typeof s=="function")for(let u of m(s))!x.call(f,u)&&u!==o&&d(f,u,{get:()=>s[u],enumerable:!(h=S(s,u))||h.enumerable});return f};var N=f=>C(d({},"__esModule",{value:!0}),f);var y={};b(y,{customParse:()=>J,parseJsObjectLiteral:()=>$,simpleJsObjectParse:()=>j});module.exports=N(y);function J(f,s={}){try{return JSON.parse(f)}catch{return $(f,s)}}function $(f,s={}){let{allowComments:o=!0,allowUnquotedKeys:h=!0,allowSingleQuotes:u=!0,allowTrailingCommas:p=!0,allowUndefined:w=!1}=s,t=f.trim();if(o&&(t=t.replace(/\/\*[\s\S]*?\*\//g,""),t=t.split(`
+`).map(r=>{let a=!1,e="",n=!1;for(let c=0;c<r.length;c++){let g=r[c];if(n){n=!1;continue}if(g==="\\"){n=!0;continue}if(!a&&(g==='"'||g==="'"))a=!0,e=g;else if(a&&g===e)a=!1,e="";else if(!a&&g==="/"&&r[c+1]==="/")return r.substring(0,c)}return r}).join(`
+`)),h&&(t=t.replace(/([{,]\s*)([a-zA-Z_$][a-zA-Z0-9_$]*)(\s*:)/g,'$1"$2"$3')),u){let l="",i=!1,r=!1,a=!1,e=0;for(;e<t.length;){let n=t[e];if(a){l+=n,a=!1,e++;continue}if(n==="\\"){a=!0,l+=n,e++;continue}n==="'"&&!r?i?(l+='"',i=!1):(l+='"',i=!0):(n==='"'&&!i&&(r?r=!1:r=!0),l+=n),e++}t=l}if(p){let l="",i=!1,r="",a=!1,e=0;for(;e<t.length;){let n=t[e];if(a){l+=n,a=!1,e++;continue}if(n==="\\"){a=!0,l+=n,e++;continue}if((n==='"'||n==="'")&&!i)i=!0,r=n,l+=n;else if(i&&n===r)i=!1,r="",l+=n;else if(!i&&n===","){let c=e+1;for(;c<t.length&&/\s/.test(t[c]);)c++;if(c<t.length&&(t[c]==="]"||t[c]==="}")){e++;continue}else l+=n}else l+=n;e++}t=l}if(w){let l="",i=!1,r="",a=!1,e=0;for(;e<t.length;){if(a){l+=t[e],a=!1,e++;continue}if(t[e]==="\\"){a=!0,l+=t[e],e++;continue}if((t[e]==='"'||t[e]==="'")&&!i)i=!0,r=t[e],l+=t[e];else if(i&&t[e]===r)i=!1,r="",l+=t[e];else if(!i&&t.substr(e,9)==="undefined"){let n=e>0?t[e-1]:"",c=e+8<t.length?t[e+9]:"";if(/[a-zA-Z0-9_$]/.test(n)||/[a-zA-Z0-9_$]/.test(c))l+=t[e];else{l+="null",e+=9;continue}}else l+=t[e];e++}t=l}try{return JSON.parse(t)}catch{return}}function j(f){let s=f;s=s.replace(/\/\*[\s\S]*?\*\//g,"").replace(/\/\/.*$/gm,""),s=s.replace(/([{,]\s*)([a-zA-Z_$][\w$]*)(\s*:)/g,(o,h,u,p)=>u==="true"||u==="false"||u==="null"||u==="undefined"||/^\d/.test(u)?o:`${h}"${u}"${p}`),s=s.replace(/'([^'\\]*(?:\\.[^'\\]*)*)'/g,'"$1"'),s=s.replace(/,(\s*[\]}])/g,"$1");try{return JSON.parse(s)}catch(o){throw new SyntaxError(`Failed to parse JavaScript object literal: ${o}`)}}