pako deflate and gzip roundtrips: working versions (tested 2026-10-16)

{
  "name": "pako-deflate-gzip",
  "private": true,
  "type": "module",
  "scripts": {
    "test": "node --import tsx --test test/*.test.ts"
  },
  "dependencies": {
    "pako": "3.0.2"
  },
  "devDependencies": {
    "@types/node": "26.6.5",
    "tsx": "4.23.15"
  }
}

import { deflate, gzip, inflate, ungzip } from "pako";

const decoder = new TextDecoder();

type LevelOptions = { level?: number };

function withLevel(level?: number): LevelOptions {
  return level === undefined ? {} : { level };
}

export function deflateBytes(input: Uint8Array, level?: number): Uint8Array {
  return deflate(input, withLevel(level));
}

export function inflateBytes(input: Uint8Array): Uint8Array {
  return inflate(input);
}

export function deflateText(input: string, level?: number): Uint8Array {
  return deflate(input, withLevel(level));
}

export function inflateText(input: Uint8Array): string {
  return decoder.decode(inflate(input));
}

export function gzipText(input: string, level?: number): Uint8Array {
  return gzip(input, withLevel(level));
}

export function ungzipText(input: Uint8Array): string {
  return decoder.decode(ungzip(input));
}

import { test } from "node:test";
import assert from "node:assert/strict";
import { deflate as pakoDeflate } from "pako";
import {
  deflateBytes,
  deflateText,
  gzipText,
  inflateBytes,
  inflateText,
  ungzipText,
} from "../src/codec.ts";

test("deflate/inflate roundtrips a Uint8Array", () => {
  const input = new Uint8Array([0, 1, 2, 3, 128, 200, 250, 255]);
  const compressed = deflateBytes(input);
  assert.deepEqual(inflateBytes(compressed), input);
});

test("deflate/inflate roundtrips a string", () => {
  const text = "The quick brown fox jumps over the lazy dog. ".repeat(40);
  const compressed = deflateText(text);
  assert.equal(inflateText(compressed), text);
});

test("gzip/ungzip roundtrips a string", () => {
  const text = "gzip roundtrip payload ".repeat(60);
  const compressed = gzipText(text);
  assert.ok(compressed.length < text.length);
  assert.equal(ungzipText(compressed), text);
});

test("compressed output is smaller for repetitive input", () => {
  const text = "abcabcabc".repeat(2000);
  const compressed = pakoDeflate(text);
  assert.ok(compressed.length < text.length);
});

test("deflate honors the level option", () => {
  const text = "repetitive payload ".repeat(1000);
  const fastest = pakoDeflate(text, { level: 1 });
  const smallest = pakoDeflate(text, { level: 9 });
  assert.ok(smallest.length <= fastest.length);
  assert.equal(inflateText(fastest), text);
  assert.equal(inflateText(smallest), text);
});