// The converter tool: text, hex, binary, decimal, octal and Base64 into one // another. Everything goes through bytes: text by its encoding, numbers as // words of 8, 16 or 32 bits (several bytes each in big- or little-endian). export const FORMATS = ['text', 'hex', 'bin', 'dec', 'oct', 'base64'] as const export type Format = (typeof FORMATS)[number] export const FORMAT_NAMES: Record = { text: 'Text', hex: 'Hex', bin: 'Binary', dec: 'Decimal', oct: 'Octal', base64: 'Base64' } export const ENCODINGS = ['utf8', 'ascii', 'latin1', 'utf16le', 'utf16be', 'utf32be'] as const export type Encoding = (typeof ENCODINGS)[number] export const ENCODING_NAMES: Record = { utf8: 'UTF-8', ascii: 'ASCII (7 bits)', latin1: 'Latin-1 (ISO 8859-1)', utf16le: 'UTF-16 little-endian', utf16be: 'UTF-16 big-endian', utf32be: 'UTF-32 big-endian', } export type WordBits = 8 | 16 | 32 export interface ConvertOptions { enc: Encoding word: WordBits endian: 'big' | 'little' } export type Result = { ok: true; value: T; note?: string } | { ok: false; error: string } // ── Text ⇄ bytes ───────────────────────────────────────────────────── export function encodeText(s: string, enc: Encoding): Result { const out: number[] = [] const cps = [...s].map(c => c.codePointAt(0)!) switch (enc) { case 'utf8': return { ok: true, value: new TextEncoder().encode(s) } case 'ascii': case 'latin1': { const max = enc === 'ascii' ? 0x7f : 0xff const bad = cps.findIndex(c => c > max) if (bad >= 0) return { ok: false, error: `"${String.fromCodePoint(cps[bad]!)}" (character ${bad + 1}) has no code in ${ENCODING_NAMES[enc]}` } return { ok: true, value: Uint8Array.from(cps) } } case 'utf16le': case 'utf16be': for (let i = 0; i < s.length; i++) { const u = s.charCodeAt(i) if (enc === 'utf16le') out.push(u & 0xff, u >> 8) else out.push(u >> 8, u & 0xff) } return { ok: true, value: Uint8Array.from(out) } case 'utf32be': for (const c of cps) out.push((c >>> 24) & 0xff, (c >>> 16) & 0xff, (c >>> 8) & 0xff, c & 0xff) return { ok: true, value: Uint8Array.from(out) } } } export function decodeText(b: Uint8Array, enc: Encoding): Result { switch (enc) { case 'utf8': { const text = new TextDecoder('utf-8').decode(b) return { ok: true, value: text, ...(text.includes('�') ? { note: 'Some bytes are not valid UTF-8 (shown as �)' } : {}) } } case 'ascii': case 'latin1': { const bad = enc === 'ascii' && b.some(x => x > 0x7f) let text = '' for (const x of b) text += enc === 'ascii' && x > 0x7f ? '�' : String.fromCharCode(x) return { ok: true, value: text, ...(bad ? { note: 'Bytes above 7F are not ASCII (shown as �)' } : {}) } } case 'utf16le': case 'utf16be': { let text = '' for (let i = 0; i + 1 < b.length; i += 2) text += String.fromCharCode(enc === 'utf16le' ? b[i]! | (b[i + 1]! << 8) : (b[i]! << 8) | b[i + 1]!) return { ok: true, value: text, ...(b.length % 2 ? { note: 'The last byte is half a character' } : {}) } } case 'utf32be': { let text = '' let bad = false for (let i = 0; i + 3 < b.length; i += 4) { const c = ((b[i]! << 24) | (b[i + 1]! << 16) | (b[i + 2]! << 8) | b[i + 3]!) >>> 0 if (c > 0x10ffff || (c >= 0xd800 && c <= 0xdfff)) { bad = true text += '�' } else text += String.fromCodePoint(c) } return { ok: true, value: text, ...(bad || b.length % 4 ? { note: 'Some bytes are not whole UTF-32 characters' } : {}) } } } } // ── Words ⇄ bytes ──────────────────────────────────────────────────── /** Bytes as words; a last word short of bytes is filled with zeros. */ export function toWords(b: Uint8Array, o: Pick): number[] { const n = o.word / 8 const out: number[] = [] for (let i = 0; i < b.length; i += n) { let v = 0 for (let k = 0; k < n; k++) { const byte = b[i + k] ?? 0 v += byte * 2 ** (8 * (o.endian === 'big' ? n - 1 - k : k)) } out.push(v) } return out } export function fromWords(words: number[], o: Pick): Uint8Array { const n = o.word / 8 const out = new Uint8Array(words.length * n) words.forEach((v, i) => { for (let k = 0; k < n; k++) { const byte = Math.floor(v / 2 ** (8 * k)) & 0xff out[i * n + (o.endian === 'big' ? n - 1 - k : k)] = byte } }) return out } // ── Number formats ─────────────────────────────────────────────────── const RADIX: Record<'hex' | 'bin' | 'dec' | 'oct', number> = { hex: 16, bin: 2, dec: 10, oct: 8 } const DIGITS: Record<'hex' | 'bin' | 'dec' | 'oct', RegExp> = { hex: /^[0-9a-f]+$/i, bin: /^[01]+$/, dec: /^\d+$/, oct: /^[0-7]+$/ } /** Digits one word takes in a format with a fixed width (hex and binary). */ const wordDigits = (fmt: 'hex' | 'bin', word: WordBits) => (fmt === 'hex' ? word / 4 : word) /** Words written in a number format: separated by spaces, commas or new lines; 0x, 0b, 0o prefixes are fine. A long hex or binary run is several words. */ export function parseWords(input: string, fmt: 'hex' | 'bin' | 'dec' | 'oct', word: WordBits): Result { const out: number[] = [] const max = 2 ** word for (const raw of input.split(/[\s,;]+/).filter(Boolean)) { const t = raw.replace(fmt === 'hex' ? /^(0x|\$|#)|h$/gi : fmt === 'bin' ? /^0b|b$/gi : fmt === 'oct' ? /^0o/i : /^$/, '').replace(/_/g, '') if (!DIGITS[fmt].test(t)) return { ok: false, error: `"${raw}" is not ${fmt === 'hex' ? 'hex' : fmt === 'bin' ? 'binary' : fmt === 'dec' ? 'a decimal number' : 'octal'}` } if ((fmt === 'hex' || fmt === 'bin') && t.length > wordDigits(fmt, word)) { const d = wordDigits(fmt, word) if (t.length % d) return { ok: false, error: `"${raw}" is ${t.length} digits: not a whole number of ${word}-bit words (${d} digits each)` } for (let i = 0; i < t.length; i += d) out.push(parseInt(t.slice(i, i + d), RADIX[fmt])) continue } const v = parseInt(t, RADIX[fmt]) if (v >= max) return { ok: false, error: `"${raw}" does not fit in ${word} bits (up to ${max - 1})` } out.push(v) } return { ok: true, value: out } } export function formatWords(words: number[], fmt: 'hex' | 'bin' | 'dec' | 'oct', word: WordBits): string { return words .map(v => { const s = v.toString(RADIX[fmt]) return fmt === 'hex' ? s.toUpperCase().padStart(word / 4, '0') : fmt === 'bin' ? s.padStart(word, '0') : s }) .join(' ') } // ── Base64 ─────────────────────────────────────────────────────────── export function toBase64(b: Uint8Array): string { let s = '' for (const x of b) s += String.fromCharCode(x) return btoa(s) } export function fromBase64(input: string): Result { const t = input.replace(/\s+/g, '').replace(/-/g, '+').replace(/_/g, '/') if (!/^[A-Za-z0-9+/]*={0,2}$/.test(t)) return { ok: false, error: 'Not Base64 (A–Z, a–z, 0–9, +, / and = at the end)' } try { const s = atob(t.padEnd(Math.ceil(t.length / 4) * 4, '=')) return { ok: true, value: Uint8Array.from(s, c => c.charCodeAt(0)) } } catch { return { ok: false, error: 'Not Base64' } } } // ── Any format ⇄ bytes ─────────────────────────────────────────────── export function parseAs(input: string, fmt: Format, o: ConvertOptions): Result { if (fmt === 'text') return encodeText(input, o.enc) if (fmt === 'base64') return fromBase64(input) const w = parseWords(input, fmt, o.word) return w.ok ? { ok: true, value: fromWords(w.value, o) } : w } export function formatAs(b: Uint8Array, fmt: Format, o: ConvertOptions): Result { if (fmt === 'text') return decodeText(b, o.enc) if (fmt === 'base64') return { ok: true, value: toBase64(b) } const note = b.length % (o.word / 8) ? `The last word is filled up with zero bytes` : undefined return { ok: true, value: formatWords(toWords(b, o), fmt, o.word), ...(note ? { note } : {}) } } /** A word as a signed number (two's complement). */ export const signed = (v: number, word: WordBits) => (v >= 2 ** (word - 1) ? v - 2 ** word : v) /** How a byte or character shows in a table: control characters by name. */ export function charLabel(code: number): string { const NAMES: Record = { 0: 'NUL', 7: 'BEL', 8: 'BS', 9: 'TAB', 10: 'LF', 13: 'CR', 27: 'ESC', 32: 'space', 127: 'DEL' } if (NAMES[code]) return NAMES[code]! if (code < 32 || (code >= 0x80 && code < 0xa0)) return `^${code.toString(16).toUpperCase().padStart(2, '0')}` if (code >= 0xd800 && code <= 0xdfff) return '·' return code <= 0x10ffff ? String.fromCodePoint(code) : '·' }