quick-json5 0.1.0

package/LICENSE.md

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

package/README.md

@@ -0,0 +1,66 @@
+# Quick JSON5
+
+Fast JSON5 parser and serializer.
+
+* Written in pure TypeScript (JavaScript)
+* Parses up to 10x faster than reference JSON5 implementation
+* Tested for 100% compliance with the official [JSON5 specification](https://spec.json5.org/)
+* Fully supports `replacer` and `space` properties in `stringify`, and `reviver` in `parse` (including the new `context` callback argument)
+* Support several extensions to the JSON5 standard (optional)
+* Improved validation and error reporting. Errors embed machine-readable positional metadata
+* No external dependencies
+
+## Support for extended numeric literals, beyond JSON5 (optional)
+
+Parser also supports additional numeric literal syntax added in later versions of ECMAScript:
+
+* Octal literals (`0o1234567`), and binary literals (`0b1001011`). Introduced in ES2015
+* `BigInt` numeric literals (`123412341234n`). Introduced in ES2020
+* Underscore separators in numeric literals (`123_456_789`, `123.456_789`, `0b0110_1101`). Introduced in ES2021
+
+Enabling these extensions requires the `enableExtensions` option to be set to `true` in the `options` argument for `parse` and `stringify`.
+
+## Extra: Plain JSON parser and serializer
+
+As an extra, also includes an optimized pure JavaScript JSON parser and serializer, with performance approaching to the native `JSON.parse` and `JSON.stringify`.
+
+The alternative parser can be useful when detailed metadata is required when handling errors. For example when implementing a syntax checker that needs to highlight the location of errors in the JSON file.
+
+You can also use the source code as a starting point for implementing various custom JSON extensions, like adding support for comments (AKA "JSON with comments").
+
+## Usage examples
+
+Installation:
+```
+npm install quick-json5
+```
+
+JSON5 serializer and parser:
+```ts
+import * as JSON5 from 'quick-json5'
+
+const json5Str = JSON5.stringify({ 'hello': 123 })
+const parsedObject = JSON5.parse(json5Str)
+```
+
+JSON5 serializer and parser with extensions enabled:
+```ts
+import * as JSON5 from 'quick-json5'
+
+const options = { enableExtensions: true }
+
+const json5Str = JSON5.stringify({ 'hello': 12356123456123456n }, undefined, 4, options)
+const parsedObject = JSON5.parse(json5Str, undefined, options)
+```
+
+Plain JSON serializer and parser:
+```ts
+import * as JSON5 from 'quick-json5'
+
+const jsonStr = JSON5.stringifyJSON({ 'hello': 123 })
+const parsedObject = JSON5.parseJSON(jsonStr)
+```
+
+## License
+
+MIT

package/dist/exports/Exports.d.ts

@@ -0,0 +1,6 @@
+export * from '../json5/Json5Encoder.js';
+export * from '../json5/Json5Parser.js';
+export * from '../json/JsonEncoder.js';
+export * from '../json/JsonParser.js';
+export * from '../types/Types.js';
+//# sourceMappingURL=Exports.d.ts.map

package/dist/exports/Exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Exports.d.ts","sourceRoot":"","sources":["../../src/exports/Exports.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAA;AACxC,cAAc,yBAAyB,CAAA;AAEvC,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AAErC,cAAc,mBAAmB,CAAA"}

package/dist/exports/Exports.js

@@ -0,0 +1,6 @@
+export * from '../json5/Json5Encoder.js';
+export * from '../json5/Json5Parser.js';
+export * from '../json/JsonEncoder.js';
+export * from '../json/JsonParser.js';
+export * from '../types/Types.js';
+//# sourceMappingURL=Exports.js.map

package/dist/exports/Exports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Exports.js","sourceRoot":"","sources":["../../src/exports/Exports.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAA;AACxC,cAAc,yBAAyB,CAAA;AAEvC,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AAErC,cAAc,mBAAmB,CAAA"}

package/dist/json/JsonEncoder.d.ts

@@ -0,0 +1,3 @@
+import { JsonReplacerType } from '../types/Types.js';
+export declare function stringifyJSON(obj: any, replacer?: JsonReplacerType, space?: number): any;
+//# sourceMappingURL=JsonEncoder.d.ts.map

package/dist/json/JsonEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonEncoder.d.ts","sourceRoot":"","sources":["../../src/json/JsonEncoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AAG1E,wBAAgB,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,CAAC,EAAE,gBAAgB,EAAE,KAAK,SAAI,OAsI7E"}

package/dist/json/JsonEncoder.js

@@ -0,0 +1,147 @@
+import { charCodeToHex } from '../utilities/Utilities.js';
+export function stringifyJSON(obj, replacer, space = 0) {
+    let replacerFunc;
+    if (replacer != null) {
+        if (Array.isArray(replacer)) {
+            const replacerSet = new Set();
+            for (const key of replacer) {
+                replacerSet.add(String(key));
+            }
+            replacerFunc = (key, value) => {
+                if (replacerSet.has(key)) {
+                    return value;
+                }
+            };
+        }
+        else if (typeof replacer === 'function') {
+            replacerFunc = replacer;
+        }
+        else {
+            throw new TypeError('Invalid replacer argument.');
+        }
+    }
+    const baseIndentString = ' '.repeat(space);
+    let currentIndentLevel = 0;
+    function getIndentString() {
+        if (space === 0) {
+            return '';
+        }
+        const spaces = baseIndentString.repeat(currentIndentLevel);
+        return `\n${spaces}`;
+    }
+    function encode(obj) {
+        if (obj === undefined) {
+            return '';
+        }
+        const typeofObj = typeof obj;
+        if (obj === null || typeofObj === 'boolean') {
+            return String(obj);
+        }
+        if (typeofObj === 'number') {
+            if (isNaN(obj) || obj === Infinity || obj === -Infinity) {
+                throw new Error(`NaN and Infinity can't be encoded in JSON`);
+            }
+            return String(obj);
+        }
+        if (typeofObj === 'string') {
+            return `"${escapeStringIfNeeded(obj)}"`;
+        }
+        if (typeof obj !== 'object') {
+            throw new Error(`Type '${typeof obj}' cannot be encoded in JSON`);
+        }
+        if (typeof obj.toJSON === 'function') {
+            return obj.toJSON();
+        }
+        if (Array.isArray(obj)) {
+            let str = '[';
+            let isFirstElement = true;
+            for (let i = 0; i < obj.length; i++) {
+                const element = obj[i];
+                if (element === undefined) {
+                    continue;
+                }
+                currentIndentLevel += 1;
+                const saparatingComma = isFirstElement === true ? '' : ',';
+                const indentString = getIndentString();
+                const encodedElement = encode(element);
+                str += `${saparatingComma}${indentString}${encodedElement}`;
+                currentIndentLevel -= 1;
+                isFirstElement = false;
+            }
+            str += `${getIndentString()}]`;
+            return str;
+        }
+        else {
+            let str = '{';
+            let isFirstEntry = true;
+            for (const key in obj) {
+                let value = obj[key];
+                if (replacerFunc !== undefined) {
+                    value = replacerFunc(key, value);
+                }
+                if (value === undefined) {
+                    continue;
+                }
+                currentIndentLevel += 1;
+                const saparatingComma = isFirstEntry === true ? '' : ',';
+                const indentString = getIndentString();
+                const escapedKey = escapeStringIfNeeded(key);
+                const spaceAfterColons = space > 0 ? ' ' : '';
+                const encodedValue = encode(value);
+                str += `${saparatingComma}${indentString}"${escapedKey}":${spaceAfterColons}${encodedValue}`;
+                currentIndentLevel -= 1;
+                isFirstEntry = false;
+            }
+            str += `${getIndentString()}}`;
+            return str;
+        }
+    }
+    return encode(obj);
+}
+function escapeStringIfNeeded(str) {
+    if (!/["\\\x00-\x1F]/.test(str)) {
+        return str;
+    }
+    else {
+        return escapeString(str);
+    }
+}
+function escapeString(str) {
+    let escapedStr = '';
+    for (let i = 0; i < str.length; i++) {
+        const charCode = str.charCodeAt(i);
+        if (charCode >= 32) {
+            if (charCode === 34) { // '"'
+                escapedStr += '\\"';
+            }
+            else if (charCode === 92) { // '\\'
+                escapedStr += '\\\\';
+            }
+            else {
+                escapedStr += String.fromCharCode(charCode);
+            }
+        }
+        else {
+            if (charCode === 10) { // '\n'
+                escapedStr += '\\n';
+            }
+            else if (charCode === 13) { // '\r'
+                escapedStr += '\\r';
+            }
+            else if (charCode === 9) { // '\t'
+                escapedStr += '\\t';
+            }
+            else if (charCode === 12) { // '\f'
+                escapedStr += '\\f';
+            }
+            else if (charCode === 8) { // '\b'
+                escapedStr += '\\b';
+            }
+            else {
+                escapedStr += `\\u${charCodeToHex(charCode)}`;
+            }
+        }
+    }
+    return escapedStr;
+}
+//# sourceMappingURL=JsonEncoder.js.map

package/dist/json/JsonEncoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonEncoder.js","sourceRoot":"","sources":["../../src/json/JsonEncoder.ts"],"names":[],"mappings":"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"}

package/dist/json/JsonParser.d.ts

@@ -0,0 +1,3 @@
+import { JsonReviverFunction } from '../types/Types.js';
+export declare function parseJSON(jsonString: string, reviver?: JsonReviverFunction): any;
+//# sourceMappingURL=JsonParser.d.ts.map

package/dist/json/JsonParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonParser.d.ts","sourceRoot":"","sources":["../../src/json/JsonParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAIvD,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,OAse1E"}

package/dist/json/JsonParser.js

@@ -0,0 +1,378 @@
+import { JsonParserError } from '../utilities/JsonParseError.js';
+import { getPositionInfo, hexCharCodeToNumber, positivePowersOf10 } from '../utilities/Utilities.js';
+export function parseJSON(jsonString, reviver) {
+    if (typeof jsonString !== 'string') {
+        throw new TypeError(`Given JSON string argument is not a string.`);
+    }
+    if (reviver !== undefined && typeof reviver !== 'function') {
+        throw new TypeError(`Reviver can only be a function.`);
+    }
+    let readPosition = 0;
+    function parse(initialCharCode) {
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        // Parse string
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        if (initialCharCode === 34) { // '"' for string start
+            readPosition += 1;
+            // Try to quickly parse the string for the common case where there are no escape patterns
+            {
+                const match = jsonString.substring(readPosition).match(/^[^\\\x00-\x1F]*?"/);
+                if (match !== null) {
+                    const matchString = match[0];
+                    const str = matchString.substring(0, matchString.length - 1);
+                    readPosition += matchString.length;
+                    return str;
+                }
+            }
+            // Fallback to slower method if an escape pattern is found or string is unterminated.
+            let decodedString = '';
+            while (true) {
+                const charCode = readCharCodeAndAdvance();
+                if (charCode === 34) { // '"'
+                    break;
+                }
+                else if (charCode === 92) { // '\\'
+                    const escapedCharCharcode = readCharCodeAndAdvance();
+                    if (escapedCharCharcode <= 92) {
+                        if (escapedCharCharcode === 34 || escapedCharCharcode === 92 || escapedCharCharcode === 47) { // '"', '\' and '/'
+                            decodedString += String.fromCharCode(escapedCharCharcode);
+                        }
+                        else {
+                            const positionInfo = getInfoForPosition(readPosition - 2);
+                            throw new JsonParserError(`Invalid escaped character '${String.fromCharCode(escapedCharCharcode)}' in escape sequence starting at ${positionInfo.positionString}.`, positionInfo);
+                        }
+                    }
+                    else if (escapedCharCharcode === 110) { // 'n'
+                        decodedString += '\n';
+                    }
+                    else if (escapedCharCharcode === 114) { // 'r'
+                        decodedString += '\r';
+                    }
+                    else if (escapedCharCharcode === 116) { // 't'
+                        decodedString += '\t';
+                    }
+                    else if (escapedCharCharcode === 117) { // 'u'
+                        if (readPosition + 4 > jsonString.length) {
+                            const positionInfo = getInfoForCurrentReadPosition();
+                            throw new JsonParserError(`Unterminated hexadecimal sequence. Expected 4 hexadecimal characters at ${positionInfo.positionString}.`, positionInfo);
+                        }
+                        const codePoint = hexCharCodeToNumber(jsonString.charCodeAt(readPosition + 0)) << 12 |
+                            hexCharCodeToNumber(jsonString.charCodeAt(readPosition + 1)) << 8 |
+                            hexCharCodeToNumber(jsonString.charCodeAt(readPosition + 2)) << 4 |
+                            hexCharCodeToNumber(jsonString.charCodeAt(readPosition + 3));
+                        decodedString += String.fromCharCode(codePoint);
+                        readPosition += 4;
+                    }
+                    else if (escapedCharCharcode === 102) { // 'f'
+                        decodedString += '\f';
+                    }
+                    else if (escapedCharCharcode === 98) { // 'b'
+                        decodedString += '\b';
+                    }
+                    else {
+                        const positionInfo = getInfoForPosition(readPosition - 2);
+                        throw new JsonParserError(`Invalid escaped character '${String.fromCharCode(escapedCharCharcode)}' in escape sequence at ${positionInfo.positionString}.`, positionInfo);
+                    }
+                }
+                else if (charCode === undefined) {
+                    const positionInfo = getInfoForPosition(jsonString.length - 1);
+                    throw new JsonParserError(`Unterminated string literal.`, positionInfo);
+                }
+                else if (charCode < 32) {
+                    const positionInfo = getInfoForPosition(readPosition - 1);
+                    throw new JsonParserError(`Invalid unescaped control character (${charCode}) at ${positionInfo.positionString}.`, positionInfo);
+                }
+                else {
+                    decodedString += String.fromCharCode(charCode);
+                }
+            }
+            return decodedString;
+        }
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        // Parse number
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        if (initialCharCode < 91) { // '0'-'9' or '-' for number start
+            let numberStringStartPosition = readPosition;
+            let charCode = initialCharCode;
+            let isNegative;
+            if (charCode === 45) { // '-'
+                isNegative = true;
+                charCode = advanceAndReadCharCode();
+            }
+            else {
+                isNegative = false;
+            }
+            let concatenatedInteger = 0;
+            // Parse integer part
+            {
+                const digitsStartPosition = readPosition;
+                while (charCode >= 48 && charCode <= 57) { // '0'-'9'
+                    const digitValue = charCode - 48;
+                    concatenatedInteger = (concatenatedInteger * 10) + digitValue;
+                    charCode = advanceAndReadCharCode();
+                }
+                const integerPartDigitCount = readPosition - digitsStartPosition;
+                if (integerPartDigitCount === 0) {
+                    const positionInfo = getInfoForCurrentReadPosition();
+                    throw new JsonParserError(`Invalid character '${String.fromCharCode(charCode)}' at ${positionInfo.positionString}.`, positionInfo);
+                }
+                if (integerPartDigitCount > 1 && jsonString[digitsStartPosition] === '0') {
+                    const positionInfo = getInfoForPosition(digitsStartPosition);
+                    throw new JsonParserError(`Invalid leading zero found in number literal at ${positionInfo.positionString}.`, positionInfo);
+                }
+            }
+            let fractionalDigitCount = 0;
+            // Parse fractional part
+            if (charCode === 46) { // '.'
+                charCode = advanceAndReadCharCode();
+                const digitsStartPosition = readPosition;
+                while (charCode >= 48 && charCode <= 57) { // '0'-'9'
+                    const digitValue = charCode - 48;
+                    concatenatedInteger = (concatenatedInteger * 10) + digitValue;
+                    charCode = advanceAndReadCharCode();
+                }
+                fractionalDigitCount = readPosition - digitsStartPosition;
+                if (fractionalDigitCount === 0) {
+                    const positionInfo = getInfoForCurrentReadPosition();
+                    throw new JsonParserError(`Invalid character '${String.fromCharCode(charCode)}' at ${positionInfo.positionString}. Exepcted at least one decimal digit following '.'.`, positionInfo);
+                }
+            }
+            let exponent = 0;
+            // Parse exponent part
+            if (charCode === 101 || charCode === 69) { // 'e' or 'E'
+                charCode = advanceAndReadCharCode();
+                let isNegativeExponent = false;
+                if (charCode === 43) { // '+'
+                    charCode = advanceAndReadCharCode();
+                }
+                else if (charCode === 45) { // '-'
+                    isNegativeExponent = true;
+                    charCode = advanceAndReadCharCode();
+                }
+                let exponentDigitsStartPosition = readPosition;
+                while (charCode >= 48 && charCode <= 57) { // '0'-'9'
+                    const digitValue = charCode - 48;
+                    exponent = (exponent * 10) + digitValue;
+                    charCode = advanceAndReadCharCode();
+                }
+                if (readPosition === exponentDigitsStartPosition) {
+                    const positionInfo = getInfoForCurrentReadPosition();
+                    throw new JsonParserError(`Invalid character '${String.fromCharCode(charCode)}' at ${positionInfo.positionString}. Exepcted at least one exponent digit.`, positionInfo);
+                }
+                if (isNegativeExponent) {
+                    exponent = -exponent;
+                }
+            }
+            const adjustedExponent = exponent - fractionalDigitCount;
+            // Use fast method for cases where the number can be parsed efficiently,
+            // or fall back to slower method if not possible.
+            if (concatenatedInteger < 2 ** 53 && adjustedExponent >= -22 && adjustedExponent <= 22) {
+                let parsedNumber = concatenatedInteger;
+                if (adjustedExponent > 0) {
+                    parsedNumber *= positivePowersOf10[adjustedExponent];
+                }
+                else if (adjustedExponent < 0) {
+                    parsedNumber /= positivePowersOf10[-adjustedExponent];
+                }
+                if (isNegative) {
+                    return -parsedNumber;
+                }
+                else {
+                    return parsedNumber;
+                }
+            }
+            else {
+                return Number(jsonString.substring(numberStringStartPosition, readPosition));
+            }
+        }
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        // Parse 'true' literal
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        if (initialCharCode === 116) { // 't' for true
+            if (jsonString.charCodeAt(readPosition + 1) !== 114 || // 'r'
+                jsonString.charCodeAt(readPosition + 2) !== 117 || // 'u'
+                jsonString.charCodeAt(readPosition + 3) !== 101) { // 'e'
+                const positionInfo = getInfoForCurrentReadPosition();
+                throw new JsonParserError(`Expected 'true' at ${positionInfo.positionString}.`, positionInfo);
+            }
+            readPosition += 4;
+            return true;
+        }
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        // Parse 'false' literal
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        if (initialCharCode === 102) { // 'f' for false
+            if (jsonString.charCodeAt(readPosition + 1) !== 97 || // 'a'
+                jsonString.charCodeAt(readPosition + 2) !== 108 || // 'l'
+                jsonString.charCodeAt(readPosition + 3) !== 115 || // 's'
+                jsonString.charCodeAt(readPosition + 4) !== 101) { // 'e'
+                const positionInfo = getInfoForCurrentReadPosition();
+                throw new JsonParserError(`Expected 'false' at ${positionInfo.positionString}.`, positionInfo);
+            }
+            readPosition += 5;
+            return false;
+        }
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        // Parse 'null' literal
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        if (initialCharCode === 110) { // 'n' for null
+            if (jsonString.charCodeAt(readPosition + 1) !== 117 || // 'u'
+                jsonString.charCodeAt(readPosition + 2) !== 108 || // 'l'
+                jsonString.charCodeAt(readPosition + 3) !== 108) { // 'l'
+                const positionInfo = getInfoForCurrentReadPosition();
+                throw new JsonParserError(`Expected 'null' at ${positionInfo.positionString}.`, positionInfo);
+            }
+            readPosition += 4;
+            return null;
+        }
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        // Parse array
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        if (initialCharCode === 91) { // '[' for array start
+            readPosition += 1;
+            let charCode = skipToNextReadableCharCode();
+            if (charCode === 93) { // ']' for array end
+                readPosition += 1;
+                return [];
+            }
+            const arr = [];
+            while (true) {
+                const elementStartPosition = readPosition;
+                let element = parse(charCode);
+                if (reviver !== undefined) {
+                    element = applyReviver('', element, elementStartPosition);
+                }
+                arr.push(element);
+                charCode = skipToNextReadableCharCode();
+                if (charCode === 44) { // ',' for comma
+                    readPosition += 1;
+                    charCode = skipToNextReadableCharCode();
+                    continue;
+                }
+                if (charCode === 93) { // ']' for array end
+                    readPosition += 1;
+                    break;
+                }
+                {
+                    const positionInfo = getInfoForCurrentReadPosition();
+                    throw new JsonParserError(`Invalid character '${String.fromCharCode(charCode)}' in array expression at ${positionInfo.positionString}. Expected ',' or ']'.`, positionInfo);
+                }
+            }
+            return arr;
+        }
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        // Parse object
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        if (initialCharCode === 123) { // '{' for object start
+            readPosition += 1;
+            let charCode = skipToNextReadableCharCode();
+            if (charCode === 125) { // '}' for object end
+                readPosition += 1;
+                return {};
+            }
+            const obj = {};
+            while (true) {
+                if (charCode !== 34) {
+                    const positionInfo = getInfoForCurrentReadPosition();
+                    throw new JsonParserError(`Invalid character '${String.fromCharCode(charCode)}' at ${positionInfo.positionString}. Expected '"'.`, positionInfo);
+                }
+                const key = parse(charCode);
+                charCode = skipToNextReadableCharCode();
+                if (charCode !== 58) { // ':'
+                    const positionInfo = getInfoForCurrentReadPosition();
+                    throw new JsonParserError(`Invalid character '${String.fromCharCode(charCode)}' at ${positionInfo.positionString}. Expected ':'.`, positionInfo);
+                }
+                readPosition += 1;
+                charCode = skipToNextReadableCharCode();
+                const valueStartPosition = readPosition;
+                let value = parse(charCode);
+                if (reviver !== undefined) {
+                    value = applyReviver(key, value, valueStartPosition, obj);
+                }
+                obj[key] = value;
+                const commaOrClosingBraceCharCode = skipToNextReadableCharCode();
+                if (commaOrClosingBraceCharCode === 44) { // ','
+                    readPosition += 1;
+                    charCode = skipToNextReadableCharCode();
+                    continue;
+                }
+                if (commaOrClosingBraceCharCode === 125) { // '}'
+                    readPosition += 1;
+                    break;
+                }
+                {
+                    const positionInfo = getInfoForCurrentReadPosition();
+                    throw new JsonParserError(`Invalid character '${String.fromCharCode(commaOrClosingBraceCharCode)}' in object expression at ${positionInfo.positionString}. Expected ',' or '}'.`, positionInfo);
+                }
+            }
+            return obj;
+        }
+        {
+            const positionInfo = getInfoForCurrentReadPosition();
+            throw new JsonParserError(`Invalid character '${String.fromCharCode(initialCharCode)}' at ${positionInfo.positionString}.`, positionInfo);
+        }
+    }
+    function advanceAndReadCharCode() {
+        return jsonString.charCodeAt(++readPosition);
+    }
+    function readCharCodeAndAdvance() {
+        return jsonString.charCodeAt(readPosition++);
+    }
+    function skipWhitespace() {
+        while (readPosition < jsonString.length) {
+            const charCode = jsonString.charCodeAt(readPosition);
+            if (charCode > 32 || (charCode !== 32 && charCode !== 10 && charCode !== 13 && charCode !== 9)) {
+                return charCode;
+            }
+            readPosition += 1;
+        }
+        return undefined;
+    }
+    function skipToNextReadableCharCode() {
+        const nextCharCode = skipWhitespace();
+        if (nextCharCode === undefined) {
+            const positionInfo = getInfoForPosition(jsonString.length - 1);
+            throw new JsonParserError(`Unexpected termination of JSON input.`, positionInfo);
+        }
+        return nextCharCode;
+    }
+    function getInfoForCurrentReadPosition() {
+        return getInfoForPosition(readPosition);
+    }
+    function getInfoForPosition(position) {
+        return getPositionInfo(jsonString, position);
+    }
+    function applyReviver(key, value, valueStartPosition, thisArg) {
+        if (reviver === undefined) {
+            return;
+        }
+        let context;
+        if (typeof value !== 'object' || value === null) {
+            context = jsonString.substring(valueStartPosition, readPosition);
+        }
+        let result;
+        if (thisArg) {
+            result = reviver.call(thisArg, key, value, context);
+        }
+        else {
+            result = reviver(key, value, context);
+        }
+        return result;
+    }
+    // Parse the given string
+    {
+        const initialCharCode = skipToNextReadableCharCode();
+        const documentStartPosition = readPosition;
+        let result = parse(initialCharCode);
+        if (reviver !== undefined) {
+            result = applyReviver('', result, documentStartPosition);
+        }
+        const finalSkipResult = skipWhitespace();
+        if (finalSkipResult !== undefined) {
+            const positionInfo = getInfoForCurrentReadPosition();
+            throw new JsonParserError(`Unexpected trailing character(s) starting at ${positionInfo.positionString}.`, positionInfo);
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=JsonParser.js.map