@highlight-run/rrweb 1.2.0 → 2.0.1

package/dist/record/rrweb-record-pack.js

@@ -0,0 +1,747 @@
+var rrwebRecord = (function (exports) {
+    'use strict';
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    var NodeType;
+    (function (NodeType) {
+        NodeType[NodeType["Document"] = 0] = "Document";
+        NodeType[NodeType["DocumentType"] = 1] = "DocumentType";
+        NodeType[NodeType["Element"] = 2] = "Element";
+        NodeType[NodeType["Text"] = 3] = "Text";
+        NodeType[NodeType["CDATA"] = 4] = "CDATA";
+        NodeType[NodeType["Comment"] = 5] = "Comment";
+    })(NodeType || (NodeType = {}));
+
+    var EventType;
+    (function (EventType) {
+        EventType[EventType["DomContentLoaded"] = 0] = "DomContentLoaded";
+        EventType[EventType["Load"] = 1] = "Load";
+        EventType[EventType["FullSnapshot"] = 2] = "FullSnapshot";
+        EventType[EventType["IncrementalSnapshot"] = 3] = "IncrementalSnapshot";
+        EventType[EventType["Meta"] = 4] = "Meta";
+        EventType[EventType["Custom"] = 5] = "Custom";
+        EventType[EventType["Plugin"] = 6] = "Plugin";
+    })(EventType || (EventType = {}));
+    var IncrementalSource;
+    (function (IncrementalSource) {
+        IncrementalSource[IncrementalSource["Mutation"] = 0] = "Mutation";
+        IncrementalSource[IncrementalSource["MouseMove"] = 1] = "MouseMove";
+        IncrementalSource[IncrementalSource["MouseInteraction"] = 2] = "MouseInteraction";
+        IncrementalSource[IncrementalSource["Scroll"] = 3] = "Scroll";
+        IncrementalSource[IncrementalSource["ViewportResize"] = 4] = "ViewportResize";
+        IncrementalSource[IncrementalSource["Input"] = 5] = "Input";
+        IncrementalSource[IncrementalSource["TouchMove"] = 6] = "TouchMove";
+        IncrementalSource[IncrementalSource["MediaInteraction"] = 7] = "MediaInteraction";
+        IncrementalSource[IncrementalSource["StyleSheetRule"] = 8] = "StyleSheetRule";
+        IncrementalSource[IncrementalSource["CanvasMutation"] = 9] = "CanvasMutation";
+        IncrementalSource[IncrementalSource["Font"] = 10] = "Font";
+        IncrementalSource[IncrementalSource["Log"] = 11] = "Log";
+        IncrementalSource[IncrementalSource["Drag"] = 12] = "Drag";
+        IncrementalSource[IncrementalSource["StyleDeclaration"] = 13] = "StyleDeclaration";
+    })(IncrementalSource || (IncrementalSource = {}));
+    var MouseInteractions;
+    (function (MouseInteractions) {
+        MouseInteractions[MouseInteractions["MouseUp"] = 0] = "MouseUp";
+        MouseInteractions[MouseInteractions["MouseDown"] = 1] = "MouseDown";
+        MouseInteractions[MouseInteractions["Click"] = 2] = "Click";
+        MouseInteractions[MouseInteractions["ContextMenu"] = 3] = "ContextMenu";
+        MouseInteractions[MouseInteractions["DblClick"] = 4] = "DblClick";
+        MouseInteractions[MouseInteractions["Focus"] = 5] = "Focus";
+        MouseInteractions[MouseInteractions["Blur"] = 6] = "Blur";
+        MouseInteractions[MouseInteractions["TouchStart"] = 7] = "TouchStart";
+        MouseInteractions[MouseInteractions["TouchMove_Departed"] = 8] = "TouchMove_Departed";
+        MouseInteractions[MouseInteractions["TouchEnd"] = 9] = "TouchEnd";
+        MouseInteractions[MouseInteractions["TouchCancel"] = 10] = "TouchCancel";
+    })(MouseInteractions || (MouseInteractions = {}));
+    var CanvasContext;
+    (function (CanvasContext) {
+        CanvasContext[CanvasContext["2D"] = 0] = "2D";
+        CanvasContext[CanvasContext["WebGL"] = 1] = "WebGL";
+        CanvasContext[CanvasContext["WebGL2"] = 2] = "WebGL2";
+    })(CanvasContext || (CanvasContext = {}));
+    var MediaInteractions;
+    (function (MediaInteractions) {
+        MediaInteractions[MediaInteractions["Play"] = 0] = "Play";
+        MediaInteractions[MediaInteractions["Pause"] = 1] = "Pause";
+        MediaInteractions[MediaInteractions["Seeked"] = 2] = "Seeked";
+        MediaInteractions[MediaInteractions["VolumeChange"] = 3] = "VolumeChange";
+    })(MediaInteractions || (MediaInteractions = {}));
+    var ReplayerEvents;
+    (function (ReplayerEvents) {
+        ReplayerEvents["Start"] = "start";
+        ReplayerEvents["Pause"] = "pause";
+        ReplayerEvents["Resume"] = "resume";
+        ReplayerEvents["Resize"] = "resize";
+        ReplayerEvents["Finish"] = "finish";
+        ReplayerEvents["FullsnapshotRebuilded"] = "fullsnapshot-rebuilded";
+        ReplayerEvents["LoadStylesheetStart"] = "load-stylesheet-start";
+        ReplayerEvents["LoadStylesheetEnd"] = "load-stylesheet-end";
+        ReplayerEvents["SkipStart"] = "skip-start";
+        ReplayerEvents["SkipEnd"] = "skip-end";
+        ReplayerEvents["MouseInteraction"] = "mouse-interaction";
+        ReplayerEvents["EventCast"] = "event-cast";
+        ReplayerEvents["CustomEvent"] = "custom-event";
+        ReplayerEvents["Flush"] = "flush";
+        ReplayerEvents["StateChange"] = "state-change";
+        ReplayerEvents["PlayBack"] = "play-back";
+    })(ReplayerEvents || (ReplayerEvents = {}));
+
+    var DEPARTED_MIRROR_ACCESS_WARNING = 'Please stop import mirror directly. Instead of that,' +
+        '\r\n' +
+        'now you can use replayer.getMirror() to access the mirror instance of a replayer,' +
+        '\r\n' +
+        'or you can use record.mirror to access the mirror instance during recording.';
+    var _mirror = {
+        map: {},
+        getId: function () {
+            console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+            return -1;
+        },
+        getNode: function () {
+            console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+            return null;
+        },
+        removeNodeFromMap: function () {
+            console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+        },
+        has: function () {
+            console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+            return false;
+        },
+        reset: function () {
+            console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+        },
+    };
+    if (typeof window !== 'undefined' && window.Proxy && window.Reflect) {
+        _mirror = new Proxy(_mirror, {
+            get: function (target, prop, receiver) {
+                if (prop === 'map') {
+                    console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+        });
+    }
+
+    /*
+     * base64-arraybuffer 1.0.1 <https://github.com/niklasvh/base64-arraybuffer>
+     * Copyright (c) 2021 Niklas von Hertzen <https://hertzen.com>
+     * Released under MIT License
+     */
+    var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    // Use a lookup table to find the index.
+    var lookup = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);
+    for (var i$1 = 0; i$1 < chars.length; i$1++) {
+        lookup[chars.charCodeAt(i$1)] = i$1;
+    }
+
+    // DEFLATE is a complex format; to read this code, you should probably check the RFC first:
+
+    // aliases for shorter compressed code (most minifers don't do this)
+    var u8 = Uint8Array, u16 = Uint16Array, u32 = Uint32Array;
+    // fixed length extra bits
+    var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]);
+    // fixed distance extra bits
+    // see fleb note
+    var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]);
+    // code length index map
+    var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+    // get base, reverse index map from extra bits
+    var freb = function (eb, start) {
+        var b = new u16(31);
+        for (var i = 0; i < 31; ++i) {
+            b[i] = start += 1 << eb[i - 1];
+        }
+        // numbers here are at max 18 bits
+        var r = new u32(b[30]);
+        for (var i = 1; i < 30; ++i) {
+            for (var j = b[i]; j < b[i + 1]; ++j) {
+                r[j] = ((j - b[i]) << 5) | i;
+            }
+        }
+        return [b, r];
+    };
+    var _a = freb(fleb, 2), fl = _a[0], revfl = _a[1];
+    // we can ignore the fact that the other numbers are wrong; they never happen anyway
+    fl[28] = 258, revfl[258] = 28;
+    var _b = freb(fdeb, 0), revfd = _b[1];
+    // map of value to reverse (assuming 16 bits)
+    var rev = new u16(32768);
+    for (var i = 0; i < 32768; ++i) {
+        // reverse table algorithm from SO
+        var x = ((i & 0xAAAA) >>> 1) | ((i & 0x5555) << 1);
+        x = ((x & 0xCCCC) >>> 2) | ((x & 0x3333) << 2);
+        x = ((x & 0xF0F0) >>> 4) | ((x & 0x0F0F) << 4);
+        rev[i] = (((x & 0xFF00) >>> 8) | ((x & 0x00FF) << 8)) >>> 1;
+    }
+    // create huffman tree from u8 "map": index -> code length for code index
+    // mb (max bits) must be at most 15
+    // TODO: optimize/split up?
+    var hMap = (function (cd, mb, r) {
+        var s = cd.length;
+        // index
+        var i = 0;
+        // u16 "map": index -> # of codes with bit length = index
+        var l = new u16(mb);
+        // length of cd must be 288 (total # of codes)
+        for (; i < s; ++i)
+            ++l[cd[i] - 1];
+        // u16 "map": index -> minimum code for bit length = index
+        var le = new u16(mb);
+        for (i = 0; i < mb; ++i) {
+            le[i] = (le[i - 1] + l[i - 1]) << 1;
+        }
+        var co;
+        if (r) {
+            // u16 "map": index -> number of actual bits, symbol for code
+            co = new u16(1 << mb);
+            // bits to remove for reverser
+            var rvb = 15 - mb;
+            for (i = 0; i < s; ++i) {
+                // ignore 0 lengths
+                if (cd[i]) {
+                    // num encoding both symbol and bits read
+                    var sv = (i << 4) | cd[i];
+                    // free bits
+                    var r_1 = mb - cd[i];
+                    // start value
+                    var v = le[cd[i] - 1]++ << r_1;
+                    // m is end value
+                    for (var m = v | ((1 << r_1) - 1); v <= m; ++v) {
+                        // every 16 bit value starting with the code yields the same result
+                        co[rev[v] >>> rvb] = sv;
+                    }
+                }
+            }
+        }
+        else {
+            co = new u16(s);
+            for (i = 0; i < s; ++i)
+                co[i] = rev[le[cd[i] - 1]++] >>> (15 - cd[i]);
+        }
+        return co;
+    });
+    // fixed length tree
+    var flt = new u8(288);
+    for (var i = 0; i < 144; ++i)
+        flt[i] = 8;
+    for (var i = 144; i < 256; ++i)
+        flt[i] = 9;
+    for (var i = 256; i < 280; ++i)
+        flt[i] = 7;
+    for (var i = 280; i < 288; ++i)
+        flt[i] = 8;
+    // fixed distance tree
+    var fdt = new u8(32);
+    for (var i = 0; i < 32; ++i)
+        fdt[i] = 5;
+    // fixed length map
+    var flm = /*#__PURE__*/ hMap(flt, 9, 0);
+    // fixed distance map
+    var fdm = /*#__PURE__*/ hMap(fdt, 5, 0);
+    // get end of byte
+    var shft = function (p) { return ((p / 8) >> 0) + (p & 7 && 1); };
+    // typed array slice - allows garbage collector to free original reference,
+    // while being more compatible than .slice
+    var slc = function (v, s, e) {
+        if (s == null || s < 0)
+            s = 0;
+        if (e == null || e > v.length)
+            e = v.length;
+        // can't use .constructor in case user-supplied
+        var n = new (v instanceof u16 ? u16 : v instanceof u32 ? u32 : u8)(e - s);
+        n.set(v.subarray(s, e));
+        return n;
+    };
+    // starting at p, write the minimum number of bits that can hold v to d
+    var wbits = function (d, p, v) {
+        v <<= p & 7;
+        var o = (p / 8) >> 0;
+        d[o] |= v;
+        d[o + 1] |= v >>> 8;
+    };
+    // starting at p, write the minimum number of bits (>8) that can hold v to d
+    var wbits16 = function (d, p, v) {
+        v <<= p & 7;
+        var o = (p / 8) >> 0;
+        d[o] |= v;
+        d[o + 1] |= v >>> 8;
+        d[o + 2] |= v >>> 16;
+    };
+    // creates code lengths from a frequency table
+    var hTree = function (d, mb) {
+        // Need extra info to make a tree
+        var t = [];
+        for (var i = 0; i < d.length; ++i) {
+            if (d[i])
+                t.push({ s: i, f: d[i] });
+        }
+        var s = t.length;
+        var t2 = t.slice();
+        if (!s)
+            return [new u8(0), 0];
+        if (s == 1) {
+            var v = new u8(t[0].s + 1);
+            v[t[0].s] = 1;
+            return [v, 1];
+        }
+        t.sort(function (a, b) { return a.f - b.f; });
+        // after i2 reaches last ind, will be stopped
+        // freq must be greater than largest possible number of symbols
+        t.push({ s: -1, f: 25001 });
+        var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2;
+        t[0] = { s: -1, f: l.f + r.f, l: l, r: r };
+        // efficient algorithm from UZIP.js
+        // i0 is lookbehind, i2 is lookahead - after processing two low-freq
+        // symbols that combined have high freq, will start processing i2 (high-freq,
+        // non-composite) symbols instead
+        // see https://reddit.com/r/photopea/comments/ikekht/uzipjs_questions/
+        while (i1 != s - 1) {
+            l = t[t[i0].f < t[i2].f ? i0++ : i2++];
+            r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++];
+            t[i1++] = { s: -1, f: l.f + r.f, l: l, r: r };
+        }
+        var maxSym = t2[0].s;
+        for (var i = 1; i < s; ++i) {
+            if (t2[i].s > maxSym)
+                maxSym = t2[i].s;
+        }
+        // code lengths
+        var tr = new u16(maxSym + 1);
+        // max bits in tree
+        var mbt = ln(t[i1 - 1], tr, 0);
+        if (mbt > mb) {
+            // more algorithms from UZIP.js
+            // TODO: find out how this code works (debt)
+            //  ind    debt
+            var i = 0, dt = 0;
+            //    left            cost
+            var lft = mbt - mb, cst = 1 << lft;
+            t2.sort(function (a, b) { return tr[b.s] - tr[a.s] || a.f - b.f; });
+            for (; i < s; ++i) {
+                var i2_1 = t2[i].s;
+                if (tr[i2_1] > mb) {
+                    dt += cst - (1 << (mbt - tr[i2_1]));
+                    tr[i2_1] = mb;
+                }
+                else
+                    break;
+            }
+            dt >>>= lft;
+            while (dt > 0) {
+                var i2_2 = t2[i].s;
+                if (tr[i2_2] < mb)
+                    dt -= 1 << (mb - tr[i2_2]++ - 1);
+                else
+                    ++i;
+            }
+            for (; i >= 0 && dt; --i) {
+                var i2_3 = t2[i].s;
+                if (tr[i2_3] == mb) {
+                    --tr[i2_3];
+                    ++dt;
+                }
+            }
+            mbt = mb;
+        }
+        return [new u8(tr), mbt];
+    };
+    // get the max length and assign length codes
+    var ln = function (n, l, d) {
+        return n.s == -1
+            ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1))
+            : (l[n.s] = d);
+    };
+    // length codes generation
+    var lc = function (c) {
+        var s = c.length;
+        // Note that the semicolon was intentional
+        while (s && !c[--s])
+            ;
+        var cl = new u16(++s);
+        //  ind      num         streak
+        var cli = 0, cln = c[0], cls = 1;
+        var w = function (v) { cl[cli++] = v; };
+        for (var i = 1; i <= s; ++i) {
+            if (c[i] == cln && i != s)
+                ++cls;
+            else {
+                if (!cln && cls > 2) {
+                    for (; cls > 138; cls -= 138)
+                        w(32754);
+                    if (cls > 2) {
+                        w(cls > 10 ? ((cls - 11) << 5) | 28690 : ((cls - 3) << 5) | 12305);
+                        cls = 0;
+                    }
+                }
+                else if (cls > 3) {
+                    w(cln), --cls;
+                    for (; cls > 6; cls -= 6)
+                        w(8304);
+                    if (cls > 2)
+                        w(((cls - 3) << 5) | 8208), cls = 0;
+                }
+                while (cls--)
+                    w(cln);
+                cls = 1;
+                cln = c[i];
+            }
+        }
+        return [cl.subarray(0, cli), s];
+    };
+    // calculate the length of output from tree, code lengths
+    var clen = function (cf, cl) {
+        var l = 0;
+        for (var i = 0; i < cl.length; ++i)
+            l += cf[i] * cl[i];
+        return l;
+    };
+    // writes a fixed block
+    // returns the new bit pos
+    var wfblk = function (out, pos, dat) {
+        // no need to write 00 as type: TypedArray defaults to 0
+        var s = dat.length;
+        var o = shft(pos + 2);
+        out[o] = s & 255;
+        out[o + 1] = s >>> 8;
+        out[o + 2] = out[o] ^ 255;
+        out[o + 3] = out[o + 1] ^ 255;
+        for (var i = 0; i < s; ++i)
+            out[o + i + 4] = dat[i];
+        return (o + 4 + s) * 8;
+    };
+    // writes a block
+    var wblk = function (dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
+        wbits(out, p++, final);
+        ++lf[256];
+        var _a = hTree(lf, 15), dlt = _a[0], mlb = _a[1];
+        var _b = hTree(df, 15), ddt = _b[0], mdb = _b[1];
+        var _c = lc(dlt), lclt = _c[0], nlc = _c[1];
+        var _d = lc(ddt), lcdt = _d[0], ndc = _d[1];
+        var lcfreq = new u16(19);
+        for (var i = 0; i < lclt.length; ++i)
+            lcfreq[lclt[i] & 31]++;
+        for (var i = 0; i < lcdt.length; ++i)
+            lcfreq[lcdt[i] & 31]++;
+        var _e = hTree(lcfreq, 7), lct = _e[0], mlcb = _e[1];
+        var nlcc = 19;
+        for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
+            ;
+        var flen = (bl + 5) << 3;
+        var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
+        var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + (2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18]);
+        if (flen <= ftlen && flen <= dtlen)
+            return wfblk(out, p, dat.subarray(bs, bs + bl));
+        var lm, ll, dm, dl;
+        wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
+        if (dtlen < ftlen) {
+            lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;
+            var llm = hMap(lct, mlcb, 0);
+            wbits(out, p, nlc - 257);
+            wbits(out, p + 5, ndc - 1);
+            wbits(out, p + 10, nlcc - 4);
+            p += 14;
+            for (var i = 0; i < nlcc; ++i)
+                wbits(out, p + 3 * i, lct[clim[i]]);
+            p += 3 * nlcc;
+            var lcts = [lclt, lcdt];
+            for (var it = 0; it < 2; ++it) {
+                var clct = lcts[it];
+                for (var i = 0; i < clct.length; ++i) {
+                    var len = clct[i] & 31;
+                    wbits(out, p, llm[len]), p += lct[len];
+                    if (len > 15)
+                        wbits(out, p, (clct[i] >>> 5) & 127), p += clct[i] >>> 12;
+                }
+            }
+        }
+        else {
+            lm = flm, ll = flt, dm = fdm, dl = fdt;
+        }
+        for (var i = 0; i < li; ++i) {
+            if (syms[i] > 255) {
+                var len = (syms[i] >>> 18) & 31;
+                wbits16(out, p, lm[len + 257]), p += ll[len + 257];
+                if (len > 7)
+                    wbits(out, p, (syms[i] >>> 23) & 31), p += fleb[len];
+                var dst = syms[i] & 31;
+                wbits16(out, p, dm[dst]), p += dl[dst];
+                if (dst > 3)
+                    wbits16(out, p, (syms[i] >>> 5) & 8191), p += fdeb[dst];
+            }
+            else {
+                wbits16(out, p, lm[syms[i]]), p += ll[syms[i]];
+            }
+        }
+        wbits16(out, p, lm[256]);
+        return p + ll[256];
+    };
+    // deflate options (nice << 13) | chain
+    var deo = /*#__PURE__*/ new u32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
+    // empty
+    var et = /*#__PURE__*/ new u8(0);
+    // compresses data into a raw DEFLATE buffer
+    var dflt = function (dat, lvl, plvl, pre, post, lst) {
+        var s = dat.length;
+        var o = new u8(pre + s + 5 * (1 + Math.floor(s / 7000)) + post);
+        // writing to this writes to the output buffer
+        var w = o.subarray(pre, o.length - post);
+        var pos = 0;
+        if (!lvl || s < 8) {
+            for (var i = 0; i <= s; i += 65535) {
+                // end
+                var e = i + 65535;
+                if (e < s) {
+                    // write full block
+                    pos = wfblk(w, pos, dat.subarray(i, e));
+                }
+                else {
+                    // write final block
+                    w[i] = lst;
+                    pos = wfblk(w, pos, dat.subarray(i, s));
+                }
+            }
+        }
+        else {
+            var opt = deo[lvl - 1];
+            var n = opt >>> 13, c = opt & 8191;
+            var msk_1 = (1 << plvl) - 1;
+            //    prev 2-byte val map    curr 2-byte val map
+            var prev = new u16(32768), head = new u16(msk_1 + 1);
+            var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
+            var hsh = function (i) { return (dat[i] ^ (dat[i + 1] << bs1_1) ^ (dat[i + 2] << bs2_1)) & msk_1; };
+            // 24576 is an arbitrary number of maximum symbols per block
+            // 424 buffer for last block
+            var syms = new u32(25000);
+            // length/literal freq   distance freq
+            var lf = new u16(288), df = new u16(32);
+            //  l/lcnt  exbits  index  l/lind  waitdx  bitpos
+            var lc_1 = 0, eb = 0, i = 0, li = 0, wi = 0, bs = 0;
+            for (; i < s; ++i) {
+                // hash value
+                var hv = hsh(i);
+                // index mod 32768
+                var imod = i & 32767;
+                // previous index with this value
+                var pimod = head[hv];
+                prev[imod] = pimod;
+                head[hv] = imod;
+                // We always should modify head and prev, but only add symbols if
+                // this data is not yet processed ("wait" for wait index)
+                if (wi <= i) {
+                    // bytes remaining
+                    var rem = s - i;
+                    if ((lc_1 > 7000 || li > 24576) && rem > 423) {
+                        pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);
+                        li = lc_1 = eb = 0, bs = i;
+                        for (var j = 0; j < 286; ++j)
+                            lf[j] = 0;
+                        for (var j = 0; j < 30; ++j)
+                            df[j] = 0;
+                    }
+                    //  len    dist   chain
+                    var l = 2, d = 0, ch_1 = c, dif = (imod - pimod) & 32767;
+                    if (rem > 2 && hv == hsh(i - dif)) {
+                        var maxn = Math.min(n, rem) - 1;
+                        var maxd = Math.min(32767, i);
+                        // max possible length
+                        // not capped at dif because decompressors implement "rolling" index population
+                        var ml = Math.min(258, rem);
+                        while (dif <= maxd && --ch_1 && imod != pimod) {
+                            if (dat[i + l] == dat[i + l - dif]) {
+                                var nl = 0;
+                                for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl)
+                                    ;
+                                if (nl > l) {
+                                    l = nl, d = dif;
+                                    // break out early when we reach "nice" (we are satisfied enough)
+                                    if (nl > maxn)
+                                        break;
+                                    // now, find the rarest 2-byte sequence within this
+                                    // length of literals and search for that instead.
+                                    // Much faster than just using the start
+                                    var mmd = Math.min(dif, nl - 2);
+                                    var md = 0;
+                                    for (var j = 0; j < mmd; ++j) {
+                                        var ti = (i - dif + j + 32768) & 32767;
+                                        var pti = prev[ti];
+                                        var cd = (ti - pti + 32768) & 32767;
+                                        if (cd > md)
+                                            md = cd, pimod = ti;
+                                    }
+                                }
+                            }
+                            // check the previous match
+                            imod = pimod, pimod = prev[imod];
+                            dif += (imod - pimod + 32768) & 32767;
+                        }
+                    }
+                    // d will be nonzero only when a match was found
+                    if (d) {
+                        // store both dist and len data in one Uint32
+                        // Make sure this is recognized as a len/dist with 28th bit (2^28)
+                        syms[li++] = 268435456 | (revfl[l] << 18) | revfd[d];
+                        var lin = revfl[l] & 31, din = revfd[d] & 31;
+                        eb += fleb[lin] + fdeb[din];
+                        ++lf[257 + lin];
+                        ++df[din];
+                        wi = i + l;
+                        ++lc_1;
+                    }
+                    else {
+                        syms[li++] = dat[i];
+                        ++lf[dat[i]];
+                    }
+                }
+            }
+            pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);
+            // this is the easiest way to avoid needing to maintain state
+            if (!lst)
+                pos = wfblk(w, pos, et);
+        }
+        return slc(o, 0, pre + shft(pos) + post);
+    };
+    // Alder32
+    var adler = function () {
+        var a = 1, b = 0;
+        return {
+            p: function (d) {
+                // closures have awful performance
+                var n = a, m = b;
+                var l = d.length;
+                for (var i = 0; i != l;) {
+                    var e = Math.min(i + 5552, l);
+                    for (; i < e; ++i)
+                        n += d[i], m += n;
+                    n %= 65521, m %= 65521;
+                }
+                a = n, b = m;
+            },
+            d: function () { return ((a >>> 8) << 16 | (b & 255) << 8 | (b >>> 8)) + ((a & 255) << 23) * 2; }
+        };
+    };
+    // deflate with opts
+    var dopt = function (dat, opt, pre, post, st) {
+        return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : (12 + opt.mem), pre, post, !st);
+    };
+    // write bytes
+    var wbytes = function (d, b, v) {
+        for (; v; ++b)
+            d[b] = v, v >>>= 8;
+    };
+    // zlib header
+    var zlh = function (c, o) {
+        var lv = o.level, fl = lv == 0 ? 0 : lv < 6 ? 1 : lv == 9 ? 3 : 2;
+        c[0] = 120, c[1] = (fl << 6) | (fl ? (32 - 2 * fl) : 1);
+    };
+    /**
+     * Compress data with Zlib
+     * @param data The data to compress
+     * @param opts The compression options
+     * @returns The zlib-compressed version of the data
+     */
+    function zlibSync(data, opts) {
+        if (opts === void 0) { opts = {}; }
+        var a = adler();
+        a.p(data);
+        var d = dopt(data, opts, 2, 4);
+        return zlh(d, opts), wbytes(d, d.length - 4, a.d()), d;
+    }
+    /**
+     * Converts a string into a Uint8Array for use with compression/decompression methods
+     * @param str The string to encode
+     * @param latin1 Whether or not to interpret the data as Latin-1. This should
+     *               not need to be true unless decoding a binary string.
+     * @returns The string encoded in UTF-8/Latin-1 binary
+     */
+    function strToU8(str, latin1) {
+        var l = str.length;
+        if (!latin1 && typeof TextEncoder != 'undefined')
+            return new TextEncoder().encode(str);
+        var ar = new u8(str.length + (str.length >>> 1));
+        var ai = 0;
+        var w = function (v) { ar[ai++] = v; };
+        for (var i = 0; i < l; ++i) {
+            if (ai + 5 > ar.length) {
+                var n = new u8(ai + 8 + ((l - i) << 1));
+                n.set(ar);
+                ar = n;
+            }
+            var c = str.charCodeAt(i);
+            if (c < 128 || latin1)
+                w(c);
+            else if (c < 2048)
+                w(192 | (c >>> 6)), w(128 | (c & 63));
+            else if (c > 55295 && c < 57344)
+                c = 65536 + (c & 1023 << 10) | (str.charCodeAt(++i) & 1023),
+                    w(240 | (c >>> 18)), w(128 | ((c >>> 12) & 63)), w(128 | ((c >>> 6) & 63)), w(128 | (c & 63));
+            else
+                w(224 | (c >>> 12)), w(128 | ((c >>> 6) & 63)), w(128 | (c & 63));
+        }
+        return slc(ar, 0, ai);
+    }
+    /**
+     * Converts a Uint8Array to a string
+     * @param dat The data to decode to string
+     * @param latin1 Whether or not to interpret the data as Latin-1. This should
+     *               not need to be true unless encoding to binary string.
+     * @returns The original UTF-8/Latin-1 string
+     */
+    function strFromU8(dat, latin1) {
+        var r = '';
+        if (!latin1 && typeof TextDecoder != 'undefined')
+            return new TextDecoder().decode(dat);
+        for (var i = 0; i < dat.length;) {
+            var c = dat[i++];
+            if (c < 128 || latin1)
+                r += String.fromCharCode(c);
+            else if (c < 224)
+                r += String.fromCharCode((c & 31) << 6 | (dat[i++] & 63));
+            else if (c < 240)
+                r += String.fromCharCode((c & 15) << 12 | (dat[i++] & 63) << 6 | (dat[i++] & 63));
+            else
+                c = ((c & 15) << 18 | (dat[i++] & 63) << 12 | (dat[i++] & 63) << 6 | (dat[i++] & 63)) - 65536,
+                    r += String.fromCharCode(55296 | (c >> 10), 56320 | (c & 1023));
+        }
+        return r;
+    }
+
+    var MARK = 'v1';
+
+    var pack = function (event) {
+        var _e = __assign(__assign({}, event), { v: MARK });
+        return strFromU8(zlibSync(strToU8(JSON.stringify(_e))), true);
+    };
+
+    exports.pack = pack;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+    return exports;
+
+}({}));