fix z85 implementation

Author: edde746

src/z85.js

@@ -1,123 +1,57 @@
-const CHARSET = new Uint8Array([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 46, 45, 58, 43, 61, 94, 33, 47, 42, 63, 38, 60, 62, 40, 41, 91, 93, 123, 125, 64, 37, 36, 35]);
-const POW_85 = [1, 85, 7225, 614125, 52200625];
-/** @type {Uint8Array} */
-let REVERSE_MAP;
+const ENCODE = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#";
+const DECODE = [-1, 68, -1, 84, 83, 82, 72, -1, 75, 76, 70, 65, -1, 63, 62, 69, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 64, -1, 73, 66, 74, 71, 81, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 77, -1, 78, 67, -1, -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 79, -1, 80, -1, -1];
+const POW_85 = [0, 1, 85, 7225, 614125, 52200625];
+const POW_256 = [1, 256, 65536, 16777216];
 
 /**
  * Encodes binary data into a Z85 string.
  * @param {ArrayBuffer} data - The binary data to encode
  * @returns {string} The Z85 encoded string
  */
-export function encode85(data) {
-  const byteLength = data.byteLength;
-  const fullBlocks = Math.floor(byteLength / 4);
-  const remain = byteLength % 4;
-  const outputLength = Math.ceil(byteLength * 5 / 4);
-  const target = new Uint8Array(outputLength);
+function encode85(data) {
   const dv = new DataView(data);
-
-  let targetIndex = 0;
-
-  // Process complete 4-byte blocks
-  for (let i = 0; i < fullBlocks; i++) {
-    let value = dv.getUint32(i * 4);
-
-    // Encode 5 characters
-    target[targetIndex + 4] = CHARSET[value % 85];
-    value = Math.floor(value / 85);
-    target[targetIndex + 3] = CHARSET[value % 85];
-    value = Math.floor(value / 85);
-    target[targetIndex + 2] = CHARSET[value % 85];
-    value = Math.floor(value / 85);
-    target[targetIndex + 1] = CHARSET[value % 85];
-    target[targetIndex] = CHARSET[Math.floor(value / 85)];
-
-    targetIndex += 5;
-  }
-
-  // Handle remaining bytes
-  if (remain) {
-    let value = 0;
-    for (let i = 0; i < remain; i++) {
-      value = (value << 8) | dv.getUint8(fullBlocks * 4 + i);
-    }
-    value <<= (4 - remain) * 8; // Pad remaining bytes
-
-    const partialOutput = [];
-    for (let i = 0; i < Math.ceil((remain + 1) * 5 / 4); i++) {
-      partialOutput.unshift(CHARSET[value % 85]);
-      value = Math.floor(value / 85);
-    }
-
-    for (const char of partialOutput) {
-      target[targetIndex++] = char;
+  const length = dv.byteLength;
+  const padding = (4 - (length % 4)) % 4;
+
+  let result = '', value = 0;
+  for (let i = 0; i < length + padding; ++i) {
+    const isPadding = i >= length;
+    value = value * 256 + (isPadding ? 0 : dv.getUint8(i));
+    if ((i + 1) % 4 === 0) {
+      for (let j = 5; j > 0; --j) {
+        if (isPadding && j <= padding)
+          continue;
+
+        result += ENCODE[Math.floor(value / POW_85[j]) % 85];
+      }
+      value = 0;
     }
   }
 
-  return new TextDecoder().decode(target);
-}
-
-/**
- * Creates a reverse mapping from character codes to indices.
- * @param {Uint8Array} mapOrig - The original character map
- * @returns {Uint8Array} A mapping of character codes to indices
- * @private
- */
-function getReverseMap(mapOrig) {
-  const revMap = new Uint8Array(128);
-  for (const [num, charCode] of Object.entries(mapOrig)) {
-    revMap[charCode] = parseInt(num);
-  }
-  return revMap;
-}
+  return result;
+};
 
 /**
  * Decodes a Z85 string into binary data.
  * @param {string} string - The Z85 encoded string
  * @returns {ArrayBuffer} The decoded binary data
  */
-export function decode85(string) {
-  if (!REVERSE_MAP) REVERSE_MAP = getReverseMap(CHARSET);
-  const z85ab = new Uint8Array(string.length);
-  for (let i = 0; i < string.length; i++) {
-    z85ab[i] = string.charCodeAt(i);
-  }
-
-  const pad = (5 - (z85ab.length % 5)) % 5;
-  const result = new Uint8Array((Math.ceil(z85ab.length / 5) * 4) - pad);
-  const dv = new DataView(result.buffer);
-
-  // Process complete 5-character blocks
-  const completeBlocks = Math.floor(z85ab.length / 5) - 1;
-  for (let i = 0; i <= completeBlocks; i++) {
-    const chunk = z85ab.slice(i * 5, i * 5 + 5);
-    const value = chunk.reduceRight((acc, char, idx) => {
-      return acc + REVERSE_MAP[char] * POW_85[4 - idx];
-    }, 0);
-    dv.setUint32(i * 4, value);
-  }
-
-  // Handle remaining characters
-  if (pad > 0) {
-    const lastIndex = completeBlocks + 1;
-    const lastChar = CHARSET[CHARSET.length - 1];
-    const lastPart = new Uint8Array([
-      ...z85ab.slice(lastIndex * 5),
-      lastChar, lastChar, lastChar, lastChar
-    ]);
-
-    const value = [...lastPart].slice(0, 5).reduceRight((acc, char, idx) => {
-      return acc + REVERSE_MAP[char] * POW_85[4 - idx];
-    }, 0);
-
-    const lastDv = new DataView(lastPart.buffer);
-    lastDv.setUint32(0, value);
-
-    const remainingBytes = 4 - pad;
-    for (let j = 0; j < remainingBytes; j++) {
-      result[lastIndex * 4 + j] = lastPart[j];
-    }
+function decode85(string) {
+  const remainder = string.length % 5;
+  const padding = 5 - (remainder === 0 ? 5 : remainder);
+  string = string.padEnd(string.length + padding, ENCODE[ENCODE.length - 1]);
+  const length = string.length;
+
+  let buffer = new Uint8Array((length * 4 / 5) - padding);
+  let value = 0, char = 0, byte = 0;
+  for (let i = 0; i < length; ++i) {
+    value = value * 85 + DECODE[string.charCodeAt(char++) - 32];
+    if (char % 5 !== 0) continue;
+
+    for (let j = 3; j >= 0; --j)
+      buffer[byte++] = Math.floor(value / POW_256[j]) % 256;
+    value = 0;
   }
 
-  return result.buffer;
+  return buffer.buffer;
 }