index.js

const delimiter = "\uFFFD" // eslint complains about the file appearing to be binary if the character is pasted in
const forbiddenRecordKeys = ["__proto__", "prototype"]

const unescapedColonRegex = /(?<!\\):/g
const unescapedDelimiterRegex = new RegExp(`(?<!\\\\)${delimiter}`, "g")
const escapedColonRegex = /\\:/g
const escapedDelimiterRegex = new RegExp(`\\\\${delimiter}`, "g")
const escapedForwardSlashAtEndRegex = /\\$/

/**
 * If what's supplied is a Record and not null or an Array
 * @template T
 * @param {T} item
 * @returns {T extends Record<any, any> ? true : false}
 */
function isObject(item) {
	// @ts-expect-error true or false is a boolean
	return (typeof item === "object" && !Array.isArray(item) && item !== null)
}

// encode

/**
 * Transforms supported non Record and Array data types to a string to be appended to the encoding result
 * @param {any} item
 * @returns {string}
 */
function encodePrimitive(item) {
	if (item === null) return "n" // nil
	const t = typeof item
	switch (t) {
	case "bigint":
		return `b${item}` // bigint
	case "undefined":
		return "v" // void
	case "string":
		return `"${item.replace(unescapedDelimiterRegex, `\\${delimiter}`).replace(escapedForwardSlashAtEndRegex, "")}` // strings
	case "boolean":
		return item ? "t" : "f" // booleans
	case "number":
		return String(item)
	default:
		throw new Error(`Don't know how to encode ${t}: ${require("util").inspect(item)}`)
	}
}

/**
 * Actually encodes items to their string formats
 * @param {any} item
 * @returns {string}
 */
function encodePush(item) {
	let rt = ""

	if (isObject(item)) rt += `{${encodeStep(item)}}` // obj
	else if (Array.isArray(item)) {
		// array
		const mapped = item.map((i, ind, arr) => {
			return isObject(i)
				? `{${encodeStep(i)}}`
				// [...null, 1000] => [...n�1000] Appends delimiter if isn't last element
				: `${encodeStep(i)}${ind !== arr.length - 1 ? delimiter : ""}`
		}).join("")
		rt += `[${mapped}]`

	} else rt += encodePrimitive(item)

	return rt
}

/**
 * @param {Record<string, any> | Array<any>} info
 * @returns {string}
 */
function encodeStep(info) {
	let rt = ""

	if (!isObject(info)) rt += encodePush(info)
	else {
		const keys = Object.keys(info)

		for (let index = 0; index < keys.length; index++) {
			const key = keys[index]
			if (forbiddenRecordKeys.includes(key)) continue
			rt += `${key.replace(unescapedColonRegex, "\\:")}:`
			// @ts-expect-error It will be an Object here
			rt += encodePush(info[key])

			// They have their own endings, so space can be saved
			// @ts-expect-error It will be an Object here
			if ((index !== keys.length - 1) && !isObject(info[key]) && !Array.isArray(info[key])) rt += delimiter
		}
	}

	return rt
}

/**
 * A method to encode custom data in a space efficient and supportive format similar to JSON-ish.
 * Keys cannot be "\_\_proto\_\_" or "prototype"
 * @param {Record<string, any> | Array<any>} info
 * @returns {string}
 */
function encode(info) {
	if (!info) return ""
	if (!isObject(info) && !Array.isArray(info)) throw new Error("Cannot encode non Records or Arrays by themselves")

	return encodeStep(info)
}

// decode

/**
 * @param {string} text
 * @param {number} openPos
 * @param {"]" | "}"} expecting
 * @returns {number}
 */
function findClosing(text, openPos, expecting) {
	let closePos = openPos
	let counter = 1
	const opener = expecting === "]" ? "[" : "{"
	while (counter > 0) {
		if (text.length === closePos) throw new Error(`Unbalanced ${expecting}`)
		const c = text[++closePos]
		if (c === opener) counter++
		else if (c === expecting) counter--
	}
	return closePos
}

/**
 * @param {string} str
 * @param {string} item
 * @returns {number}
 */
function indexOfNextUnescapedItem(str, item) {
	const index = str.indexOf(item)
	if (index === -1) return -1
	if (index === 0) return 1 + indexOfNextUnescapedItem(str.slice(1), item)
	if (str[index - 1] === "\\") return index + indexOfNextUnescapedItem(str.slice(index + 1), item)
	return index
}

/**
 * Transforms supported encoded non Record and Array data types to their decoded types
 * @param {string} val
 * @returns {any}
 */
function decodePrimitive(val) {
	let actualValue

	switch (val[0]) {
	case "t":
		actualValue = true
		break
	case "f":
		actualValue = false
		break
	case "v":
		actualValue = void 0
		break
	case "n":
		actualValue = null
		break
	case "b":
		actualValue = BigInt(val.slice(1))
		break
	case "\"":
		actualValue = val.slice(1).replace(escapedDelimiterRegex, delimiter)
		break
	default:
		actualValue = Number(val)
		break
	}

	return actualValue
}

/**
 * @param {string} str
 * @returns {any}
 */
function decodeStep(str) {
	let rt = str.startsWith("[") ? [] : {}
	let text = str

	while (text.length) {
		let key = ""
		let ignore = false

		if (isObject(rt)) {
			const firstColon = indexOfNextUnescapedItem(text, ":")
			key = text.slice(0, firstColon)
			if (forbiddenRecordKeys.includes(key)) ignore = true
			text = text.slice(firstColon + 1)
		}

		const nextDelimiter = indexOfNextUnescapedItem(text, delimiter)
		const endToUse = nextDelimiter === -1 ? text.length : nextDelimiter

		let actualValue
		switch (text[0]) {
		case "{": {
			const closingIndex = findClosing(text, 0, "}")
			if (!ignore) actualValue = decodeStep(text.slice(1, closingIndex))
			text = text.slice(closingIndex + 1)

			break
		}
		case "[": {
			const closingIndex = findClosing(text, 0, "]")
			let text2 = text.slice(1, closingIndex)
			const holder = []

			if (!ignore) {
				while (text2.length) {
					switch (text2[0]) {
					case "{": {
						const closingIndex2 = findClosing(text2, 0, "}")
						const toPush = decodeStep(text2.slice(1, closingIndex2))
						holder.push(toPush)
						text2 = text2.slice(closingIndex2 + 1)
						break
					}
					case "[": {
						const closingIndex2 = findClosing(text2, 0, "]")
						const toPush = decodeStep(text2.slice(0, closingIndex2 + 1))
						holder.push(toPush)
						text2 = text2.slice(closingIndex2 + 2) // will always be a delimiter after otherwise if end of string, will clamp to end
						break
					}
					default: {
						const nextDelimiter2 = indexOfNextUnescapedItem(text2, delimiter)
						const endToUse2 = nextDelimiter2 === -1 ? text2.length : nextDelimiter2
						const sliced = text2.slice(0, endToUse2)
						const toPush = decodePrimitive(sliced)
						holder.push(toPush)
						text2 = text2.slice(endToUse2 + 1)
						break
					}
					}
				}
			}

			text = text.slice(closingIndex + 1)
			if (Array.isArray(rt)) {
				rt = holder
				ignore = true
			} else actualValue = holder

			break
		}
		default:
			actualValue = decodePrimitive(text.slice(0, endToUse))
			text = text.slice(endToUse + 1)
			break
		}

		if (ignore) continue
		// @ts-expect-error It will be an Object here
		if (isObject(rt)) rt[key.replace(escapedColonRegex, ":")] = actualValue
		// @ts-expect-error It will be an Array here
		else rt.push(actualValue)
	}

	return rt
}

/**
 * @param {string} str
 * @returns {any}
 */
function decode(str) {
	return decodeStep(str)
}

module.exports = { encode, decode }