quick-json5 0.1.0

package/src/json/JsonParser.ts

@@ -0,0 +1,491 @@
+import { JsonReviverFunction } from '../types/Types.js'
+import { JsonParserError } from '../utilities/JsonParseError.js'
+import { getPositionInfo, hexCharCodeToNumber, positivePowersOf10 } from '../utilities/Utilities.js'
+
+export function parseJSON(jsonString: string, reviver?: JsonReviverFunction) {
+	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: number) {
+		////////////////////////////////////////////////////////////////////////////////////////////
+		// 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: boolean
+
+			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: any[] = []
+
+			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: any = {}
+
+			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: number) {
+		return getPositionInfo(jsonString, position)
+	}
+
+	function applyReviver(key: string, value: any, valueStartPosition: number, thisArg?: any) {
+		if (reviver === undefined) {
+			return
+		}
+
+		let context: string | undefined
+
+		if (typeof value !== 'object' || value === null) {
+			context = jsonString.substring(valueStartPosition, readPosition)
+		}
+
+		let result: any
+
+		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
+	}
+}

package/src/json5/Json5Encoder.ts

@@ -0,0 +1,189 @@
+import { Json5Options, JsonReplacerFunction, JsonReplacerType } from '../types/Types.js'
+import { charCodeToHex } from '../utilities/Utilities.js'
+
+export function stringify(obj: any, replacer?: JsonReplacerType, space = 0, options?: Json5Options) {
+	const extensionsEnabled = options?.enableExtensions
+
+	let replacerFunc: JsonReplacerFunction | undefined
+
+	if (replacer != null) {
+		if (typeof replacer === 'function') {
+			replacerFunc = replacer
+		} else 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 {
+			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: any) {
+		if (obj === undefined) {
+			return ''
+		}
+
+		const typeofObj = typeof obj
+
+		if (obj === null || typeofObj === 'number' || typeofObj === 'boolean') {
+			return String(obj)
+		}
+
+		if (typeofObj === 'bigint') {
+			if (extensionsEnabled === false) {
+				throw new Error(`Encoding BigInt values requires JSON5 extensions to be enabled in options.`)
+			}
+
+			return String(obj)
+		}
+
+		if (typeofObj === 'string') {
+			return `"${escapeStringIfNeeded(obj)}"`
+		}
+
+		if (typeof obj !== 'object') {
+			throw new Error(`Type '${typeof obj}' can't be encoded in JSON5.`)
+		}
+
+		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 keyDoesNotRequireQuoting = /^[\p{ID_Start}\$_\u200C\u200D](?:[\p{ID_Continue}\$_\u200C\u200D])*$/u.test(key)
+				const keyWithPossibleQuotes = keyDoesNotRequireQuoting ? key : `"${escapeStringIfNeeded(key)}"`
+
+				const spaceAfterColons = space > 0 ? ' ' : ''
+
+				const encodedValue = encode(value)
+
+				str += `${saparatingComma}${indentString}${keyWithPossibleQuotes}:${spaceAfterColons}${encodedValue}`
+
+				currentIndentLevel -= 1
+
+				isFirstEntry = false
+			}
+
+			str += `${getIndentString()}}`
+
+			return str
+		}
+	}
+
+	return encode(obj)
+}
+
+function escapeStringIfNeeded(str: string): string {
+	if (!/["\\\x00-\x1F]/.test(str)) {
+		return str
+	} else {
+		return escapeString(str)
+	}
+}
+
+function escapeString(str: string): string {
+	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 if (charCode === 11) { // '\v'
+				escapedStr += '\\v'
+			} else if (charCode === 0) { // '\v'
+				escapedStr += '\\0'
+			} else {
+				escapedStr += `\\u${charCodeToHex(charCode)}`
+			}
+		}
+	}
+
+	return escapedStr
+}