Restored back dictionary option and removed onNeedDict hook

Author: puzrin

examples/advanced-hooks.mjs

@@ -1,42 +1,12 @@
 import {
   Deflate,
   GZheader,
-  Inflate,
-  zlibDeflateSetDictionary,
   zlibDeflateSetHeader,
-  zlibInflateSetDictionary,
   Z_OK
 } from '../src/index.ts';
 
 const data = new Uint8Array([ 1, 2, 3, 1, 2, 3 ]);
-const dict = new Uint8Array([ 1, 2, 3 ]);
 
-// Deflate needs the dictionary before the first byte is compressed.
-const deflator = new Deflate();
-deflator.onStart = function (strm) {
-  if (zlibDeflateSetDictionary(strm, dict) !== Z_OK) throw new Error('dictionary rejected');
-};
-deflator.push(data, true);
-
-// Zlib-wrapped inflate asks for the dictionary after reading its dictionary id.
-const inflator = new Inflate();
-inflator.onNeedDict = function () { return dict; };
-inflator.push(deflator.result, true);
-
-// Raw deflate has no wrapper header, so both sides set the dictionary up front.
-const rawDeflator = new Deflate({ raw: true });
-rawDeflator.onStart = function (strm) {
-  if (zlibDeflateSetDictionary(strm, dict) !== Z_OK) throw new Error('dictionary rejected');
-};
-rawDeflator.push(data, true);
-
-const rawInflator = new Inflate({ raw: true });
-rawInflator.onStart = function (strm) {
-  if (zlibInflateSetDictionary(strm, dict) !== Z_OK) throw new Error('dictionary rejected');
-};
-rawInflator.push(rawDeflator.result, true);
-
-// Gzip header is written before compression starts.
 const gzipper = new Deflate({ gzip: true });
 gzipper.onStart = function (strm) {
   const header = new GZheader();

src/deflate.ts

@@ -2,6 +2,7 @@ import {
   messages,
   ZStream,
   zlibDeflateInit2,
+  zlibDeflateSetDictionary,
   zlibDeflate,
   zlibDeflateEnd
 } from './zlib.mjs';
@@ -36,6 +37,7 @@ interface DeflateOptions {
   raw?: boolean;
   gzip?: boolean;
   legacyHash?: boolean;
+  dictionary?: Uint8Array | ArrayBuffer;
 }
 
 const defaultOptions: Required<DeflateOptions> = {
@@ -47,7 +49,8 @@ const defaultOptions: Required<DeflateOptions> = {
   strategy: Z_DEFAULT_STRATEGY,
   raw: false,
   gzip: false,
-  legacyHash: false
+  legacyHash: false,
+  dictionary: new Uint8Array(0)
 };
 
 /**
@@ -99,6 +102,7 @@ const defaultOptions: Required<DeflateOptions> = {
  * - `windowBits`
  * - `memLevel`
  * - `strategy`
+ * - `dictionary`
  *
  * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
  * for more information on these.
@@ -175,6 +179,24 @@ class Deflate {
     if (status !== Z_OK) {
       throw new Error(messages[status]);
     }
+
+    if (toString.call(opt.dictionary) === '[object ArrayBuffer]') {
+      opt.dictionary = new Uint8Array(opt.dictionary as ArrayBuffer);
+    }
+
+    const dictionary = opt.dictionary as Uint8Array;
+
+    if (dictionary.length) {
+      if (opt.gzip) {
+        throw new Error('dictionary is not supported with gzip');
+      }
+
+      status = zlibDeflateSetDictionary(this.strm, dictionary);
+
+      if (status !== Z_OK) {
+        throw new Error(messages[status]);
+      }
+    }
   }
 
 /**
@@ -330,6 +352,7 @@ class Deflate {
  * - windowBits
  * - memLevel
  * - strategy
+ * - dictionary
  *
  * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
  * for more information on these.

src/inflate.ts

@@ -33,13 +33,15 @@ interface InflateOptions {
   windowBits?: number;
   raw?: boolean;
   to?: string;
+  dictionary?: Uint8Array | ArrayBuffer;
 }
 
 const defaultOptions: Required<InflateOptions> = {
   chunkSize: 1024 * 64,
   windowBits: 15,
   raw: false,
-  to: ''
+  to: '',
+  dictionary: new Uint8Array(0)
 };
 
 /**
@@ -86,6 +88,7 @@ const defaultOptions: Required<InflateOptions> = {
  * on bad params. Supported options:
  *
  * - `windowBits`
+ * - `dictionary`
  * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
  * for more information on these.
  *
@@ -179,6 +182,19 @@ class Inflate {
     this.header = new GZheader();
 
     zlibInflateGetHeader(this.strm, this.header);
+
+    if (toString.call(opt.dictionary) === '[object ArrayBuffer]') {
+      opt.dictionary = new Uint8Array(opt.dictionary as ArrayBuffer);
+    }
+
+    const dictionary = opt.dictionary as Uint8Array;
+
+    if (opt.raw && dictionary.length) {
+      status = zlibInflateSetDictionary(this.strm, dictionary);
+      if (status !== Z_OK) {
+        throw new Error(messages[status]);
+      }
+    }
   }
 
 /**
@@ -243,9 +259,9 @@ class Inflate {
       status = zlibInflate(strm, _flush_mode);
 
       if (status === Z_NEED_DICT) {
-        const dictionary = this.onNeedDict(strm);
+        const dictionary = this.options.dictionary as Uint8Array;
 
-        if (dictionary?.length) {
+        if (dictionary.length) {
           status = zlibInflateSetDictionary(strm, dictionary);
 
           if (status === Z_OK) {
@@ -365,15 +381,6 @@ class Inflate {
   onStart(strm: ZStream): void {}
 
 
-/**
- * Inflate#onNeedDict(strm) -> Uint8Array
- * - strm (ZStream): low-level zlib stream.
- *
- * Called when inflate needs a preset dictionary. Return a Uint8Array dictionary.
- **/
-  onNeedDict(strm: ZStream): Uint8Array { return new Uint8Array(0); }
-
-
 /**
  * Inflate#onData(chunk) -> Void
  * - chunk (Uint8Array|String): output data. When string output requested,
@@ -424,6 +431,7 @@ class Inflate {
  * Supported options are:
  *
  * - windowBits
+ * - dictionary
  *
  * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
  * for more information.

test/deflate.test.mjs

@@ -4,11 +4,10 @@ import {
   Inflate,
   deflate,
   deflateRaw,
+  gzip,
   inflate,
   inflateRaw,
-  zlibDeflateSetDictionary,
   Z_FULL_FLUSH,
-  Z_OK,
   Z_SYNC_FLUSH
 } from '../src/index.ts';
 import assert from 'assert';
@@ -23,19 +22,15 @@ describe('deflate misc', () => {
 
   it('handles a dictionary across multiple pushes', () => {
     const dict = Buffer.from('abcd');
-    const deflate = new Deflate();
-    deflate.onStart = function (strm) {
-      assert.strictEqual(zlibDeflateSetDictionary(strm, dict), Z_OK);
-    };
+    const deflate = new Deflate({ dictionary: dict });
 
     deflate.push(Buffer.from('hello'), false);
     deflate.push(Buffer.from('hello'), false);
     deflate.push(Buffer.from(' world'), true);
 
     if (deflate.err) { throw new Error(deflate.err); }
 
-    const inflate = new Inflate();
-    inflate.onNeedDict = function () { return dict; };
+    const inflate = new Inflate({ dictionary: dict });
     inflate.push(Buffer.from(deflate.result), true);
     assert.ok(!inflate.err, 'inflate error: ' + inflate.err);
 
@@ -51,42 +46,24 @@ describe('deflate misc', () => {
     assert.deepStrictEqual(deflate(sample.buffer), deflate(sample));
   });
 
-  it('sets a dictionary from onStart', () => {
-    const dict = new Uint8Array([ 0x61, 0x62, 0x63, 0x64 ]); // 'abcd'
-
-    const withDictionary = new Deflate();
-    withDictionary.onStart = function (strm) {
-      assert.strictEqual(zlibDeflateSetDictionary(strm, dict), Z_OK);
-    };
-    withDictionary.push(Buffer.from('hellohello world'), true);
-    assert.ok(!withDictionary.err, 'deflate error: ' + withDictionary.err);
-
-    const withoutDictionary = new Deflate();
-    withoutDictionary.push(Buffer.from('hellohello world'), true);
-
-    assert.notDeepStrictEqual(withDictionary.result, withoutDictionary.result);
+  it('accepts a dictionary passed as ArrayBuffer', () => {
+    const dict = Uint8Array.from('abcd', c => c.charCodeAt(0));
 
-    const inflate = new Inflate();
-    inflate.onNeedDict = function () { return dict; };
-    inflate.push(Buffer.from(withDictionary.result), true);
-    assert.ok(!inflate.err, 'inflate error: ' + inflate.err);
+    const compressed = deflate(Buffer.from('hellohello world'), { dictionary: dict.buffer });
+    const uncompressed = inflate(compressed, { dictionary: dict });
     assert.deepStrictEqual(
       new Uint8Array(Buffer.from('hellohello world')),
-      inflate.result
+      uncompressed
     );
   });
 
   it('throws on invalid init options', () => {
     assert.throws(() => new Deflate({ level: 42 }));
   });
 
-  it('reports gzip dictionary errors from onStart', () => {
-    const deflate = new Deflate({ gzip: true });
-    deflate.onStart = function (strm) {
-      assert.notStrictEqual(zlibDeflateSetDictionary(strm, Buffer.from('abcd')), Z_OK);
-    };
-    deflate.push(Buffer.from('hello'), true);
-    assert.ok(!deflate.err, 'deflate error: ' + deflate.err);
+  it('throws when a dictionary is used with gzip compression', () => {
+    assert.throws(() => new Deflate({ gzip: true, dictionary: Buffer.from('abcd') }), /dictionary is not supported with gzip/);
+    assert.throws(() => gzip(Buffer.from('hello'), { dictionary: Buffer.from('abcd') }), /dictionary is not supported with gzip/);
   });
 
   it('returns false when pushing after the stream has ended', () => {

test/inflate.test.mjs

@@ -12,9 +12,6 @@ import {
   inflate,
   inflateRaw,
   ungzip,
-  zlibDeflateSetDictionary,
-  zlibInflateSetDictionary,
-  Z_OK,
   Z_SYNC_FLUSH
 } from '../src/index.ts';
 import { fileURLToPath } from 'node:url';
@@ -41,17 +38,11 @@ describe('inflate misc', () => {
   it('applies a dictionary early in raw mode', () => {
     const dict = Buffer.from('abcd');
 
-    const deflate = new Deflate({ raw: true });
-    deflate.onStart = function (strm) {
-      assert.strictEqual(zlibDeflateSetDictionary(strm, dict), Z_OK);
-    };
+    const deflate = new Deflate({ raw: true, dictionary: dict });
     deflate.push(Buffer.from('hellohello world'), true);
     assert.ok(!deflate.err, 'deflate error: ' + deflate.err);
 
-    const inflate = new Inflate({ raw: true });
-    inflate.onStart = function (strm) {
-      assert.strictEqual(zlibInflateSetDictionary(strm, dict), Z_OK);
-    };
+    const inflate = new Inflate({ raw: true, dictionary: dict });
     inflate.push(Buffer.from(deflate.result), true);
     assert.ok(!inflate.err, 'inflate error: ' + inflate.err);
 

test/zlib/binary_compare.test.mjs

@@ -5,12 +5,9 @@ import path from 'path';
 import zlib from 'zlib';
 
 import {
-  Deflate,
   deflate,
   deflateRaw,
-  gzip,
-  zlibDeflateSetDictionary,
-  Z_OK
+  gzip
 } from '../../src/index.ts';
 import { loadSamples } from '../helpers.mjs';
 import { fileURLToPath } from 'node:url';
@@ -20,16 +17,6 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const sample = loadSamples().lorem_en_100k;
 const buf    = Buffer.from(sample);
 
-function deflateWithDictionary(data, options, dictionary) {
-  const deflator = new Deflate(options);
-  deflator.onStart = function (strm) {
-    assert.strictEqual(zlibDeflateSetDictionary(strm, dictionary), Z_OK);
-  };
-  deflator.push(data, true);
-  if (deflator.err) throw deflator.msg;
-  return deflator.result;
-}
-
 
 // pako `legacyHash` output must match canonical zlib (pre-chromium node.js)
 // fixtures byte-for-byte.
@@ -139,9 +126,9 @@ describe('Deflate vs canonical zlib snapshots (legacyHash)', () => {
     it('trivial dictionary', () => {
       const dict = Buffer.from('abcdefghijklmnoprstuvwxyz');
       testSample(
-        (data, options) => deflateWithDictionary(data, options, dict),
+        deflate,
         sample,
-        {},
+        { dictionary: dict },
         'deflate_dictionary=trivial.bin'
       );
     });
@@ -150,9 +137,9 @@ describe('Deflate vs canonical zlib snapshots (legacyHash)', () => {
       const spdyDict = fs.readFileSync(path.join(__dirname, '..', 'fixtures', 'spdy_dict.txt'));
 
       testSample(
-        (data, options) => deflateWithDictionary(data, options, spdyDict),
+        deflate,
         sample,
-        {},
+        { dictionary: spdyDict },
         'deflate_dictionary=spdy.bin'
       );
     });
@@ -260,13 +247,13 @@ describe('Deflate vs node.js zlib (ANZAC++ hash)', () => {
 
     it('trivial dictionary', () => {
       const dict = Buffer.from('abcdefghijklmnoprstuvwxyz');
-      testNode(deflateWithDictionary(sample, { legacyHash: false }, dict), zlib.deflateSync(buf, { dictionary: dict }));
+      testNode(deflate(sample, { legacyHash: false, dictionary: dict }), zlib.deflateSync(buf, { dictionary: dict }));
     });
 
     it('spdy dictionary', () => {
       const spdyDict = fs.readFileSync(path.join(__dirname, '..', 'fixtures', 'spdy_dict.txt'));
 
-      testNode(deflateWithDictionary(sample, { legacyHash: false }, spdyDict), zlib.deflateSync(buf, { dictionary: spdyDict }));
+      testNode(deflate(sample, { legacyHash: false, dictionary: spdyDict }), zlib.deflateSync(buf, { dictionary: spdyDict }));
     });
   });
 });