@woosh/meep-engine 3.1.0 → 3.2.0

package/src/core/binary/lz4/lz4_compress_block.js

@@ -1,385 +1,385 @@
-import { assert } from "../../assert.js";
-import { LZ4_MAX_INPUT_SIZE } from "./LZ4_MAX_INPUT_SIZE.js";
-
-/** the shortest match the format can code — the match length field is biased by this */
-const MIN_MATCH = 4;
-
-/**
- * How much of the end of a block is left for the trailing literals: no match starts within this
- * many bytes of it.
- *
- * The loop tests it against the *next* position it would try rather than the current one, so a
- * position actually reached is at least one step below the limit — which is what makes the rule
- * hold as stated, with the limit itself computed one byte past it.
- */
-const MATCH_FIND_LIMIT = 12;
-
-/** the last bytes of a block are literals, and no match may cover them */
-const LAST_LITERALS = 5;
-
-/** below this there is no room for a match at all, so the block is one literal run */
-const MIN_LENGTH = MATCH_FIND_LIMIT + 1;
-
-/** the offset field is sixteen bits, so a match reaches back no further than this */
-const MAX_DISTANCE = 0xFFFF;
-
-/** both length nibbles saturate here, and continue in whole bytes */
-const NIBBLE_MAX = 15;
-
-/** a length continuation codes this much per byte, and a byte below it ends the run */
-const CONTINUATION_MAX = 255;
-
-/** Knuth's multiplicative constant, which is what the reference encoder hashes with */
-const HASH_MULTIPLIER = 2654435761;
-
-/**
- * The table holds this many slots. It is the wider of the two the reference encoder picks between:
- * it uses thirteen bits below 64KB of input and twelve above, because above that it also switches
- * to hashing five bytes through a 64-bit multiply, which JavaScript has no cheap way to do. Taking
- * the wider table everywhere costs 32KB of static memory and buys ratio on the large inputs where
- * the byte-for-byte agreement is out of reach anyway.
- */
-const HASH_LOG = 13;
-const HASH_SHIFT = 32 - HASH_LOG;
-
-/**
- * How far a failing search strides once this many positions in a row have failed. Widening the
- * stride as the miss run grows is what keeps incompressible input to a scan rather than a search.
- */
-const SKIP_TRIGGER = 6;
-
-/**
- * Literal runs shorter than this are cheaper to copy a byte at a time than to hand to `set`, whose
- * call overhead dominates until there is a memmove's worth of work behind it. Both halves earn
- * their keep: always looping costs incompressible input most of its throughput, and always calling
- * `set` costs data that codes as many short runs most of its own.
- */
-const BULK_COPY_LENGTH = 32;
-
-/**
- * Positions seen so far, keyed by a hash of the four bytes at them, and biased by one so that a
- * zeroed slot reads as empty.
- *
- * Module-static: it is 32KB that would otherwise be allocated and thrown away per call, and
- * {@link lz4_compress_block} is straight-line synchronous code that clears the table on entry, so
- * no second call can be part-way through it.
- *
- * @type {Int32Array}
- */
-const hash_table = new Int32Array(1 << HASH_LOG);
-
-/**
- * @param {number} sequence four bytes of input, read little-endian
- * @returns {number} a slot in {@link hash_table}
- */
-function hash_of(sequence) {
-    return Math.imul(sequence, HASH_MULTIPLIER) >>> HASH_SHIFT;
-}
-
-/**
- * Bytes a length continuation takes to carry `remainder`.
- *
- * @param {number} remainder what is left of a length once its nibble saturated
- * @returns {number}
- */
-function continuation_size(remainder) {
-    return 1 + ((remainder / CONTINUATION_MAX) | 0);
-}
-
-/**
- * Write a length continuation: whole 255s, then a byte below 255 to end it. A remainder that is
- * itself a multiple of 255 therefore ends in an explicit zero.
- *
- * @param {Uint8Array} destination
- * @param {number} d
- * @param {number} remainder
- * @returns {number} the offset just past the last byte written
- */
-function write_continuation(destination, d, remainder) {
-    let r = remainder;
-    let p = d;
-
-    while (r >= CONTINUATION_MAX) {
-        destination[p++] = CONTINUATION_MAX;
-        r -= CONTINUATION_MAX;
-    }
-
-    destination[p++] = r;
-
-    return p;
-}
-
-/**
- * Write a sequence's token and the literal run behind it.
- *
- * The token carries both length nibbles, so the match's coded length has to be known here even
- * though the match's own bytes come after the literals. The closing sequence of a block has no
- * match at all and passes a coded length of zero: the nibble is written, and nothing reads it,
- * because the block ends with the literals.
- *
- * @param {Uint8Array} destination
- * @param {number} d
- * @param {number} destination_end
- * @param {Uint8Array} source
- * @param {number} literal_start
- * @param {number} literal_end
- * @param {number} coded_match_length match length less {@link MIN_MATCH}
- * @returns {number} the offset just past the last byte written
- * @throws {Error} if the sequence does not fit the space given
- */
-function write_token_and_literals(destination, d, destination_end, source, literal_start, literal_end, coded_match_length) {
-    const literal_length = literal_end - literal_start;
-    const saturated = literal_length >= NIBBLE_MAX;
-
-    let required = 1 + literal_length;
-
-    if (saturated) {
-        required += continuation_size(literal_length - NIBBLE_MAX);
-    }
-
-    if (d + required > destination_end) {
-        throw new Error(
-            `lz4 sequence of ${literal_length} literals needs ${required} bytes, and only ${destination_end - d} are left`
-        );
-    }
-
-    let p = d;
-
-    destination[p++] = ((saturated ? NIBBLE_MAX : literal_length) << 4)
-        | (coded_match_length >= NIBBLE_MAX ? NIBBLE_MAX : coded_match_length);
-
-    if (saturated) {
-        p = write_continuation(destination, p, literal_length - NIBBLE_MAX);
-    }
-
-    if (literal_length >= BULK_COPY_LENGTH) {
-        destination.set(source.subarray(literal_start, literal_end), p);
-    } else {
-        for (let i = 0; i < literal_length; i++) {
-            destination[p + i] = source[literal_start + i];
-        }
-    }
-
-    return p + literal_length;
-}
-
-/**
- * How many bytes beyond the four already known to agree two positions agree on.
- *
- * @param {Uint8Array} source
- * @param {DataView} view over the whole of `source`
- * @param {number} a the later position, past its first four bytes
- * @param {number} b the earlier position, past its first four bytes
- * @param {number} limit one past the last byte a match may cover
- * @returns {number}
- */
-function count_match(source, view, a, b, limit) {
-    let p = a;
-    let q = b;
-
-    while (p + 4 <= limit && view.getUint32(p, true) === view.getUint32(q, true)) {
-        p += 4;
-        q += 4;
-    }
-
-    while (p < limit && source[p] === source[q]) {
-        p++;
-        q++;
-    }
-
-    return p - a;
-}
-
-/**
- * Encode one LZ4 block.
- *
- * The mirror of {@link lz4_decompress_block}, and its inverse: a block written here decodes back to
- * exactly the bytes it was given.
- *
- * This is the format's fast encoder, and for inputs below 64KB it is `LZ4_compress_default` byte
- * for byte — the specs pin that against blocks the reference implementation produced. It makes a
- * single greedy pass, offering each position's four bytes to a hash table that remembers one
- * position per slot, and taking whatever match that slot holds without ever looking for a better
- * one. A position that yields nothing costs a hash and a store, and a run of them widens the
- * stride between the positions tried at all, so input with nothing in it is scanned rather than
- * searched.
- *
- * Three things beyond the plain loop are worth naming, because each buys ratio for a handful of
- * instructions. A match is extended *backwards* first, over bytes that would otherwise be coded as
- * literals. The two bytes at the far end of a match are indexed on the way past, since a later
- * match may want to start on them. And the position a match lands on is tried immediately, so two
- * adjacent matches cost an empty literal run between them rather than a fresh search.
- *
- * The block is self-contained, which is what the decoder will accept: no match reaches back before
- * `source_offset`, so blocks written back to back into one buffer decode back to back out of it.
- * The end-of-block restrictions the specification places on encoders are honoured — the last five
- * bytes are literals, no match starts within twelve bytes of the end, and the block closes with a
- * literals-only sequence.
- *
- * `destination` and `source` must not overlap.
- *
- * @see https://github.com/lz4/lz4/blob/dev/doc/lz4_Block_format.md — LZ4 block format
- * @see https://github.com/lz4/lz4/blob/dev/lib/lz4.c — `LZ4_compress_generic`
- *
- * @param {Uint8Array} destination
- * @param {number} destination_offset where this block's output starts
- * @param {number} destination_end one past the last byte the block may write; give it
- *                                 {@link lz4_compress_bound} bytes and it cannot run out
- * @param {Uint8Array} source
- * @param {number} source_offset the first byte of input, and the floor a match may reach back to
- * @param {number} source_end one past the last byte of input
- * @returns {number} the offset just past the last byte written
- * @throws {Error} if the block does not fit the space given for it
- */
-export function lz4_compress_block(destination, destination_offset, destination_end, source, source_offset, source_end) {
-    assert.isNonNegativeInteger(destination_offset, 'destination_offset');
-    assert.lessThanOrEqual(destination_end, destination.length, 'destination_end');
-    assert.lessThanOrEqual(destination_offset, destination_end, 'destination_offset');
-    assert.isNonNegativeInteger(source_offset, 'source_offset');
-    assert.lessThanOrEqual(source_end, source.length, 'source_end');
-    assert.lessThanOrEqual(source_offset, source_end, 'source_offset');
-    // positions are held in an Int32Array, and a conforming block carries no more than this anyway
-    assert.lessThanOrEqual(source_end, LZ4_MAX_INPUT_SIZE, 'source_end');
-
-    let d = destination_offset;
-    let anchor = source_offset;
-
-    if (source_end - source_offset >= MIN_LENGTH) {
-        const view = new DataView(source.buffer, source.byteOffset, source.byteLength);
-
-        /** one past the last position the search may step to, so matches start below it */
-        const match_find_limit = source_end - MATCH_FIND_LIMIT + 1;
-
-        /** one past the last byte a match may cover */
-        const match_limit = source_end - LAST_LITERALS;
-
-        hash_table.fill(0);
-
-        let ip = source_offset;
-
-        hash_table[hash_of(view.getUint32(ip, true))] = ip + 1;
-        ip++;
-
-        let forward_hash = hash_of(view.getUint32(ip, true));
-
-        // broken out of where the reference encoder jumps to its trailing literals: when the search
-        // runs out of room, and when a match lands too close to the end to be followed by another
-        sequences: for (;;) {
-            /** set by the search below, which either finds a match or leaves the block entirely */
-            let match_position;
-
-            // --- find a match ---
-
-            {
-                let forward_ip = ip;
-                let step = 1;
-                let miss_count = 1 << SKIP_TRIGGER;
-
-                for (;;) {
-                    const h = forward_hash;
-
-                    ip = forward_ip;
-                    forward_ip += step;
-                    step = (miss_count++) >> SKIP_TRIGGER;
-
-                    if (forward_ip > match_find_limit) {
-                        break sequences;
-                    }
-
-                    // slots hold nothing but positions stored this call, so a slot that is not
-                    // empty holds a position at or after the start of the block
-                    const candidate = hash_table[h] - 1;
-
-                    forward_hash = hash_of(view.getUint32(forward_ip, true));
-                    hash_table[h] = ip + 1;
-
-                    if (
-                        candidate >= 0
-                        && ip - candidate <= MAX_DISTANCE
-                        && view.getUint32(candidate, true) === view.getUint32(ip, true)
-                    ) {
-                        match_position = candidate;
-                        break;
-                    }
-                }
-            }
-
-            // --- encode it, and any match that follows it immediately ---
-
-            for (;;) {
-                // Extend backwards over bytes the literal run would otherwise carry. The offset is
-                // unchanged by this, since both ends step back together. A match reached from the
-                // position the last one ended on has nothing behind it, and skips the loop.
-                while (
-                    ip > anchor
-                    && match_position > source_offset
-                    && source[ip - 1] === source[match_position - 1]
-                ) {
-                    ip--;
-                    match_position--;
-                }
-
-                const match_length = MIN_MATCH + count_match(
-                    source, view, ip + MIN_MATCH, match_position + MIN_MATCH, match_limit
-                );
-
-                const coded_match_length = match_length - MIN_MATCH;
-
-                d = write_token_and_literals(destination, d, destination_end, source, anchor, ip, coded_match_length);
-
-                let required = 2;
-
-                if (coded_match_length >= NIBBLE_MAX) {
-                    required += continuation_size(coded_match_length - NIBBLE_MAX);
-                }
-
-                if (d + required > destination_end) {
-                    throw new Error(
-                        `lz4 match of ${match_length} needs ${required} bytes, and only ${destination_end - d} are left`
-                    );
-                }
-
-                const match_offset = ip - match_position;
-
-                destination[d++] = match_offset & 0xFF;
-                destination[d++] = (match_offset >> 8) & 0xFF;
-
-                if (coded_match_length >= NIBBLE_MAX) {
-                    d = write_continuation(destination, d, coded_match_length - NIBBLE_MAX);
-                }
-
-                ip += match_length;
-                anchor = ip;
-
-                if (ip >= match_find_limit) {
-                    break sequences;
-                }
-
-                // the two bytes at the far end of the match that a later match could start on
-                hash_table[hash_of(view.getUint32(ip - 2, true))] = (ip - 2) + 1;
-
-                const h = hash_of(view.getUint32(ip, true));
-                const candidate = hash_table[h] - 1;
-
-                hash_table[h] = ip + 1;
-
-                if (
-                    candidate >= 0
-                    && ip - candidate <= MAX_DISTANCE
-                    && view.getUint32(candidate, true) === view.getUint32(ip, true)
-                ) {
-                    match_position = candidate;
-                    continue;
-                }
-
-                ip++;
-                forward_hash = hash_of(view.getUint32(ip, true));
-
-                break;
-            }
-        }
-    }
-
-    // a block closes with its trailing literals, and no match behind them
-    return write_token_and_literals(destination, d, destination_end, source, anchor, source_end, 0);
-}
+import { assert } from "../../assert.js";
+import { LZ4_MAX_INPUT_SIZE } from "./LZ4_MAX_INPUT_SIZE.js";
+
+/** the shortest match the format can code — the match length field is biased by this */
+const MIN_MATCH = 4;
+
+/**
+ * How much of the end of a block is left for the trailing literals: no match starts within this
+ * many bytes of it.
+ *
+ * The loop tests it against the *next* position it would try rather than the current one, so a
+ * position actually reached is at least one step below the limit — which is what makes the rule
+ * hold as stated, with the limit itself computed one byte past it.
+ */
+const MATCH_FIND_LIMIT = 12;
+
+/** the last bytes of a block are literals, and no match may cover them */
+const LAST_LITERALS = 5;
+
+/** below this there is no room for a match at all, so the block is one literal run */
+const MIN_LENGTH = MATCH_FIND_LIMIT + 1;
+
+/** the offset field is sixteen bits, so a match reaches back no further than this */
+const MAX_DISTANCE = 0xFFFF;
+
+/** both length nibbles saturate here, and continue in whole bytes */
+const NIBBLE_MAX = 15;
+
+/** a length continuation codes this much per byte, and a byte below it ends the run */
+const CONTINUATION_MAX = 255;
+
+/** Knuth's multiplicative constant, which is what the reference encoder hashes with */
+const HASH_MULTIPLIER = 2654435761;
+
+/**
+ * The table holds this many slots. It is the wider of the two the reference encoder picks between:
+ * it uses thirteen bits below 64KB of input and twelve above, because above that it also switches
+ * to hashing five bytes through a 64-bit multiply, which JavaScript has no cheap way to do. Taking
+ * the wider table everywhere costs 32KB of static memory and buys ratio on the large inputs where
+ * the byte-for-byte agreement is out of reach anyway.
+ */
+const HASH_LOG = 13;
+const HASH_SHIFT = 32 - HASH_LOG;
+
+/**
+ * How far a failing search strides once this many positions in a row have failed. Widening the
+ * stride as the miss run grows is what keeps incompressible input to a scan rather than a search.
+ */
+const SKIP_TRIGGER = 6;
+
+/**
+ * Literal runs shorter than this are cheaper to copy a byte at a time than to hand to `set`, whose
+ * call overhead dominates until there is a memmove's worth of work behind it. Both halves earn
+ * their keep: always looping costs incompressible input most of its throughput, and always calling
+ * `set` costs data that codes as many short runs most of its own.
+ */
+const BULK_COPY_LENGTH = 32;
+
+/**
+ * Positions seen so far, keyed by a hash of the four bytes at them, and biased by one so that a
+ * zeroed slot reads as empty.
+ *
+ * Module-static: it is 32KB that would otherwise be allocated and thrown away per call, and
+ * {@link lz4_compress_block} is straight-line synchronous code that clears the table on entry, so
+ * no second call can be part-way through it.
+ *
+ * @type {Int32Array}
+ */
+const hash_table = new Int32Array(1 << HASH_LOG);
+
+/**
+ * @param {number} sequence four bytes of input, read little-endian
+ * @returns {number} a slot in {@link hash_table}
+ */
+function hash_of(sequence) {
+    return Math.imul(sequence, HASH_MULTIPLIER) >>> HASH_SHIFT;
+}
+
+/**
+ * Bytes a length continuation takes to carry `remainder`.
+ *
+ * @param {number} remainder what is left of a length once its nibble saturated
+ * @returns {number}
+ */
+function continuation_size(remainder) {
+    return 1 + ((remainder / CONTINUATION_MAX) | 0);
+}
+
+/**
+ * Write a length continuation: whole 255s, then a byte below 255 to end it. A remainder that is
+ * itself a multiple of 255 therefore ends in an explicit zero.
+ *
+ * @param {Uint8Array} destination
+ * @param {number} d
+ * @param {number} remainder
+ * @returns {number} the offset just past the last byte written
+ */
+function write_continuation(destination, d, remainder) {
+    let r = remainder;
+    let p = d;
+
+    while (r >= CONTINUATION_MAX) {
+        destination[p++] = CONTINUATION_MAX;
+        r -= CONTINUATION_MAX;
+    }
+
+    destination[p++] = r;
+
+    return p;
+}
+
+/**
+ * Write a sequence's token and the literal run behind it.
+ *
+ * The token carries both length nibbles, so the match's coded length has to be known here even
+ * though the match's own bytes come after the literals. The closing sequence of a block has no
+ * match at all and passes a coded length of zero: the nibble is written, and nothing reads it,
+ * because the block ends with the literals.
+ *
+ * @param {Uint8Array} destination
+ * @param {number} d
+ * @param {number} destination_end
+ * @param {Uint8Array} source
+ * @param {number} literal_start
+ * @param {number} literal_end
+ * @param {number} coded_match_length match length less {@link MIN_MATCH}
+ * @returns {number} the offset just past the last byte written
+ * @throws {Error} if the sequence does not fit the space given
+ */
+function write_token_and_literals(destination, d, destination_end, source, literal_start, literal_end, coded_match_length) {
+    const literal_length = literal_end - literal_start;
+    const saturated = literal_length >= NIBBLE_MAX;
+
+    let required = 1 + literal_length;
+
+    if (saturated) {
+        required += continuation_size(literal_length - NIBBLE_MAX);
+    }
+
+    if (d + required > destination_end) {
+        throw new Error(
+            `lz4 sequence of ${literal_length} literals needs ${required} bytes, and only ${destination_end - d} are left`
+        );
+    }
+
+    let p = d;
+
+    destination[p++] = ((saturated ? NIBBLE_MAX : literal_length) << 4)
+        | (coded_match_length >= NIBBLE_MAX ? NIBBLE_MAX : coded_match_length);
+
+    if (saturated) {
+        p = write_continuation(destination, p, literal_length - NIBBLE_MAX);
+    }
+
+    if (literal_length >= BULK_COPY_LENGTH) {
+        destination.set(source.subarray(literal_start, literal_end), p);
+    } else {
+        for (let i = 0; i < literal_length; i++) {
+            destination[p + i] = source[literal_start + i];
+        }
+    }
+
+    return p + literal_length;
+}
+
+/**
+ * How many bytes beyond the four already known to agree two positions agree on.
+ *
+ * @param {Uint8Array} source
+ * @param {DataView} view over the whole of `source`
+ * @param {number} a the later position, past its first four bytes
+ * @param {number} b the earlier position, past its first four bytes
+ * @param {number} limit one past the last byte a match may cover
+ * @returns {number}
+ */
+function count_match(source, view, a, b, limit) {
+    let p = a;
+    let q = b;
+
+    while (p + 4 <= limit && view.getUint32(p, true) === view.getUint32(q, true)) {
+        p += 4;
+        q += 4;
+    }
+
+    while (p < limit && source[p] === source[q]) {
+        p++;
+        q++;
+    }
+
+    return p - a;
+}
+
+/**
+ * Encode one LZ4 block.
+ *
+ * The mirror of {@link lz4_decompress_block}, and its inverse: a block written here decodes back to
+ * exactly the bytes it was given.
+ *
+ * This is the format's fast encoder, and for inputs below 64KB it is `LZ4_compress_default` byte
+ * for byte — the specs pin that against blocks the reference implementation produced. It makes a
+ * single greedy pass, offering each position's four bytes to a hash table that remembers one
+ * position per slot, and taking whatever match that slot holds without ever looking for a better
+ * one. A position that yields nothing costs a hash and a store, and a run of them widens the
+ * stride between the positions tried at all, so input with nothing in it is scanned rather than
+ * searched.
+ *
+ * Three things beyond the plain loop are worth naming, because each buys ratio for a handful of
+ * instructions. A match is extended *backwards* first, over bytes that would otherwise be coded as
+ * literals. The two bytes at the far end of a match are indexed on the way past, since a later
+ * match may want to start on them. And the position a match lands on is tried immediately, so two
+ * adjacent matches cost an empty literal run between them rather than a fresh search.
+ *
+ * The block is self-contained, which is what the decoder will accept: no match reaches back before
+ * `source_offset`, so blocks written back to back into one buffer decode back to back out of it.
+ * The end-of-block restrictions the specification places on encoders are honoured — the last five
+ * bytes are literals, no match starts within twelve bytes of the end, and the block closes with a
+ * literals-only sequence.
+ *
+ * `destination` and `source` must not overlap.
+ *
+ * @see https://github.com/lz4/lz4/blob/dev/doc/lz4_Block_format.md — LZ4 block format
+ * @see https://github.com/lz4/lz4/blob/dev/lib/lz4.c — `LZ4_compress_generic`
+ *
+ * @param {Uint8Array} destination
+ * @param {number} destination_offset where this block's output starts
+ * @param {number} destination_end one past the last byte the block may write; give it
+ *                                 {@link lz4_compress_bound} bytes and it cannot run out
+ * @param {Uint8Array} source
+ * @param {number} source_offset the first byte of input, and the floor a match may reach back to
+ * @param {number} source_end one past the last byte of input
+ * @returns {number} the offset just past the last byte written
+ * @throws {Error} if the block does not fit the space given for it
+ */
+export function lz4_compress_block(destination, destination_offset, destination_end, source, source_offset, source_end) {
+    assert.isNonNegativeInteger(destination_offset, 'destination_offset');
+    assert.lessThanOrEqual(destination_end, destination.length, 'destination_end');
+    assert.lessThanOrEqual(destination_offset, destination_end, 'destination_offset');
+    assert.isNonNegativeInteger(source_offset, 'source_offset');
+    assert.lessThanOrEqual(source_end, source.length, 'source_end');
+    assert.lessThanOrEqual(source_offset, source_end, 'source_offset');
+    // positions are held in an Int32Array, and a conforming block carries no more than this anyway
+    assert.lessThanOrEqual(source_end, LZ4_MAX_INPUT_SIZE, 'source_end');
+
+    let d = destination_offset;
+    let anchor = source_offset;
+
+    if (source_end - source_offset >= MIN_LENGTH) {
+        const view = new DataView(source.buffer, source.byteOffset, source.byteLength);
+
+        /** one past the last position the search may step to, so matches start below it */
+        const match_find_limit = source_end - MATCH_FIND_LIMIT + 1;
+
+        /** one past the last byte a match may cover */
+        const match_limit = source_end - LAST_LITERALS;
+
+        hash_table.fill(0);
+
+        let ip = source_offset;
+
+        hash_table[hash_of(view.getUint32(ip, true))] = ip + 1;
+        ip++;
+
+        let forward_hash = hash_of(view.getUint32(ip, true));
+
+        // broken out of where the reference encoder jumps to its trailing literals: when the search
+        // runs out of room, and when a match lands too close to the end to be followed by another
+        sequences: for (;;) {
+            /** set by the search below, which either finds a match or leaves the block entirely */
+            let match_position;
+
+            // --- find a match ---
+
+            {
+                let forward_ip = ip;
+                let step = 1;
+                let miss_count = 1 << SKIP_TRIGGER;
+
+                for (;;) {
+                    const h = forward_hash;
+
+                    ip = forward_ip;
+                    forward_ip += step;
+                    step = (miss_count++) >> SKIP_TRIGGER;
+
+                    if (forward_ip > match_find_limit) {
+                        break sequences;
+                    }
+
+                    // slots hold nothing but positions stored this call, so a slot that is not
+                    // empty holds a position at or after the start of the block
+                    const candidate = hash_table[h] - 1;
+
+                    forward_hash = hash_of(view.getUint32(forward_ip, true));
+                    hash_table[h] = ip + 1;
+
+                    if (
+                        candidate >= 0
+                        && ip - candidate <= MAX_DISTANCE
+                        && view.getUint32(candidate, true) === view.getUint32(ip, true)
+                    ) {
+                        match_position = candidate;
+                        break;
+                    }
+                }
+            }
+
+            // --- encode it, and any match that follows it immediately ---
+
+            for (;;) {
+                // Extend backwards over bytes the literal run would otherwise carry. The offset is
+                // unchanged by this, since both ends step back together. A match reached from the
+                // position the last one ended on has nothing behind it, and skips the loop.
+                while (
+                    ip > anchor
+                    && match_position > source_offset
+                    && source[ip - 1] === source[match_position - 1]
+                ) {
+                    ip--;
+                    match_position--;
+                }
+
+                const match_length = MIN_MATCH + count_match(
+                    source, view, ip + MIN_MATCH, match_position + MIN_MATCH, match_limit
+                );
+
+                const coded_match_length = match_length - MIN_MATCH;
+
+                d = write_token_and_literals(destination, d, destination_end, source, anchor, ip, coded_match_length);
+
+                let required = 2;
+
+                if (coded_match_length >= NIBBLE_MAX) {
+                    required += continuation_size(coded_match_length - NIBBLE_MAX);
+                }
+
+                if (d + required > destination_end) {
+                    throw new Error(
+                        `lz4 match of ${match_length} needs ${required} bytes, and only ${destination_end - d} are left`
+                    );
+                }
+
+                const match_offset = ip - match_position;
+
+                destination[d++] = match_offset & 0xFF;
+                destination[d++] = (match_offset >> 8) & 0xFF;
+
+                if (coded_match_length >= NIBBLE_MAX) {
+                    d = write_continuation(destination, d, coded_match_length - NIBBLE_MAX);
+                }
+
+                ip += match_length;
+                anchor = ip;
+
+                if (ip >= match_find_limit) {
+                    break sequences;
+                }
+
+                // the two bytes at the far end of the match that a later match could start on
+                hash_table[hash_of(view.getUint32(ip - 2, true))] = (ip - 2) + 1;
+
+                const h = hash_of(view.getUint32(ip, true));
+                const candidate = hash_table[h] - 1;
+
+                hash_table[h] = ip + 1;
+
+                if (
+                    candidate >= 0
+                    && ip - candidate <= MAX_DISTANCE
+                    && view.getUint32(candidate, true) === view.getUint32(ip, true)
+                ) {
+                    match_position = candidate;
+                    continue;
+                }
+
+                ip++;
+                forward_hash = hash_of(view.getUint32(ip, true));
+
+                break;
+            }
+        }
+    }
+
+    // a block closes with its trailing literals, and no match behind them
+    return write_token_and_literals(destination, d, destination_end, source, anchor, source_end, 0);
+}