quick-json5 0.1.0

package/src/utilities/ObjectUtilities.ts

@@ -0,0 +1,184 @@
+import { TypedArray } from './TypedArray.js'
+
+export function deepEquals(obj1: unknown, obj2: unknown): boolean {
+	if (obj1 === obj2) {
+		return true // Values or references are exactly equal
+	}
+
+	// From this point, values are known to not be equal
+
+	// Take types
+	const obj1Type = typeof obj1
+	const obj2Type = typeof obj2
+
+	// `typeof obj` can be:
+	// "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+
+	if (obj1Type !== obj2Type) { // If types mismatch
+		return false // Includes case when one is null and the other undefined
+	}
+
+	// Handle NaN equality
+	if (obj1Type === 'number' && isNaN(obj1 as number) && isNaN(obj2 as number)) {
+		return true
+	}
+
+	if (obj1Type !== 'object') { // If both are not objects (we know they have the same type at this point)
+		// Return false, since values are not equal, and types other then "object" need to have
+		// full equality to return true.
+		return false
+	}
+
+	// Get object type tags for both
+	const obj1Tag = toString.call(obj1)
+	const obj2Tag = toString.call(obj2)
+
+	if (obj1Tag !== obj2Tag) {
+		return false
+	}
+
+	switch (obj1Tag) {
+		case '[object Array]': {
+			const arr1 = obj1 as any[]
+			const arr2 = obj2 as any[]
+
+			if (arr1.length !== arr2.length) {
+				return false
+			}
+
+			for (let i = 0; i < arr1.length; i++) {
+				if (!deepEquals(arr1[i], arr2[i])) {
+					return false
+				}
+			}
+
+			return true
+		}
+
+		case '[object Map]': {
+			const map1 = obj1 as Map<any, any>
+			const map2 = obj2 as Map<any, any>
+
+			if (map1.size !== map1.size) {
+				return false
+			}
+
+			for (const [key, value] of map1) {
+				if (!map2.has(key)) {
+					return false
+				}
+
+				if (!deepEquals(value, map2.get(key))) {
+					return false
+				}
+			}
+
+			return true
+		}
+
+		case '[object Set]': {
+			const set1 = obj1 as Set<any>
+			const set2 = obj2 as Set<any>
+
+			if (set1.size !== set2.size) {
+				return false
+			}
+
+			for (const element of set1) {
+				if (!set2.has(element)) {
+					return false
+				}
+			}
+
+			return true
+		}
+
+		case '[object Int8Array]':
+		case '[object Uint8Array]':
+		case '[object Uint8ClampedArray]':
+		case '[object Int16Array]':
+		case '[object Uint16Array]':
+		case '[object Int32Array]':
+		case '[object Uint32Array]':
+		case '[object BigInt64Array]':
+		case '[object BigUint64Array]':
+		case '[object Float32Array]':
+		case '[object Float64Array]': {
+			const arr1 = obj1 as TypedArray
+			const arr2 = obj2 as TypedArray
+
+			if (arr1.length !== arr2.length) {
+				return false
+			}
+
+			for (let i = 0; i < arr1.length; i++) {
+				if (arr1[i] !== arr2[i]) {
+					return false
+				}
+			}
+
+			return true
+		}
+
+		case '[object ArrayBuffer]': {
+			const arr1 = obj1 as ArrayBuffer
+			const arr2 = obj2 as ArrayBuffer
+
+			return deepEquals(new Uint8Array(arr1), new Uint8Array(arr2))
+		}
+
+		case '[object DataView]': {
+			const dataView1 = obj1 as DataView
+			const dataView2 = obj2 as DataView
+
+			if (dataView1.byteOffset !== dataView2.byteOffset) {
+				return false
+			}
+
+			if (dataView1.byteLength !== dataView2.byteLength) {
+				return false
+			}
+
+			return deepEquals(dataView1.buffer, dataView2.buffer)
+		}
+
+		case '[object Date]': {
+			const date1 = obj1 as Date
+			const date2 = obj2 as Date
+
+			return date1.getTime() === date2.getTime()
+		}
+
+		case '[object RegExp]': {
+			const regExp1 = obj1 as RegExp
+			const regExp2 = obj2 as RegExp
+
+			return regExp1.source === regExp2.source && regExp1.flags === regExp2.flags
+		}
+
+		default: {
+			// Compare own properties using Reflect.ownKeys to include Symbols and non-enumerable
+			const obj1Keys = Reflect.ownKeys(obj1 as any)
+			const obj2Keys = Reflect.ownKeys(obj2 as any)
+
+			if (obj1Keys.length !== obj2Keys.length) {
+				return false
+			}
+
+			for (const key of obj1Keys) {
+				if (!Reflect.has(obj2 as any, key)) { // Reflect.has checks own and inherited, sufficient here
+					return false
+				}
+
+				const val1 = Reflect.get(obj1 as any, key)
+				const val2 = Reflect.get(obj2 as any, key)
+
+				if (!deepEquals(val1, val2)) {
+					return false
+				}
+			}
+
+			return true
+		}
+	}
+}

package/src/utilities/TypedArray.ts

@@ -0,0 +1,39 @@
+export type TypedArray =
+	Int8Array |
+	Uint8Array |
+	Uint8ClampedArray |
+	Int16Array |
+	Uint16Array |
+	Int32Array |
+	Uint32Array |
+	BigInt64Array |
+	BigUint64Array |
+	Float32Array |
+	Float64Array
+
+export type TypedArrayConstructor =
+	Int8ArrayConstructor |
+	Uint8ArrayConstructor |
+	Uint8ClampedArrayConstructor |
+	Int16ArrayConstructor |
+	Uint16ArrayConstructor |
+	Int32ArrayConstructor |
+	Uint32ArrayConstructor |
+	BigInt64ArrayConstructor |
+	BigUint64ArrayConstructor |
+	Float32ArrayConstructor |
+	Float64ArrayConstructor
+
+export type TypedArrayToConstructor<T extends TypedArray> =
+	T extends Int8Array ? Int8ArrayConstructor :
+	T extends Uint8Array ? Uint8ArrayConstructor :
+	T extends Uint8ClampedArray ? Uint8ClampedArrayConstructor :
+	T extends Int16Array ? Int16ArrayConstructor :
+	T extends Uint16Array ? Uint16ArrayConstructor :
+	T extends Int32Array ? Int32ArrayConstructor :
+	T extends Uint32Array ? Uint32ArrayConstructor :
+	T extends BigInt64Array ? BigInt64ArrayConstructor :
+	T extends BigUint64Array ? BigUint64ArrayConstructor :
+	T extends Float32Array ? Float32ArrayConstructor :
+	T extends Float64Array ? Float64ArrayConstructor :
+	never;

package/src/utilities/Utilities.ts

@@ -0,0 +1,130 @@
+export function charCodeToHex(charcode: number): string {
+	function digitToCharCode(digit: number) {
+		if (digit < 10) {
+			return 48 + digit // 48 is '0'
+		} else {
+			return 65 + digit - 10 // 65 is 'A'
+		}
+	}
+
+	// Digit 1 (Least significant)
+	const charCode1 = digitToCharCode(charcode & 0xF)
+
+	// Digit 2
+	const charCode2 = digitToCharCode((charcode >>> 4) & 0xF)
+
+	// Digit 3
+	const charCode3 = digitToCharCode((charcode >>> 8) & 0xF)
+
+	// Digit 4 (Most significant)
+	const charCode4 = digitToCharCode((charcode >>> 12) & 0xF)
+
+	return String.fromCharCode(charCode4, charCode3, charCode2, charCode1)
+}
+
+export function hexCharCodeToNumber(charCode: number) {
+	if (charCode >= 48 && charCode <= 57) { // '0'..'9'
+		return charCode - 48
+	} if (charCode >= 65 && charCode <= 70) { // 'A'..'F'
+		return charCode - 65 + 10
+	} else if (charCode >= 97 && charCode <= 102) { // 'a'..'f'
+		return charCode - 97 + 10
+	} else {
+		throw new Error(`Invalid hexadecimal character: ${String.fromCharCode(charCode)}`)
+	}
+}
+
+export const positivePowersOf10 = new Float64Array([
+	1e+00, 1e+01, 1e+02, 1e+03, 1e+04, 1e+05, 1e+06, 1e+07, 1e+08, 1e+09,
+	1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17, 1e+18, 1e+19,
+	1e+20, 1e+21, 1e+22
+])
+
+// Converts a character offset in a string to a (line number, column) pair.
+//
+// Line and column numbers are 1-based.
+// Handles standard Unix (`\n`) and Windows (`\r\n`) line endings efficiently
+// by searching for the `\n` character.
+export function offsetToLineAndColumnNumber(text: string, charOffset: number): LineAndColumnNumber {
+	// Handle the edge case of offset 0 quickly
+	if (charOffset === 0) {
+		return { lineNumber: 1, columnNumber: 1 }
+	}
+
+	if (charOffset > text.length) {
+		throw new Error(`Character offset is larger than string length.`)
+	}
+
+	// Initialize line number and the position of the last line break found
+	let lineNumber = 1
+	let lastLineBreakPosition = -1
+	let searchPosition = 0 // Position to start the next search from
+
+	// Efficiently find line breaks using indexOf.
+	// We only need to search up to the target offset.
+	while (searchPosition < charOffset) {
+		const lineBreakPosition = text.indexOf('\n', searchPosition)
+
+		// If no more line breaks are found, or the next one is at or after the offset,
+		// the target offset is on the current line.
+		if (lineBreakPosition === -1 || lineBreakPosition >= charOffset) {
+			break
+		}
+
+		// Found a line break before the offset.
+		// Increment line number and update the position of the last line break.
+		lineNumber++
+		lastLineBreakPosition = lineBreakPosition
+
+		// Start the next search immediately after the found line break.
+		searchPosition = lineBreakPosition + 1
+	}
+
+	// Calculate the column number: it's the offset relative to the start of the current line.
+	// The start of the current line is the character immediately after the last line break,
+	// or the beginning of the string if no line breaks were found before the offset.
+	const columnNumber = charOffset - (lastLineBreakPosition + 1) + 1
+
+	return { lineNumber, columnNumber }
+}
+
+export function getPositionInfo(text: string, charOffset: number): PositionInfo {
+	charOffset = clip(charOffset, 0, text.length - 1)
+
+	const {  lineNumber, columnNumber } = offsetToLineAndColumnNumber(text, charOffset)
+
+	return {
+		charOffset,
+
+		lineNumber,
+		columnNumber,
+
+		positionString: `position ${charOffset} (line ${lineNumber}, column ${columnNumber})`
+	}
+}
+
+export function clip(num: number, min: number, max: number) {
+	if (num < min) {
+		return min
+	}
+
+	if (num > max) {
+		return max
+	}
+
+	return num
+}
+
+export interface LineAndColumnNumber {
+	lineNumber: number
+	columnNumber: number
+}
+
+export interface PositionInfo {
+	charOffset: number
+
+	lineNumber: number
+	columnNumber: number
+
+	positionString: string
+}

package/tsconfig.json

@@ -0,0 +1,55 @@
+{
+  // Visit https://aka.ms/tsconfig to read more about this file
+  "compilerOptions": {
+	// File Layout
+	"rootDir": "./src",
+	"outDir": "./dist",
+
+	// Environment Settings
+	// See also https://aka.ms/tsconfig/module
+	"module": "nodenext",
+	"target": "esnext",
+	"types": ["node"],
+	// For nodejs:
+	// "lib": ["esnext"],
+	// "types": ["node"],
+	// and npm install -D @types/node
+
+	// Other Outputs
+	"sourceMap": true,
+	"declaration": true,
+	"declarationMap": true,
+
+	// Stricter Typechecking Options
+	// "noUncheckedIndexedAccess": true,
+	// "exactOptionalPropertyTypes": true,
+
+	// Style Options
+	"noImplicitReturns": true,
+	// "noImplicitOverride": true,
+	// "noUnusedLocals": true,
+	// "noUnusedParameters": true,
+	// "noFallthroughCasesInSwitch": true,
+	// "noPropertyAccessFromIndexSignature": true,
+
+	// Recommended Options
+	"strict": true,
+	"jsx": "react-jsx",
+	// "verbatimModuleSyntax": true,
+	"isolatedModules": true,
+	"noUncheckedSideEffectImports": true,
+	"moduleDetection": "force",
+	"skipLibCheck": true,
+
+	// Extended options not in generated tsconfig.json
+	"newLine": "lf",
+	"forceConsistentCasingInFileNames": true,
+	"alwaysStrict": true,
+
+	"noImplicitThis": true,
+	"strictBindCallApply": true,
+	"strictFunctionTypes": true,
+
+	"noErrorTruncation": true,
+  }
+}