Convert Figma logo to code with AI

nodeca logopako

high speed zlib port to javascript, works in browser & node.js

5,494
784
5,494
23
View on GitHubView on NPM

Top Related Projects

imaya's avatar

zlib.js

1,122

compact zlib, deflate, inflate, zip library in JavaScript

pieroxy's avatar

lz-string

4,075

LZ-based compression algorithm for JavaScript

101arrowz's avatar

fflate

2,207

High performance (de)compression in an 8kB package

Quick Overview

Pako is a high-speed zlib port to JavaScript, implemented as a pure JS port of zlib and deflate algorithms. It provides compression and decompression functionality, making it useful for working with compressed data in JavaScript environments, both in the browser and Node.js.

Pros

  • High performance, optimized for speed
  • Works in both browser and Node.js environments
  • Supports various compression levels and strategies
  • Small footprint, with minimal dependencies

Cons

  • Limited to zlib/deflate algorithms, not a full-featured compression library
  • May have slight differences in output compared to native zlib implementations
  • Lacks support for some advanced zlib features
  • Performance may vary across different JavaScript engines

Code Examples

  1. Compressing data:
import pako from 'pako';

const input = 'Hello, world!';
const compressed = pako.deflate(input);
console.log(compressed);
  1. Decompressing data:
import pako from 'pako';

const compressed = new Uint8Array([120, 156, 202, 72, 205, 201, 201, 215, 81, 40, 207, 47, 202, 73, 1, 0, 14, 175, 3, 251]);
const decompressed = pako.inflate(compressed, { to: 'string' });
console.log(decompressed); // Output: Hello, world!
  1. Using different compression levels:
import pako from 'pako';

const input = 'This is a longer string to compress with different levels.';
const level1 = pako.deflate(input, { level: 1 });
const level9 = pako.deflate(input, { level: 9 });

console.log('Level 1 size:', level1.length);
console.log('Level 9 size:', level9.length);

Getting Started

To use Pako in your project, first install it via npm:

npm install pako

Then, import and use it in your JavaScript code:

import pako from 'pako';

// Compress data
const input = 'Your data to compress';
const compressed = pako.deflate(input);

// Decompress data
const decompressed = pako.inflate(compressed, { to: 'string' });

console.log(decompressed === input); // Should output: true

For browser usage, you can include Pako via a CDN:

<script src="https://cdn.jsdelivr.net/npm/pako@2.1.0/dist/pako.min.js"></script>
<script>
  // Pako is available as a global object
  const compressed = pako.deflate('Hello, world!');
</script>

Competitor Comparisons

imaya logo

zlib.js

1,122

compact zlib, deflate, inflate, zip library in JavaScript

Pros of zlib.js

  • Pure JavaScript implementation, making it more portable across different environments
  • Supports both browser and Node.js environments out of the box
  • Includes additional features like GZIP support

Cons of zlib.js

  • Generally slower performance compared to pako
  • Less actively maintained, with fewer recent updates
  • Larger file size, which may impact load times in browser environments

Code Comparison

pako:

var pako = require('pako');
var input = new Uint8Array([1,2,3,4,5]);
var compressed = pako.deflate(input);
var decompressed = pako.inflate(compressed);

zlib.js:

var zlib = require('zlib.js');
var input = new Uint8Array([1,2,3,4,5]);
var compressed = zlib.deflate(input);
var decompressed = zlib.inflate(compressed);

Both libraries offer similar APIs for basic compression and decompression operations. However, pako generally provides better performance and is more actively maintained. zlib.js offers broader environment support out of the box but at the cost of larger file size and slower execution. The choice between the two depends on specific project requirements, such as performance needs, environment constraints, and additional feature requirements.

pieroxy logo

lz-string

4,075

LZ-based compression algorithm for JavaScript

Pros of lz-string

  • Smaller library size, making it more lightweight for browser use
  • Designed specifically for string compression, which can be more efficient for certain use cases
  • Simple API with easy-to-use methods for compression and decompression

Cons of lz-string

  • Limited to string compression only, unlike pako's support for various data types
  • May not achieve as high compression ratios as pako for certain types of data
  • Less actively maintained compared to pako

Code Comparison

lz-string:

var compressed = LZString.compress("Hello, World!");
var decompressed = LZString.decompress(compressed);

pako:

var compressed = pako.deflate("Hello, World!");
var decompressed = pako.inflate(compressed, {to: 'string'});

Summary

lz-string is a lightweight library focused on string compression, offering a simple API and efficient browser performance. However, it's limited to string data and may not achieve the same compression ratios as pako for all data types. pako, on the other hand, provides more comprehensive compression options and supports various data formats, but comes with a larger library size. The choice between the two depends on specific project requirements, such as data types, compression efficiency, and library size constraints.

101arrowz logo

fflate

2,207

High performance (de)compression in an 8kB package

Pros of fflate

  • Significantly smaller bundle size (about 3-4x smaller than pako)
  • Generally faster performance, especially for decompression
  • Supports more compression formats (e.g., GZIP, ZLIB, and raw DEFLATE)

Cons of fflate

  • Less mature project with potentially fewer real-world use cases
  • May have less comprehensive documentation compared to pako

Code Comparison

fflate:

import { gzip, ungzip } from 'fflate';

const compressed = gzip(new TextEncoder().encode('Hello, World!'));
const decompressed = ungzip(compressed);
console.log(new TextDecoder().decode(decompressed));

pako:

import pako from 'pako';

const compressed = pako.gzip('Hello, World!');
const decompressed = pako.ungzip(compressed);
console.log(new TextDecoder().decode(decompressed));

Both libraries offer similar APIs for basic compression and decompression tasks. However, fflate provides a more modern, ES6-style import syntax and uses typed arrays by default, which can lead to better performance in some cases. Pako, on the other hand, accepts strings directly for compression, which may be more convenient in certain scenarios.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

pako

CI NPM version

zlib port to javascript, very fast!

Why pako is cool:

  • Results are binary equal to well known zlib (now contains ported zlib v1.2.8).
  • Almost as fast in modern JS engines as C implementation (see benchmarks).
  • Works in browsers, you can browserify any separate component.

This project was done to understand how fast JS can be and is it necessary to develop native C modules for CPU-intensive tasks. Enjoy the result!

Benchmarks:

node v12.16.3 (zlib 1.2.9), 1mb input sample:

deflate-imaya x 4.75 ops/sec ±4.93% (15 runs sampled)
deflate-pako x 10.38 ops/sec ±0.37% (29 runs sampled)
deflate-zlib x 17.74 ops/sec ±0.77% (46 runs sampled)
gzip-pako x 8.86 ops/sec ±1.41% (29 runs sampled)
inflate-imaya x 107 ops/sec ±0.69% (77 runs sampled)
inflate-pako x 131 ops/sec ±1.74% (82 runs sampled)
inflate-zlib x 258 ops/sec ±0.66% (88 runs sampled)
ungzip-pako x 115 ops/sec ±1.92% (80 runs sampled)

node v14.15.0 (google's zlib), 1mb output sample:

deflate-imaya x 4.93 ops/sec ±3.09% (16 runs sampled)
deflate-pako x 10.22 ops/sec ±0.33% (29 runs sampled)
deflate-zlib x 18.48 ops/sec ±0.24% (48 runs sampled)
gzip-pako x 10.16 ops/sec ±0.25% (28 runs sampled)
inflate-imaya x 110 ops/sec ±0.41% (77 runs sampled)
inflate-pako x 134 ops/sec ±0.66% (83 runs sampled)
inflate-zlib x 402 ops/sec ±0.74% (87 runs sampled)
ungzip-pako x 113 ops/sec ±0.62% (80 runs sampled)

zlib's test is partially affected by marshalling (that make sense for inflate only). You can change deflate level to 0 in benchmark source, to investigate details. For deflate level 6 results can be considered as correct.

Install:

npm install pako

Examples / API

Full docs - http://nodeca.github.io/pako/

const pako = require('pako');

// Deflate
//
const input = new Uint8Array();
//... fill input data here
const output = pako.deflate(input);

// Inflate (simple wrapper can throw exception on broken stream)
//
const compressed = new Uint8Array();
//... fill data to uncompress here
try {
  const result = pako.inflate(compressed);
  // ... continue processing
} catch (err) {
  console.log(err);
}

//
// Alternate interface for chunking & without exceptions
//

const deflator = new pako.Deflate();

deflator.push(chunk1, false);
deflator.push(chunk2); // second param is false by default.
...
deflator.push(chunk_last, true); // `true` says this chunk is last

if (deflator.err) {
  console.log(deflator.msg);
}

const output = deflator.result;


const inflator = new pako.Inflate();

inflator.push(chunk1);
inflator.push(chunk2);
...
inflator.push(chunk_last); // no second param because end is auto-detected

if (inflator.err) {
  console.log(inflator.msg);
}

const output = inflator.result;

Sometime you can wish to work with strings. For example, to send stringified objects to server. Pako's deflate detects input data type, and automatically recode strings to utf-8 prior to compress. Inflate has special option, to say compressed data has utf-8 encoding and should be recoded to javascript's utf-16.

const pako = require('pako');

const test = { my: 'super', puper: [456, 567], awesome: 'pako' };

const compressed = pako.deflate(JSON.stringify(test));

const restored = JSON.parse(pako.inflate(compressed, { to: 'string' }));

Notes

Pako does not contain some specific zlib functions:

  • deflate - methods deflateCopy, deflateBound, deflateParams, deflatePending, deflatePrime, deflateTune.
  • inflate - methods inflateCopy, inflateMark, inflatePrime, inflateGetDictionary, inflateSync, inflateSyncPoint, inflateUndermine.
  • High level inflate/deflate wrappers (classes) may not support some flush modes.

pako for enterprise

Available as part of the Tidelift Subscription

The maintainers of pako and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. Learn more.

Authors

Personal thanks to:

  • Vyacheslav Egorov (@mraleph) for his awesome tutorials about optimising JS code for v8, IRHydra tool and his advices.
  • David Duponchel (@dduponchel) for help with testing.

Original implementation (in C):

  • zlib by Jean-loup Gailly and Mark Adler.

License

  • MIT - all files, except /lib/zlib folder
  • ZLIB - /lib/zlib content

NPM DownloadsLast 30 Days