| import { Buffer } from 'node:buffer'; |
|
|
| const UTF8_BOM = Buffer.from([0xef, 0xbb, 0xbf]); |
| const LOW_BYTE_OFFSET = 14; |
| const HIGH_BYTE_OFFSET = -9; |
|
|
| const CURRENT_INTERNAL_BYTES = new Set([ |
| 0x00, 0x0a, 0x0d, 0x20, 0x22, 0x24, 0x40, 0x5b, 0x5c, 0x7b, |
| 0x7d, 0x7e, 0x80, 0xa3, 0xa4, 0xa7, 0xbd, 0x3b, 0x5d, 0x5f, |
| 0x3d, 0x21, |
| ]); |
|
|
| const LEGACY_INTERNAL_BYTES = new Set([ |
| 0x00, 0x0a, 0x0d, 0x20, 0x22, 0x23, 0x24, 0x2f, 0x3a, 0x3b, |
| 0x3d, 0x40, 0x5b, 0x5c, 0x5d, 0x5f, 0x7b, 0x7d, 0x7e, 0x80, |
| 0xa3, 0xa4, 0xa7, 0xbd, |
| ]); |
|
|
| const COMPATIBLE_INTERNAL_BYTES = new Set([ |
| ...CURRENT_INTERNAL_BYTES, |
| ...LEGACY_INTERNAL_BYTES, |
| ]); |
|
|
| const PROFILES = new Map([ |
| ['compatible', COMPATIBLE_INTERNAL_BYTES], |
| ['current', CURRENT_INTERNAL_BYTES], |
| ['legacy', LEGACY_INTERNAL_BYTES], |
| ]); |
|
|
| const CP1252_TO_UNICODE = new Map([ |
| [0x80, 0x20ac], [0x82, 0x201a], [0x83, 0x0192], [0x84, 0x201e], |
| [0x85, 0x2026], [0x86, 0x2020], [0x87, 0x2021], [0x88, 0x02c6], |
| [0x89, 0x2030], [0x8a, 0x0160], [0x8b, 0x2039], [0x8c, 0x0152], |
| [0x8e, 0x017d], [0x91, 0x2018], [0x92, 0x2019], [0x93, 0x201c], |
| [0x94, 0x201d], [0x95, 0x2022], [0x96, 0x2013], [0x97, 0x2014], |
| [0x98, 0x02dc], [0x99, 0x2122], [0x9a, 0x0161], [0x9b, 0x203a], |
| [0x9c, 0x0153], [0x9e, 0x017e], [0x9f, 0x0178], |
| ]); |
|
|
| const UNICODE_TO_CP1252 = new Map( |
| [...CP1252_TO_UNICODE].map(([byte, codePoint]) => [codePoint, byte]), |
| ); |
|
|
| function byteToUtf8CodePoint(byte) { |
| return CP1252_TO_UNICODE.get(byte) ?? byte; |
| } |
|
|
| function utf8CodePointToByte(codePoint) { |
| return UNICODE_TO_CP1252.get(codePoint) ?? codePoint; |
| } |
|
|
| function assertByte(value, position) { |
| if (!Number.isInteger(value) || value < 0 || value > 0xff) { |
| throw new SyntaxError(`Invalid EU4 byte at encoded character ${position}`); |
| } |
| } |
|
|
| export function encodeText(text, options = {}) { |
| const profile = options.profile ?? 'compatible'; |
| const internalBytes = PROFILES.get(profile); |
| if (!internalBytes) { |
| throw new TypeError(`Unknown encoding profile: ${profile}`); |
| } |
| let result = ''; |
|
|
| for (const character of text) { |
| const codePoint = character.codePointAt(0); |
| if (codePoint < 0x100) { |
| result += character; |
| continue; |
| } |
| if (codePoint > 0xffff) { |
| throw new RangeError( |
| `EU4 double-byte encoding only supports BMP characters: U+${codePoint.toString(16).toUpperCase()}`, |
| ); |
| } |
|
|
| let low = codePoint & 0xff; |
| let high = codePoint >>> 8; |
| let marker = 0x10; |
|
|
| if (internalBytes.has(high)) marker += 2; |
| if (internalBytes.has(low)) marker += 1; |
|
|
| if (marker === 0x11 || marker === 0x13) low += LOW_BYTE_OFFSET; |
| if (marker === 0x12 || marker === 0x13) high += HIGH_BYTE_OFFSET; |
|
|
| result += String.fromCodePoint( |
| marker, |
| byteToUtf8CodePoint(low), |
| byteToUtf8CodePoint(high), |
| ); |
| } |
|
|
| return result; |
| } |
|
|
| export function decodeText(text, options = {}) { |
| const characters = [...text]; |
| let result = ''; |
|
|
| for (let index = 0; index < characters.length; index += 1) { |
| const marker = characters[index].codePointAt(0); |
| if (marker < 0x10 || marker > 0x13) { |
| result += characters[index]; |
| continue; |
| } |
| if (index + 2 >= characters.length) { |
| throw new SyntaxError(`Truncated EU4 escape at encoded character ${index}`); |
| } |
|
|
| let low = utf8CodePointToByte(characters[index + 1].codePointAt(0)); |
| let high = utf8CodePointToByte(characters[index + 2].codePointAt(0)); |
|
|
| assertByte(low, index + 1); |
| assertByte(high, index + 2); |
|
|
| if (marker === 0x11 || marker === 0x13) low -= LOW_BYTE_OFFSET; |
| if (marker === 0x12 || marker === 0x13) high -= HIGH_BYTE_OFFSET; |
|
|
| assertByte(low, index + 1); |
| assertByte(high, index + 2); |
|
|
| const codePoint = (high << 8) | low; |
| if (codePoint < 0x100) { |
| throw new SyntaxError(`Invalid EU4 escape at encoded character ${index}`); |
| } |
|
|
| result += String.fromCodePoint(codePoint); |
| index += 2; |
| } |
|
|
| return result; |
| } |
|
|
| export function encodeBuffer(text, options = {}) { |
| const encoded = Buffer.from(encodeText(text, options), 'utf8'); |
| return options.bom === false ? encoded : Buffer.concat([UTF8_BOM, encoded]); |
| } |
|
|
| export function decodeBuffer(buffer, options = {}) { |
| const input = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer); |
| const hasBom = input.subarray(0, UTF8_BOM.length).equals(UTF8_BOM); |
|
|
| if (options.requireBom !== false && !hasBom) { |
| throw new SyntaxError('EU4 UTF-8 localisation file is missing the EF BB BF BOM'); |
| } |
|
|
| const content = hasBom ? input.subarray(UTF8_BOM.length) : input; |
| const encodedText = new TextDecoder('utf-8', { fatal: true }).decode(content); |
| return decodeText(encodedText, options); |
| } |
|
|
| export function hasUtf8Bom(buffer) { |
| const input = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer); |
| return input.subarray(0, UTF8_BOM.length).equals(UTF8_BOM); |
| } |
|
|
| export { UTF8_BOM }; |
|
|
