Use the runtime's base64, CRC-32 and deflate where they are faster

- the Unicode tables are decoded with Uint8Array.fromBase64 or atob
  instead of a JS base64 decoder
- crc32 uses node:zlib's crc32 (Node, Bun, Deno) from 64 bytes on,
  3-4x faster; shorter buffers stay with slice-by-16
- without node:zlib (browsers), compression levels 1-6 use
  CompressionStream (2.3x faster than the JS deflate); its level is
  fixed, so level 0 and 7-9 stay with the JS deflate

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YJgRK5qpwJEbHPuFv6kgAQ

Author: matmen

src/codecs/crc.ts

@@ -3,6 +3,8 @@
  * Copyright (c) 2021 Arjun Barrett, MIT License (see THIRD_PARTY_NOTICES.md)
  */
 
+import { nodeZlib } from './zlib.ts';
+
 // slice-by-16 tables: TABLE[k * 256 + n] is the CRC of byte n followed by k zero bytes
 const TABLE = new Int32Array(16 * 256);
 for (let n = 0; n < 256; n++) {
@@ -15,11 +17,16 @@ for (let n = 0; n < 256; n++) {
     for (let k = 256; k < TABLE.length; k += 256) c = TABLE[k + n] = TABLE[c & 0xff] ^ c >>> 8;
 }
 
+// the runtime's native CRC-32 (node:zlib in Node, Bun and Deno) is faster except for a few bytes, where the call costs more
+const native = nodeZlib && nodeZlib.crc32 ? nodeZlib.crc32.bind(nodeZlib) : null;
+const NATIVE_MIN = 64;
+
 /**
- * CRC-32 (ISO 3309), as used by PNG and zlib. Processes 16 bytes per step (slice-by-16, see #12), byte by byte so
- * it doesn't depend on alignment or endianness
+ * CRC-32 (ISO 3309), as used by PNG and zlib. Natively where the runtime has it, else 16 bytes per step (slice-by-16,
+ * see #12), byte by byte so it doesn't depend on alignment or endianness
  */
 export function crc32(buffer: Uint8Array): number {
+    if (native && buffer.length >= NATIVE_MIN) return native(buffer) >>> 0;
     let crc = -1, i = 0;
     for (const end = buffer.length - 16; i <= end; i += 16) {
         crc = TABLE[3840 + ((buffer[i] ^ crc) & 0xff)] ^ TABLE[3584 + ((buffer[i + 1] ^ crc >> 8) & 0xff)]

src/codecs/zlib.ts

@@ -639,6 +639,7 @@ export function decompress(data: Uint8Array, limit: number): Uint8Array {
 
 interface NodeZlib {
     deflateSync(data: Uint8Array, options: { level: number }): Uint8Array;
+    crc32?(data: Uint8Array): number;
     inflateSync(data: Uint8Array, options: { maxOutputLength: number, finishFlush: number }): Uint8Array;
     constants: { Z_SYNC_FLUSH: number };
 }
@@ -650,13 +651,14 @@ interface StreamReader {
 
 interface Globals {
     process?: { getBuiltinModule?: (id: string) => unknown };
+    CompressionStream?: new (format: 'deflate') => unknown;
     DecompressionStream?: new (format: 'deflate') => unknown;
     Blob?: new (parts: Uint8Array[]) => { stream(): { pipeThrough(transform: unknown): { getReader(): StreamReader } } };
 }
 
-const { process: runtime, DecompressionStream: NativeDecompression, Blob: NativeBlob } = globalThis as unknown as Globals;
+const { process: runtime, CompressionStream: NativeCompression, DecompressionStream: NativeDecompression, Blob: NativeBlob } = globalThis as unknown as Globals;
 
-const nodeZlib = ((): NodeZlib | null => {
+export const nodeZlib = ((): NodeZlib | null => {
     try {
         return (runtime && runtime.getBuiltinModule && runtime.getBuiltinModule('node:zlib') as NodeZlib) || null;
     } catch {
@@ -674,6 +676,22 @@ const plain = (buffer: Uint8Array): Uint8Array => new Uint8Array(buffer.buffer,
 export async function compressAsync(data: Uint8Array, level: number): Promise<Uint8Array> {
     level = Math.min(9, Math.max(0, level | 0));
     if (nodeZlib) return plain(nodeZlib.deflateSync(data, { level }));
+    // CompressionStream has a fixed level (zlib's default 6): used for levels 1-6, where it is faster than the JS
+    // deflate; storing (0) and the higher levels stay with the JS one
+    if (NativeCompression && NativeBlob && level >= 1 && level <= 6) {
+        const reader = new NativeBlob([data]).stream().pipeThrough(new NativeCompression('deflate')).getReader();
+        const parts: Uint8Array[] = [];
+        let length = 0;
+        for (; ;) {
+            const { done, value } = await reader.read();
+            if (done || !value) break;
+            parts.push(value);
+            length += value.length;
+        }
+        const out = new Uint8Array(length);
+        for (let i = 0, offset = 0; i < parts.length; offset += parts[i++].length) out.set(parts[i], offset);
+        return out;
+    }
     return compress(data, level);
 }
 

src/render/unicode.ts

@@ -11,22 +11,15 @@ interface Ranges {
 
 const decoded = new WeakMap<EncodedProperty, Ranges>();
 
-const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+// base64 is decoded natively: Uint8Array.fromBase64 where available, atob everywhere else (browsers, Node, Deno, Bun)
+declare const atob: (data: string) => string;
+const fromBase64 = (Uint8Array as unknown as { fromBase64?: (text: string) => Uint8Array }).fromBase64;
 
 function base64(text: string): Uint8Array {
-    const digits = new Uint8Array(128);
-    for (let i = 0; i < 64; i++) digits[ALPHABET.charCodeAt(i)] = i;
-    const length = text.replace(/=+$/, '').length;
-    const out = new Uint8Array(length * 3 >> 2);
-    for (let i = 0, o = 0, bits = 0, value = 0; i < length; i++) {
-        value = value << 6 | digits[text.charCodeAt(i)];
-        bits += 6;
-        if (bits >= 8) {
-            bits -= 8;
-            out[o++] = value >> bits & 255;
-        }
-    }
-    return out;
+    if (fromBase64) return fromBase64(text);
+    const binary = atob(text), bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+    return bytes;
 }
 
 function decode(property: EncodedProperty): Ranges {