✨ feat: First draft.

Author: make-github-pseudonymous-again

package.json

@@ -27,6 +27,7 @@
             "transform-remove-console",
             {
               "exclude": [
+                "debug",
                 "log",
                 "error",
                 "warn"
@@ -77,6 +78,8 @@
   },
   "dependencies": {},
   "devDependencies": {
+    "@aureooms/js-string": "^0.2.0",
+    "@aureooms/js-trie": "^0.0.1",
     "@babel/cli": "7.11.6",
     "@babel/core": "7.11.6",
     "@babel/preset-env": "7.11.5",
@@ -101,7 +104,13 @@
     "lib"
   ],
   "homepage": "https://aureooms.github.io/js-lempel-ziv",
-  "keywords": ["compression", "lempel", "lossless", "lz", "ziv"],
+  "keywords": [
+    "compression",
+    "lempel",
+    "lossless",
+    "lz",
+    "ziv"
+  ],
   "license": "AGPL-3.0",
   "main": "lib/index.js",
   "prettier": {

src/index.js

@@ -0,0 +1,8 @@
+import lz78 from './lz78';
+
+/* eslint import/no-anonymous-default-export: [2, {"allowObject": true}] */
+export default {
+	lz78,
+};
+
+export {lz78};

src/lz78.js

@@ -0,0 +1,70 @@
+import {Trie, ObjectNode} from '@aureooms/js-trie';
+import {push, iter} from '@aureooms/js-persistent-stack';
+
+/**
+ * Simple Lempel-Ziv lossless data compression algorithm implementation.
+ */
+
+// TODO read input as async tape
+// TODO await trie operations
+// TODO use persistent trie
+
+export function* encode({trie, table}, symbols) {
+	let chunkNumber = table.length - 1;
+	const itSymbols = symbols[Symbol.iterator]();
+	while (true) {
+		const [part, node] = trie.getClosestAncestor(itSymbols);
+		if (part === undefined) {
+			yield [node.value(), undefined];
+			break;
+		}
+
+		node.set(part, ++chunkNumber);
+
+		yield [node.value(), part];
+	}
+}
+
+const reify = (chunk) => [...iter(chunk)].reverse().join('');
+
+// TODO use persistent table
+
+export function* decode({table}, tokens) {
+	for (const [parent, child] of tokens) {
+		const previous = table[parent];
+
+		if (child === undefined) {
+			yield reify(previous);
+		} else {
+			const newChunk = push(previous, child);
+			yield reify(newChunk);
+			table.push(newChunk);
+		}
+	}
+}
+
+// TODO use persistent dict (hence a persistent trie and table)
+export const dict = (symbols = ['']) => {
+	const trie = makeTrie(symbols);
+	const table = makeTable(trie);
+	return {trie, table};
+};
+
+const makeTable = (trie) => {
+	const table = [];
+	for (const [key, value] of trie) table[value] = key;
+	return table;
+};
+
+const emptyTrie = () => {
+	const root = new ObjectNode();
+	const trie = new Trie(root);
+	return trie;
+};
+
+const makeTrie = (symbols) => {
+	const trie = emptyTrie();
+	let i = 0;
+	for (const x of symbols) trie.set(x, i++);
+	return trie;
+};

test/src/lz78.js

@@ -0,0 +1,32 @@
+import test from 'ava';
+
+import {mul} from '@aureooms/js-string';
+import {dict, encode, decode} from '../../src/lz78';
+
+const alphabetaL = 'abcdefghijklmnopqrstuvwxyz';
+const alphabetaU = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const initEmpty = () => dict();
+const initAlphabet = () => dict(['', ...alphabetaL, ...alphabetaU]);
+
+const macro = (t, init, input) => {
+	// TODO use init only once once persistent data structures are used
+	const tokens = encode(init(), input);
+	const chunks = decode(init(), tokens);
+	const decoded = [...chunks].join('');
+
+	t.deepEqual(input, decoded, 'decoded message must be the same as input');
+};
+
+const repr = (string) =>
+	string.length >= 20 ? string.slice(0, 9) + '..' + string.slice(-9) : string;
+
+macro.title = (title, init, input) => `lz78 <${init.name}>: ${repr(input)}`;
+
+for (const init of [initEmpty, initAlphabet]) {
+	test(macro, init, '');
+	test(macro, init, 'a');
+	test(macro, init, 'ab');
+	test(macro, init, 'abc');
+	test(macro, init, mul('GZYAGZUAYZGUAYZFAAFAFTAZFTAFZTAFTZFATFA', 4));
+	test(macro, init, mul('B', 81));
+}