echogarden 3.1.0 → 3.2.0

package/src/encodings/LEB128.ts

@@ -1,362 +0,0 @@
-import { DynamicUint8Array, createDynamicUint8Array } from "../data-structures/DynamicTypedArray.js"
-import { logToStderr } from "../utilities/Utilities.js"
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Encode unsigned integer
-////////////////////////////////////////////////////////////////////////////////////////////////////
-export function encodeUnsignedInt(value: number | bigint, outEncodedData: DynamicUint8Array) {
-	if (value < 0) {
-		throw new Error(`The negative value ${value} can't be encoded as an unsigned LEB128 integer.`)
-	}
-
-	if (typeof value === 'number') {
-		if (value < (2 ** 31)) {
-			return encodeUnsignedInt31(value, outEncodedData)
-		} else {
-			return encodeUnsignedBigInt(BigInt(value), outEncodedData)
-		}
-	} else {
-		return encodeUnsignedBigInt(value, outEncodedData)
-	}
-}
-
-function encodeUnsignedInt31(value: number, outEncodedData: DynamicUint8Array) {
-	value = value >>> 0
-
-	if (value < (2 ** 7)) {
-		outEncodedData.add(
-			value
-		)
-	} else if (value < (2 ** 14)) {
-		outEncodedData.addMany(
-			(value & 0b01111111) | 0b10000000,
-			value >>> 7
-		)
-	} else if (value < (2 ** 21)) {
-		outEncodedData.addMany(
-			(value & 0b01111111) | 0b10000000,
-			((value >>> 7) & 0b01111111) | 0b10000000,
-			value >>> 14
-		)
-	} else if (value < (2 ** 28)) {
-		outEncodedData.addMany(
-			(value & 0b01111111) | 0b10000000,
-			((value >>> 7) & 0b01111111) | 0b10000000,
-			((value >>> 14) & 0b01111111) | 0b10000000,
-			value >>> 21
-		)
-	} else {
-		outEncodedData.addMany(
-			(value & 0b01111111) | 0b10000000,
-			((value >>> 7) & 0b01111111) | 0b10000000,
-			((value >>> 14) & 0b01111111) | 0b10000000,
-			((value >>> 21) & 0b01111111) | 0b10000000,
-			value >>> 28
-		)
-	}
-
-	return outEncodedData
-}
-
-function encodeUnsignedBigInt(value: bigint, outEncodedData: DynamicUint8Array) {
-	while (true) {
-		const lowest7Bits = Number(value & 0b01111111n)
-
-		value = value >> 7n
-
-		if (value === 0n) {
-			outEncodedData.add(lowest7Bits)
-
-			return outEncodedData
-		} else {
-			outEncodedData.add(lowest7Bits | 0b10000000)
-		}
-	}
-}
-
-////////////////////////////////////////////////////////////////////////////////////
-// Decode unsigned integer
-////////////////////////////////////////////////////////////////////////////////////
-export function decodeUnsignedInt31Fast(encodedData: ArrayLike<number>, readOffset: number): DecodedValueAndReadOffset {
-	const byte0 = encodedData[readOffset++]
-
-	if ((byte0 & 0b10000000) === 0) {
-		const decodedValue =
-			byte0
-
-		return { decodedValue, readOffset }
-	}
-
-	const byte1 = encodedData[readOffset++]
-
-	if ((byte1 & 0b10000000) === 0) {
-		const decodedValue =
-			(byte0 & 0b01111111) |
-			(byte1 & 0b01111111) << 7
-
-		return { decodedValue, readOffset }
-	}
-
-	const byte2 = encodedData[readOffset++]
-
-	if ((byte2 & 0b10000000) === 0) {
-		const decodedValue =
-			(byte0 & 0b01111111) |
-			(byte1 & 0b01111111) << 7 |
-			(byte2 & 0b01111111) << 14
-
-		return { decodedValue, readOffset }
-	}
-
-	const byte3 = encodedData[readOffset++]
-
-	if ((byte3 & 0b10000000) === 0) {
-		const decodedValue =
-			(byte0 & 0b01111111) |
-			(byte1 & 0b01111111) << 7 |
-			(byte2 & 0b01111111) << 14 |
-			(byte3 & 0b01111111) << 21
-
-		return { decodedValue, readOffset }
-	}
-
-	const byte4 = encodedData[readOffset++]
-
-	if ((byte4 & 0b10000000) === 0) {
-		const decodedValue =
-			(byte0 & 0b01111111) |
-			(byte1 & 0b01111111) << 7 |
-			(byte2 & 0b01111111) << 14 |
-			(byte3 & 0b01111111) << 21 |
-			(byte4 & 0b01111111) << 28
-
-		return { decodedValue, readOffset }
-	}
-
-	if (readOffset >= encodedData.length) {
-		throw new Error(`Invalid LEB128 data. Last encoded byte sequence is truncated.`)
-	} else {
-		throw new Error(`LEB128 sequence can't be decoded. Encoded byte sequence represents a value that extends beyond the range of a unsigned 32 bit integer.`)
-	}
-}
-
-////////////////////////////////////////////////////////////////////////////////////
-// Encode signed integer
-////////////////////////////////////////////////////////////////////////////////////
-export function encodeSignedInt32(value: number, outEncodedData: DynamicUint8Array) {
-	if (value < -(2 ** 31) || value > (2 ** 31)) {
-		throw new Error('Value must be between -(2^31) and 2^31 - 1')
-	}
-
-	while (true) {
-		const lowest7Bits = value & 0b01111111
-
-		value >>= 7
-
-		if (
-			(value === 0 && (lowest7Bits & 0b01000000) === 0) ||
-			(value === -1 && (lowest7Bits & 0b01000000) !== 0)) {
-			outEncodedData.add(lowest7Bits)
-
-			return outEncodedData
-		} else {
-			outEncodedData.add(lowest7Bits | 0b10000000)
-		}
-	}
-}
-
-export function encodeSignedInt32Fast(value: number, outEncodedData: DynamicUint8Array) {
-	const absValue = Math.abs(value | 0)
-
-	if (absValue < (2 ** 6)) {
-		outEncodedData.add(
-			(value & 0b01111111)
-		)
-	} else if (absValue < (2 ** 13)) {
-		outEncodedData.addMany(
-			(value & 0b01111111) | 0b10000000,
-			(value >> 7) & 0b01111111
-		)
-	} else if (absValue < (2 ** 20)) {
-		outEncodedData.addMany(
-			(value & 0b01111111) | 0b10000000,
-			((value >> 7) & 0b01111111) | 0b10000000,
-			(value >> 14) & 0b01111111
-		)
-	} else if (absValue < (2 ** 27)) {
-		outEncodedData.addMany(
-			(value & 0b01111111) | 0b10000000,
-			((value >> 7) & 0b01111111) | 0b10000000,
-			((value >> 14) & 0b01111111) | 0b10000000,
-			(value >> 21) & 0b01111111
-		)
-	} else {
-		outEncodedData.addMany(
-			(value & 0b01111111) | 0b10000000,
-			((value >> 7) & 0b01111111) | 0b10000000,
-			((value >> 14) & 0b01111111) | 0b10000000,
-			((value >> 21) & 0b01111111) | 0b10000000,
-			(value >> 28) & 0b01111111
-		)
-	}
-
-	return outEncodedData
-}
-
-////////////////////////////////////////////////////////////////////////////////////
-// Decode signed integer
-////////////////////////////////////////////////////////////////////////////////////
-export function decodeSignedInt32(encodedData: ArrayLike<number>, readOffset: number): DecodedValueAndReadOffset {
-	let decodedValue = 0
-	let shiftAmount = 0
-
-	while (true) {
-		const encodedByte = encodedData[readOffset++]
-		const lowest7Bits = encodedByte & 0b01111111
-
-		decodedValue |= lowest7Bits << shiftAmount
-
-		// If 8th bit is 0, then this is the last byte in the sequence
-		if ((encodedByte & 0b10000000) === 0) {
-			// If 7th bit is 1, then the value is negative
-			if ((encodedByte & 0b01000000) !== 0) {
-				// If the value should be negative
-				// Ensure that the value is encoded as a negative number by
-				// setting all higher bits to 1
-				decodedValue |= -1 << Math.min(shiftAmount + 7, 31)
-			}
-
-			return { decodedValue, readOffset }
-		}
-
-		if (readOffset === encodedData.length) {
-			throw new Error(`Invalid LEB128 data. Last encoded byte sequence is truncated.`)
-		}
-
-		shiftAmount += 7
-
-		if (shiftAmount > 31) {
-			throw new Error(`LEB128 sequence can't be decoded. Byte sequence extends beyond the range of a signed 32 bit integer.`)
-		}
-	}
-}
-
-export function decodeSignedInt32Fast(encodedData: ArrayLike<number>, readOffset: number) {
-	const byte0 = encodedData[readOffset++]
-
-	if ((byte0 & 0b10000000) === 0) {
-		let decodedValue =
-			byte0
-
-		if ((byte0 & 0b01000000) !== 0) {
-			decodedValue |= -1 << 7
-		}
-
-		return { decodedValue, readOffset }
-	}
-
-	const byte1 = encodedData[readOffset++]
-
-	if ((byte1 & 0b10000000) === 0) {
-		let decodedValue =
-			(byte0 & 0b01111111) |
-			(byte1 & 0b01111111) << 7
-
-		if ((byte1 & 0b01000000) !== 0) {
-			decodedValue |= -1 << 14
-		}
-
-		return { decodedValue, readOffset }
-	}
-
-	const byte2 = encodedData[readOffset++]
-
-	if ((byte2 & 0b10000000) === 0) {
-		let decodedValue =
-			(byte0 & 0b01111111) |
-			(byte1 & 0b01111111) << 7 |
-			(byte2 & 0b01111111) << 14
-
-		if ((byte2 & 0b01000000) !== 0) {
-			decodedValue |= -1 << 21
-		}
-
-		return { decodedValue, readOffset }
-	}
-
-	const byte3 = encodedData[readOffset++]
-
-	if ((byte3 & 0b10000000) === 0) {
-		let decodedValue =
-			(byte0 & 0b01111111) |
-			(byte1 & 0b01111111) << 7 |
-			(byte2 & 0b01111111) << 14 |
-			(byte3 & 0b01111111) << 21
-
-		if ((byte3 & 0b01000000) !== 0) {
-			decodedValue |= -1 << 28
-		}
-
-		return { decodedValue, readOffset }
-	}
-
-	const byte4 = encodedData[readOffset++]
-
-	if ((byte4 & 0b10000000) === 0) {
-		let decodedValue =
-			(byte0 & 0b01111111) |
-			(byte1 & 0b01111111) << 7 |
-			(byte2 & 0b01111111) << 14 |
-			(byte3 & 0b01111111) << 21 |
-			(byte4 & 0b01111111) << 28
-
-		if ((byte4 & 0b01000000) !== 0) {
-			decodedValue |= -1 << 31
-		}
-
-		return { decodedValue, readOffset }
-	}
-
-	if (readOffset >= encodedData.length) {
-		throw new Error(`Invalid LEB128 data. Last encoded byte sequence is truncated.`)
-	} else {
-		throw new Error(`LEB128 sequence can't be decoded. Encoded byte sequence represents a value that extends beyond the range of a signed 32 bit integer.`)
-	}
-}
-
-////////////////////////////////////////////////////////////////////////////////////
-// Types
-////////////////////////////////////////////////////////////////////////////////////
-
-export interface DecodedValueAndReadOffset {
-	decodedValue: number
-	readOffset: number
-}
-
-////////////////////////////////////////////////////////////////////////////////////
-// Tests
-////////////////////////////////////////////////////////////////////////////////////
-export function testLeb128Signed() {
-	const encodedBytes = createDynamicUint8Array()
-
-	function runTest(testValue: number) {
-		encodedBytes.clear()
-
-		encodeSignedInt32Fast(testValue, encodedBytes)
-		const { decodedValue } = decodeSignedInt32Fast(encodedBytes.elements, 0)
-
-		if (decodedValue !== testValue) {
-			throw new Error(`Expected ${testValue} but got ${decodedValue}`)
-		}
-	}
-
-	for (let i = -(2 ** 26); i < 2 ** 26; i++) {
-		if (i % 1000000 === 0) {
-			logToStderr(i)
-		}
-
-		runTest(i)
-	}
-
-	const x = 1
-}

package/src/utilities/StringBuilder.ts

@@ -1,45 +0,0 @@
-import { DynamicUint16Array, createDynamicUint16Array } from '../data-structures/DynamicTypedArray.js'
-import { decodeUtf16 } from '../encodings/Utf16.js'
-
-export class StringBuilder {
-	private outputBuffer: DynamicUint16Array
-
-	constructor(initialCapacity = 8) {
-		this.outputBuffer = createDynamicUint16Array(initialCapacity)
-	}
-
-	appendCharCode(charCode: number) {
-		this.outputBuffer.add(charCode)
-	}
-
-	appendCharCodes(...charCodes: number[]) {
-		this.outputBuffer.addArray(charCodes)
-	}
-
-	appendCharCodeArray(charCodes: ArrayLike<number>) {
-		this.outputBuffer.addArray(charCodes)
-	}
-
-	appendString(str: string) {
-		const length = str.length
-
-		for (let i = 0; i < length; i++) {
-			this.appendCharCode(str.charCodeAt(i))
-		}
-	}
-
-	appendCodePoint(codePoint: number) {
-		if (codePoint <= 0xffff) {
-			this.appendCharCode(codePoint)
-		} else if (codePoint <= 0x10ffff) {
-			this.appendCharCode(0xd800 + ((codePoint - 0x10000) >>> 10))
-			this.appendCharCode(0xdc00 + ((codePoint - 0x10000) & 1023))
-		} else {
-			throw new Error(`appendCodePoint: A code point of ${codePoint} cannot be encoded in UTF-16`)
-		}
-	}
-
-	toString() {
-		return decodeUtf16(this.outputBuffer.toTypedArray())
-	}
-}