CCapture.all.min.js

"use strict";

function download(t, e, i) {
    function n(t) {
        var e = t.split(/[:;,]/),
            i = e[1],
            n = "base64" == e[2] ? atob : decodeURIComponent,
            r = n(e.pop()),
            o = r.length,
            a = 0,
            s = new Uint8Array(o);
        for (a; a < o; ++a) s[a] = r.charCodeAt(a);
        return new m([s], {
            type: i
        })
    }

    function r(t, e) {
        if ("download" in c) return c.href = t, c.setAttribute("download", g), c.innerHTML = "downloading...", c.style.display = "none", l.body.appendChild(c), setTimeout(function() {
            c.click(), l.body.removeChild(c), e === !0 && setTimeout(function() {
                h.URL.revokeObjectURL(c.href)
            }, 250)
        }, 66), !0;
        var i = l.createElement("iframe");
        l.body.appendChild(i), e || (t = "data:" + t.replace(/^data:([\w\/\-\+]+)/, f)), i.src = t, setTimeout(function() {
            l.body.removeChild(i)
        }, 333)
    }
    var o, a, s, h = window,
        f = "application/octet-stream",
        u = i || f,
        d = t,
        l = document,
        c = l.createElement("a"),
        p = function(t) {
            return String(t)
        },
        m = h.Blob || h.MozBlob || h.WebKitBlob || p,
        w = h.MSBlobBuilder || h.WebKitBlobBuilder || h.BlobBuilder,
        g = e || "download";
    if ("true" === String(this) && (d = [d, u], u = d[0], d = d[1]), String(d).match(/^data\:[\w+\-]+\/[\w+\-]+[,;]/)) return navigator.msSaveBlob ? navigator.msSaveBlob(n(d), g) : r(d);
    try {
        o = d instanceof m ? d : new m([d], {
            type: u
        })
    } catch (t) {
        w && (a = new w, a.append([d]), o = a.getBlob(u))
    }
    if (navigator.msSaveBlob) return navigator.msSaveBlob(o, g);
    if (h.URL) r(h.URL.createObjectURL(o), !0);
    else {
        if ("string" == typeof o || o.constructor === p) try {
            return r("data:" + u + ";base64," + h.btoa(o))
        } catch (t) {
            return r("data:" + u + "," + encodeURIComponent(o))
        }
        s = new FileReader, s.onload = function(t) {
            r(this.result)
        }, s.readAsDataURL(o)
    }
    return !0
}! function() {
    var t = function(t) {
        this.data = new Uint8Array(t), this.pos = 0
    };
    t.prototype.seek = function(t) {
        this.pos = t
    }, t.prototype.writeBytes = function(t) {
        for (var e = 0; e < t.length; e++) this.data[this.pos++] = t[e]
    }, t.prototype.writeByte = function(t) {
        this.data[this.pos++] = t
    }, t.prototype.writeU8 = t.prototype.writeByte, t.prototype.writeU16BE = function(t) {
        this.data[this.pos++] = t >> 8, this.data[this.pos++] = t
    }, t.prototype.writeDoubleBE = function(t) {
        for (var e = new Uint8Array(new Float64Array([t]).buffer), i = e.length - 1; i >= 0; i--) this.writeByte(e[i])
    }, t.prototype.writeFloatBE = function(t) {
        for (var e = new Uint8Array(new Float32Array([t]).buffer), i = e.length - 1; i >= 0; i--) this.writeByte(e[i])
    }, t.prototype.writeString = function(t) {
        for (var e = 0; e < t.length; e++) this.data[this.pos++] = t.charCodeAt(e)
    }, t.prototype.writeEBMLVarIntWidth = function(t, e) {
        switch (e) {
            case 1:
                this.writeU8(128 | t);
                break;
            case 2:
                this.writeU8(64 | t >> 8), this.writeU8(t);
                break;
            case 3:
                this.writeU8(32 | t >> 16), this.writeU8(t >> 8), this.writeU8(t);
                break;
            case 4:
                this.writeU8(16 | t >> 24), this.writeU8(t >> 16), this.writeU8(t >> 8), this.writeU8(t);
                break;
            case 5:
                this.writeU8(8 | t / 4294967296 & 7), this.writeU8(t >> 24), this.writeU8(t >> 16), this.writeU8(t >> 8), this.writeU8(t);
                break;
            default:
                throw new RuntimeException("Bad EBML VINT size " + e)
        }
    }, t.prototype.measureEBMLVarInt = function(t) {
        if (t < 127) return 1;
        if (t < 16383) return 2;
        if (t < 2097151) return 3;
        if (t < 268435455) return 4;
        if (t < 34359738367) return 5;
        throw new RuntimeException("EBML VINT size not supported " + t)
    }, t.prototype.writeEBMLVarInt = function(t) {
        this.writeEBMLVarIntWidth(t, this.measureEBMLVarInt(t))
    }, t.prototype.writeUnsignedIntBE = function(t, e) {
        switch (void 0 === e && (e = this.measureUnsignedInt(t)), e) {
            case 5:
                this.writeU8(Math.floor(t / 4294967296));
            case 4:
                this.writeU8(t >> 24);
            case 3:
                this.writeU8(t >> 16);
            case 2:
                this.writeU8(t >> 8);
            case 1:
                this.writeU8(t);
                break;
            default:
                throw new RuntimeException("Bad UINT size " + e)
        }
    }, t.prototype.measureUnsignedInt = function(t) {
        return t < 256 ? 1 : t < 65536 ? 2 : t < 1 << 24 ? 3 : t < 4294967296 ? 4 : 5
    }, t.prototype.getAsDataArray = function() {
        if (this.pos < this.data.byteLength) return this.data.subarray(0, this.pos);
        if (this.pos == this.data.byteLength) return this.data;
        throw "ArrayBufferDataStream's pos lies beyond end of buffer"
    }, "undefined" != typeof module && "undefined" != typeof module.exports ? module.exports = t : window.ArrayBufferDataStream = t
}(),
function() {
    var t = function(t) {
        return function(e) {
            function i(t) {
                return new Promise(function(e, i) {
                    var n = new FileReader;
                    n.addEventListener("loadend", function() {
                        e(n.result)
                    }), n.readAsArrayBuffer(t)
                })
            }

            function n(t) {
                return new Promise(function(e, n) {
                    e(t instanceof Uint8Array ? t : t instanceof ArrayBuffer || ArrayBuffer.isView(t) ? new Uint8Array(t) : t instanceof Blob ? i(t).then(function(t) {
                        return new Uint8Array(t)
                    }) : i(new Blob([t])).then(function(t) {
                        return new Uint8Array(t)
                    }))
                })
            }

            function r(t) {
                var e = t.byteLength || t.length || t.size;
                if (!Number.isInteger(e)) throw "Failed to determine size of element";
                return e
            }
            var o = [],
                a = Promise.resolve(),
                s = null,
                h = null;
            "undefined" != typeof FileWriter && e instanceof FileWriter ? s = e : t && e && (h = e), this.pos = 0, this.length = 0, this.seek = function(t) {
                if (t < 0) throw "Offset may not be negative";
                if (isNaN(t)) throw "Offset may not be NaN";
                if (t > this.length) throw "Seeking beyond the end of file is not allowed";
                this.pos = t
            }, this.write = function(e) {
                var i = {
                        offset: this.pos,
                        data: e,
                        length: r(e)
                    },
                    f = i.offset >= this.length;
                this.pos += i.length, this.length = Math.max(this.length, this.pos), a = a.then(function() {
                    if (h) return new Promise(function(e, r) {
                        n(i.data).then(function(n) {
                            var r = 0,
                                o = Buffer.from(n.buffer),
                                a = function(n, o, s) {
                                    r += o, r >= s.length ? e() : t.write(h, s, r, s.length - r, i.offset + r, a)
                                };
                            t.write(h, o, 0, o.length, i.offset, a)
                        })
                    });
                    if (s) return new Promise(function(t, e) {
                        s.onwriteend = t, s.seek(i.offset), s.write(new Blob([i.data]))
                    });
                    if (!f)
                        for (var e = 0; e < o.length; e++) {
                            var r = o[e];
                            if (!(i.offset + i.length <= r.offset || i.offset >= r.offset + r.length)) {
                                if (i.offset < r.offset || i.offset + i.length > r.offset + r.length) throw new Error("Overwrite crosses blob boundaries");
                                return i.offset == r.offset && i.length == r.length ? void(r.data = i.data) : n(r.data).then(function(t) {
                                    return r.data = t, n(i.data)
                                }).then(function(t) {
                                    i.data = t, r.data.set(i.data, i.offset - r.offset)
                                })
                            }
                        }
                    o.push(i)
                })
            }, this.complete = function(t) {
                return a = h || s ? a.then(function() {
                    return null
                }) : a.then(function() {
                    for (var e = [], i = 0; i < o.length; i++) e.push(o[i].data);
                    return new Blob(e, {
                        mimeType: t
                    })
                })
            }
        }
    };
    "undefined" != typeof module && "undefined" != typeof module.exports ? module.exports = t(require("fs")) : window.BlobBuffer = t(null)
}(),
function() {
    var t = function(t, e) {
        function i(t, e) {
            var i = {};
            return [t, e].forEach(function(t) {
                for (var e in t) Object.prototype.hasOwnProperty.call(t, e) && (i[e] = t[e])
            }), i
        }

        function n(t) {
            return !("string" != typeof t || !t.match(/^data:image\/webp;base64,/i)) && window.atob(t.substring("data:image/webp;base64,".length))
        }

        function r(t, e) {
            var i = t.toDataURL("image/webp", {
                quality: e
            });
            return n(i)
        }

        function o(t) {
            var e = t.indexOf("VP8 ");
            if (e == -1) throw "Failed to identify beginning of keyframe in WebP image";
            return e += "VP8 ".length + 4, t.substring(e)
        }

        function a(t) {
            this.value = t
        }

        function s(t) {
            this.value = t
        }

        function h(t, e, i) {
            if (Array.isArray(i))
                for (var n = 0; n < i.length; n++) h(t, e, i[n]);
            else if ("string" == typeof i) t.writeString(i);
            else if (i instanceof Uint8Array) t.writeBytes(i);
            else {
                if (!i.id) throw "Bad EBML datatype " + typeof i.data;
                if (i.offset = t.pos + e, t.writeUnsignedIntBE(i.id), Array.isArray(i.data)) {
                    var r, o, f;
                    i.size === -1 ? t.writeByte(255) : (r = t.pos, t.writeBytes([0, 0, 0, 0])), o = t.pos, i.dataOffset = o + e, h(t, e, i.data), i.size !== -1 && (f = t.pos, i.size = f - o, t.seek(r), t.writeEBMLVarIntWidth(i.size, 4), t.seek(f))
                } else if ("string" == typeof i.data) t.writeEBMLVarInt(i.data.length), i.dataOffset = t.pos + e, t.writeString(i.data);
                else if ("number" == typeof i.data) i.size || (i.size = t.measureUnsignedInt(i.data)), t.writeEBMLVarInt(i.size), i.dataOffset = t.pos + e, t.writeUnsignedIntBE(i.data, i.size);
                else if (i.data instanceof s) t.writeEBMLVarInt(8), i.dataOffset = t.pos + e, t.writeDoubleBE(i.data.value);
                else if (i.data instanceof a) t.writeEBMLVarInt(4), i.dataOffset = t.pos + e, t.writeFloatBE(i.data.value);
                else {
                    if (!(i.data instanceof Uint8Array)) throw "Bad EBML datatype " + typeof i.data;
                    t.writeEBMLVarInt(i.data.byteLength), i.dataOffset = t.pos + e, t.writeBytes(i.data)
                }
            }
        }
        return function(n) {
            function a(t) {
                return t - B.dataOffset
            }

            function f() {
                var t = {
                        id: 21420,
                        size: 5,
                        data: 0
                    },
                    e = {
                        id: 290298740,
                        data: []
                    };
                for (var i in D) {
                    var n = D[i];
                    n.positionEBML = Object.create(t), e.data.push({
                        id: 19899,
                        data: [{
                            id: 21419,
                            data: n.id
                        }, n.positionEBML]
                    })
                }
                return e
            }

            function u() {
                x = f();
                var e = {
                        id: 440786851,
                        data: [{
                            id: 17030,
                            data: 1
                        }, {
                            id: 17143,
                            data: 1
                        }, {
                            id: 17138,
                            data: 4
                        }, {
                            id: 17139,
                            data: 8
                        }, {
                            id: 17026,
                            data: "webm"
                        }, {
                            id: 17031,
                            data: 2
                        }, {
                            id: 17029,
                            data: 2
                        }]
                    },
                    i = {
                        id: 357149030,
                        data: [{
                            id: 2807729,
                            data: 1e6
                        }, {
                            id: 19840,
                            data: "webm-writer-js"
                        }, {
                            id: 22337,
                            data: "webm-writer-js"
                        }, M]
                    },
                    n = {
                        id: 374648427,
                        data: [{
                            id: 174,
                            data: [{
                                id: 215,
                                data: A
                            }, {
                                id: 29637,
                                data: A
                            }, {
                                id: 156,
                                data: 0
                            }, {
                                id: 2274716,
                                data: "und"
                            }, {
                                id: 134,
                                data: "V_VP8"
                            }, {
                                id: 2459272,
                                data: "VP8"
                            }, {
                                id: 131,
                                data: 1
                            }, {
                                id: 224,
                                data: [{
                                    id: 176,
                                    data: b
                                }, {
                                    id: 186,
                                    data: k
                                }]
                            }]
                        }]
                    };
                B = {
                    id: 408125543,
                    size: -1,
                    data: [x, i, n]
                };
                var r = new t(256);
                h(r, S.pos, [e, B]), S.write(r.getAsDataArray()), D.SegmentInfo.positionEBML.data = a(i.offset), D.Tracks.positionEBML.data = a(n.offset)
            }

            function d(e) {
                var i = new t(4);
                if (!(e.trackNumber > 0 && e.trackNumber < 127)) throw "TrackNumber must be > 0 and < 127";
                return i.writeEBMLVarInt(e.trackNumber), i.writeU16BE(e.timecode), i.writeByte(128), {
                    id: 163,
                    data: [i.getAsDataArray(), e.frame]
                }
            }

            function l(t) {
                return {
                    id: 524531317,
                    data: [{
                        id: 231,
                        data: Math.round(t.timecode)
                    }]
                }
            }

            function c(t, e, i) {
                _.push({
                    id: 187,
                    data: [{
                        id: 179,
                        data: e
                    }, {
                        id: 183,
                        data: [{
                            id: 247,
                            data: t
                        }, {
                            id: 241,
                            data: a(i)
                        }]
                    }]
                })
            }

            function p() {
                var e = {
                        id: 475249515,
                        data: _
                    },
                    i = new t(16 + 32 * _.length);
                h(i, S.pos, e), S.write(i.getAsDataArray()), D.Cues.positionEBML.data = a(e.offset)
            }

            function m() {
                if (0 != T.length) {
                    for (var e = 0, i = 0; i < T.length; i++) e += T[i].frame.length;
                    for (var n = new t(e + 32 * T.length), r = l({
                            timecode: Math.round(U)
                        }), i = 0; i < T.length; i++) r.data.push(d(T[i]));
                    h(n, S.pos, r), S.write(n.getAsDataArray()), c(A, Math.round(U), r.offset), T = [], U += F, F = 0
                }
            }

            function w() {
                if (!n.frameDuration) {
                    if (!n.frameRate) throw "Missing required frameDuration or frameRate setting";
                    n.frameDuration = 1e3 / n.frameRate
                }
            }

            function g(t) {
                t.trackNumber = A, t.timecode = Math.round(F), T.push(t), F += t.duration, F >= E && m()
            }

            function y() {
                var e = new t(x.size),
                    i = S.pos;
                h(e, x.dataOffset, x.data), S.seek(x.dataOffset), S.write(e.getAsDataArray()), S.seek(i)
            }

            function v() {
                var e = new t(8),
                    i = S.pos;
                e.writeDoubleBE(U), S.seek(M.dataOffset), S.write(e.getAsDataArray()), S.seek(i)
            }
            var b, k, B, x, E = 5e3,
                A = 1,
                L = !1,
                T = [],
                U = 0,
                F = 0,
                I = {
                    quality: .95,
                    fileWriter: null,
                    fd: null,
                    frameDuration: null,
                    frameRate: null
                },
                D = {
                    Cues: {
                        id: new Uint8Array([28, 83, 187, 107]),
                        positionEBML: null
                    },
                    SegmentInfo: {
                        id: new Uint8Array([21, 73, 169, 102]),
                        positionEBML: null
                    },
                    Tracks: {
                        id: new Uint8Array([22, 84, 174, 107]),
                        positionEBML: null
                    }
                },
                M = {
                    id: 17545,
                    data: new s(0)
                },
                _ = [],
                S = new e(n.fileWriter || n.fd);
            this.addFrame = function(t) {
                if (L) {
                    if (t.width != b || t.height != k) throw "Frame size differs from previous frames"
                } else b = t.width, k = t.height, u(), L = !0;
                var e = r(t, {
                    quality: n.quality
                });
                if (!e) throw "Couldn't decode WebP frame, does the browser support WebP?";
                g({
                    frame: o(e),
                    duration: n.frameDuration
                })
            }, this.complete = function() {
                return m(), p(), y(), v(), S.complete("video/webm")
            }, this.getWrittenSize = function() {
                return S.length
            }, n = i(I, n || {}), w()
        }
    };
    "undefined" != typeof module && "undefined" != typeof module.exports ? module.exports = t(require("./ArrayBufferDataStream"), require("./BlobBuffer")) : window.WebMWriter = t(ArrayBufferDataStream, BlobBuffer)
}(),
function() {
    function t(t) {
        var e, i = new Uint8Array(t);
        for (e = 0; e < t; e += 1) i[e] = 0;
        return i
    }

    function e(e, i, n, r) {
        var o = i + n,
            a = t((parseInt(o / r) + 1) * r);
        return a.set(e), a
    }

    function i(t, e, i) {
        return t = t.toString(i || 8), "000000000000".substr(t.length + 12 - e) + t
    }

    function n(e, i, n) {
        var r, o;
        for (i = i || t(e.length), n = n || 0, r = 0, o = e.length; r < o; r += 1) i[n] = e.charCodeAt(r), n += 1;
        return i
    }

    function r(t) {
        function e(t) {
            return o[t >> 18 & 63] + o[t >> 12 & 63] + o[t >> 6 & 63] + o[63 & t]
        }
        var i, n, r, a = t.length % 3,
            s = "";
        for (i = 0, r = t.length - a; i < r; i += 3) n = (t[i] << 16) + (t[i + 1] << 8) + t[i + 2], s += e(n);
        switch (s.length % 4) {
            case 1:
                s += "=";
                break;
            case 2:
                s += "=="
        }
        return s
    }
    var o = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "+", "/"];
    window.utils = {}, window.utils.clean = t, window.utils.pad = i, window.utils.extend = e, window.utils.stringToUint8 = n, window.utils.uint8ToBase64 = r
}(),
function() {
    function t(t, n) {
        var r = i.clean(512),
            o = 0;
        return e.forEach(function(e) {
            var i, n, a = t[e.field] || "";
            for (i = 0, n = a.length; i < n; i += 1) r[o] = a.charCodeAt(i), o += 1;
            o += e.length - i
        }), "function" == typeof n ? n(r, o) : r
    }
    var e, i = window.utils;
    e = [{
        field: "fileName",
        length: 100
    }, {
        field: "fileMode",
        length: 8
    }, {
        field: "uid",
        length: 8
    }, {
        field: "gid",
        length: 8
    }, {
        field: "fileSize",
        length: 12
    }, {
        field: "mtime",
        length: 12
    }, {
        field: "checksum",
        length: 8
    }, {
        field: "type",
        length: 1
    }, {
        field: "linkName",
        length: 100
    }, {
        field: "ustar",
        length: 8
    }, {
        field: "owner",
        length: 32
    }, {
        field: "group",
        length: 32
    }, {
        field: "majorNumber",
        length: 8
    }, {
        field: "minorNumber",
        length: 8
    }, {
        field: "filenamePrefix",
        length: 155
    }, {
        field: "padding",
        length: 12
    }], window.header = {}, window.header.structure = e, window.header.format = t
}(),
function() {
    function t(t) {
        this.written = 0, e = (t || 20) * r, this.out = n.clean(e), this.blocks = [], this.length = 0
    }
    var e, i = window.header,
        n = window.utils,
        r = 512;
    t.prototype.append = function(t, e, o, a) {
        var s, h, f, u, d, l, c;
        if ("string" == typeof e) e = n.stringToUint8(e);
        else if (e.constructor !== Uint8Array.prototype.constructor) throw "Invalid input type. You gave me: " + e.constructor.toString().match(/function\s*([$A-Za-z_][0-9A-Za-z_]*)\s*\(/)[1];
        "function" == typeof o && (a = o, o = {}), o = o || {}, f = o.mode || 4095 & parseInt("777", 8), u = o.mtime || Math.floor(+new Date / 1e3), d = o.uid || 0, l = o.gid || 0, s = {
            fileName: t,
            fileMode: n.pad(f, 7),
            uid: n.pad(d, 7),
            gid: n.pad(l, 7),
            fileSize: n.pad(e.length, 11),
            mtime: n.pad(u, 11),
            checksum: "        ",
            type: "0",
            ustar: "ustar  ",
            owner: o.owner || "",
            group: o.group || ""
        }, h = 0, Object.keys(s).forEach(function(t) {
            var e, i, n = s[t];
            for (e = 0, i = n.length; e < i; e += 1) h += n.charCodeAt(e)
        }), s.checksum = n.pad(h, 6) + "\0 ", c = i.format(s);
        var p = Math.ceil(c.length / r) * r,
            m = Math.ceil(e.length / r) * r;
        this.blocks.push({
            header: c,
            input: e,
            headerLength: p,
            inputLength: m
        })
    }, t.prototype.save = function() {
        var t = [],
            e = [],
            i = 0,
            n = Math.pow(2, 20),
            o = [];
        return this.blocks.forEach(function(t) {
            i + t.headerLength + t.inputLength > n && (e.push({
                blocks: o,
                length: i
            }), o = [], i = 0), o.push(t), i += t.headerLength + t.inputLength
        }), e.push({
            blocks: o,
            length: i
        }), e.forEach(function(e) {
            var i = new Uint8Array(e.length),
                n = 0;
            e.blocks.forEach(function(t) {
                i.set(t.header, n), n += t.headerLength, i.set(t.input, n), n += t.inputLength
            }), t.push(i)
        }), t.push(new Uint8Array(2 * r)), new Blob(t, {
            type: "octet/stream"
        })
    }, t.prototype.clear = function() {
        this.written = 0, this.out = n.clean(e)
    }, window.Tar = t
}(),
function(t) {
    function e(t, i) {
        if ({}.hasOwnProperty.call(e.cache, t)) return e.cache[t];
        var n = e.resolve(t);
        if (!n) throw new Error("Failed to resolve module " + t);
        var r = {
            id: t,
            require: e,
            filename: t,
            exports: {},
            loaded: !1,
            parent: i,
            children: []
        };
        i && i.children.push(r);
        var o = t.slice(0, t.lastIndexOf("/") + 1);
        return e.cache[t] = r.exports, n.call(r.exports, r, r.exports, o, t), r.loaded = !0, e.cache[t] = r.exports
    }
    e.modules = {}, e.cache = {}, e.resolve = function(t) {
        return {}.hasOwnProperty.call(e.modules, t) ? e.modules[t] : void 0
    }, e.define = function(t, i) {
        e.modules[t] = i
    };
    var i = function(e) {
        return e = "/", {
            title: "browser",
            version: "v0.10.26",
            browser: !0,
            env: {},
            argv: [],
            nextTick: t.setImmediate || function(t) {
                setTimeout(t, 0)
            },
            cwd: function() {
                return e
            },
            chdir: function(t) {
                e = t
            }
        }
    }();
    e.define("/gif.coffee", function(t, i, n, r) {
        function o(t, e) {
            return {}.hasOwnProperty.call(t, e)
        }

        function a(t, e) {
            for (var i = 0, n = e.length; i < n; ++i)
                if (i in e && e[i] === t) return !0;
            return !1
        }

        function s(t, e) {
            function i() {
                this.constructor = t
            }
            for (var n in e) o(e, n) && (t[n] = e[n]);
            return i.prototype = e.prototype, t.prototype = new i, t.__super__ = e.prototype, t
        }
        var h, f, u, d, l;
        u = e("events", t).EventEmitter, h = e("/browser.coffee", t), l = function(t) {
            function e(t) {
                var e, i;
                this.running = !1, this.options = {}, this.frames = [], this.freeWorkers = [], this.activeWorkers = [], this.setOptions(t);
                for (e in f) i = f[e], null != this.options[e] ? this.options[e] : this.options[e] = i
            }
            return s(e, t), f = {
                workerScript: "gif.worker.js",
                workers: 2,
                repeat: 0,
                background: "#fff",
                quality: 10,
                width: null,
                height: null,
                transparent: null
            }, d = {
                delay: 500,
                copy: !1
            }, e.prototype.setOption = function(t, e) {
                return this.options[t] = e, null == this._canvas || "width" !== t && "height" !== t ? void 0 : this._canvas[t] = e
            }, e.prototype.setOptions = function(t) {
                var e, i;
                return function(n) {
                    for (e in t) o(t, e) && (i = t[e], n.push(this.setOption(e, i)));
                    return n
                }.call(this, [])
            }, e.prototype.addFrame = function(t, e) {
                var i, n;
                null == e && (e = {}), i = {}, i.transparent = this.options.transparent;
                for (n in d) i[n] = e[n] || d[n];
                if (null != this.options.width || this.setOption("width", t.width), null != this.options.height || this.setOption("height", t.height), "undefined" != typeof ImageData && null != ImageData && t instanceof ImageData) i.data = t.data;
                else if ("undefined" != typeof CanvasRenderingContext2D && null != CanvasRenderingContext2D && t instanceof CanvasRenderingContext2D || "undefined" != typeof WebGLRenderingContext && null != WebGLRenderingContext && t instanceof WebGLRenderingContext) e.copy ? i.data = this.getContextData(t) : i.context = t;
                else {
                    if (null == t.childNodes) throw new Error("Invalid image");
                    e.copy ? i.data = this.getImageData(t) : i.image = t
                }
                return this.frames.push(i)
            }, e.prototype.render = function() {
                var t, e;
                if (this.running) throw new Error("Already running");
                if (null == this.options.width || null == this.options.height) throw new Error("Width and height must be set prior to rendering");
                this.running = !0, this.nextFrame = 0, this.finishedFrames = 0, this.imageParts = function(e) {
                    for (var i = function() {
                            var t;
                            t = [];
                            for (var e = 0; 0 <= this.frames.length ? e < this.frames.length : e > this.frames.length; 0 <= this.frames.length ? ++e : --e) t.push(e);
                            return t
                        }.apply(this, arguments), n = 0, r = i.length; n < r; ++n) t = i[n], e.push(null);
                    return e
                }.call(this, []), e = this.spawnWorkers();
                for (var i = function() {
                        var t;
                        t = [];
                        for (var i = 0; 0 <= e ? i < e : i > e; 0 <= e ? ++i : --i) t.push(i);
                        return t
                    }.apply(this, arguments), n = 0, r = i.length; n < r; ++n) t = i[n], this.renderNextFrame();
                return this.emit("start"), this.emit("progress", 0)
            }, e.prototype.abort = function() {
                for (var t;;) {
                    if (t = this.activeWorkers.shift(), !(null != t)) break;
                    console.log("killing active worker"), t.terminate()
                }
                return this.running = !1, this.emit("abort")
            }, e.prototype.spawnWorkers = function() {
                var t;
                return t = Math.min(this.options.workers, this.frames.length),
                    function() {
                        var e;
                        e = [];
                        for (var i = this.freeWorkers.length; this.freeWorkers.length <= t ? i < t : i > t; this.freeWorkers.length <= t ? ++i : --i) e.push(i);
                        return e
                    }.apply(this, arguments).forEach(function(t) {
                        return function(e) {
                            var i;
                            return console.log("spawning worker " + e), i = new Worker(t.options.workerScript), i.onmessage = function(t) {
                                return function(e) {
                                    return t.activeWorkers.splice(t.activeWorkers.indexOf(i), 1), t.freeWorkers.push(i), t.frameFinished(e.data)
                                }
                            }(t), t.freeWorkers.push(i)
                        }
                    }(this)), t
            }, e.prototype.frameFinished = function(t) {
                return console.log("frame " + t.index + " finished - " + this.activeWorkers.length + " active"), this.finishedFrames++, this.emit("progress", this.finishedFrames / this.frames.length), this.imageParts[t.index] = t, a(null, this.imageParts) ? this.renderNextFrame() : this.finishRendering()
            }, e.prototype.finishRendering = function() {
                var t, e, i, n, r, o, a;
                r = 0;
                for (var s = 0, h = this.imageParts.length; s < h; ++s) e = this.imageParts[s], r += (e.data.length - 1) * e.pageSize + e.cursor;
                r += e.pageSize - e.cursor, console.log("rendering finished - filesize " + Math.round(r / 1e3) + "kb"), t = new Uint8Array(r), o = 0;
                for (var f = 0, u = this.imageParts.length; f < u; ++f) {
                    e = this.imageParts[f];
                    for (var d = 0, l = e.data.length; d < l; ++d) a = e.data[d], i = d, t.set(a, o), o += i === e.data.length - 1 ? e.cursor : e.pageSize
                }
                return n = new Blob([t], {
                    type: "image/gif"
                }), this.emit("finished", n, t)
            }, e.prototype.renderNextFrame = function() {
                var t, e, i;
                if (0 === this.freeWorkers.length) throw new Error("No free workers");
                return this.nextFrame >= this.frames.length ? void 0 : (t = this.frames[this.nextFrame++], i = this.freeWorkers.shift(), e = this.getTask(t), console.log("starting frame " + (e.index + 1) + " of " + this.frames.length), this.activeWorkers.push(i), i.postMessage(e))
            }, e.prototype.getContextData = function(t) {
                return t.getImageData(0, 0, this.options.width, this.options.height).data
            }, e.prototype.getImageData = function(t) {
                var e;
                return null != this._canvas || (this._canvas = document.createElement("canvas"), this._canvas.width = this.options.width, this._canvas.height = this.options.height), e = this._canvas.getContext("2d"), e.setFill = this.options.background, e.fillRect(0, 0, this.options.width, this.options.height), e.drawImage(t, 0, 0), this.getContextData(e)
            }, e.prototype.getTask = function(t) {
                var e, i;
                if (e = this.frames.indexOf(t), i = {
                        index: e,
                        last: e === this.frames.length - 1,
                        delay: t.delay,
                        transparent: t.transparent,
                        width: this.options.width,
                        height: this.options.height,
                        quality: this.options.quality,
                        repeat: this.options.repeat,
                        canTransfer: "chrome" === h.name
                    }, null != t.data) i.data = t.data;
                else if (null != t.context) i.data = this.getContextData(t.context);
                else {
                    if (null == t.image) throw new Error("Invalid frame");
                    i.data = this.getImageData(t.image)
                }
                return i
            }, e
        }(u), t.exports = l
    }), e.define("/browser.coffee", function(t, e, i, n) {
        var r, o, a, s, h;
        s = navigator.userAgent.toLowerCase(), a = navigator.platform.toLowerCase(), h = s.match(/(opera|ie|firefox|chrome|version)[\s\/:]([\w\d\.]+)?.*?(safari|version[\s\/:]([\w\d\.]+)|$)/) || [null, "unknown", 0], o = "ie" === h[1] && document.documentMode, r = {
            name: "version" === h[1] ? h[3] : h[1],
            version: o || parseFloat("opera" === h[1] && h[4] ? h[4] : h[2]),
            platform: {
                name: s.match(/ip(?:ad|od|hone)/) ? "ios" : (s.match(/(?:webos|android)/) || a.match(/mac|win|linux/) || ["other"])[0]
            }
        }, r[r.name] = !0, r[r.name + parseInt(r.version, 10)] = !0, r.platform[r.platform.name] = !0, t.exports = r
    }), e.define("events", function(t, e, n, r) {
        i.EventEmitter || (i.EventEmitter = function() {});
        var o = e.EventEmitter = i.EventEmitter,
            a = "function" == typeof Array.isArray ? Array.isArray : function(t) {
                return "[object Array]" === Object.prototype.toString.call(t)
            },
            s = 10;
        o.prototype.setMaxListeners = function(t) {
            this._events || (this._events = {}), this._events.maxListeners = t
        }, o.prototype.emit = function(t) {
            if ("error" === t && (!this._events || !this._events.error || a(this._events.error) && !this._events.error.length)) throw arguments[1] instanceof Error ? arguments[1] : new Error("Uncaught, unspecified 'error' event.");
            if (!this._events) return !1;
            var e = this._events[t];
            if (!e) return !1;
            if ("function" != typeof e) {
                if (a(e)) {
                    for (var i = Array.prototype.slice.call(arguments, 1), n = e.slice(), r = 0, o = n.length; r < o; r++) n[r].apply(this, i);
                    return !0
                }
                return !1
            }
            switch (arguments.length) {
                case 1:
                    e.call(this);
                    break;
                case 2:
                    e.call(this, arguments[1]);
                    break;
                case 3:
                    e.call(this, arguments[1], arguments[2]);
                    break;
                default:
                    var i = Array.prototype.slice.call(arguments, 1);
                    e.apply(this, i)
            }
            return !0
        }, o.prototype.addListener = function(t, e) {
            if ("function" != typeof e) throw new Error("addListener only takes instances of Function");
            if (this._events || (this._events = {}), this.emit("newListener", t, e), this._events[t])
                if (a(this._events[t])) {
                    if (!this._events[t].warned) {
                        var i;
                        i = void 0 !== this._events.maxListeners ? this._events.maxListeners : s, i && i > 0 && this._events[t].length > i && (this._events[t].warned = !0, console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.", this._events[t].length), console.trace())
                    }
                    this._events[t].push(e)
                } else this._events[t] = [this._events[t], e];
            else this._events[t] = e;
            return this
        }, o.prototype.on = o.prototype.addListener, o.prototype.once = function(t, e) {
            var i = this;
            return i.on(t, function n() {
                i.removeListener(t, n), e.apply(this, arguments)
            }), this
        }, o.prototype.removeListener = function(t, e) {
            if ("function" != typeof e) throw new Error("removeListener only takes instances of Function");
            if (!this._events || !this._events[t]) return this;
            var i = this._events[t];
            if (a(i)) {
                var n = i.indexOf(e);
                if (n < 0) return this;
                i.splice(n, 1), 0 == i.length && delete this._events[t]
            } else this._events[t] === e && delete this._events[t];
            return this
        }, o.prototype.removeAllListeners = function(t) {
            return t && this._events && this._events[t] && (this._events[t] = null), this
        }, o.prototype.listeners = function(t) {
            return this._events || (this._events = {}), this._events[t] || (this._events[t] = []), a(this._events[t]) || (this._events[t] = [this._events[t]]), this._events[t]
        }
    }), t.GIF = e("/gif.coffee")
}.call(this, this),
    function() {
        function t(t) {
            return t && t.Object === Object ? t : null
        }

        function e(t) {
            return String("0000000" + t).slice(-7)
        }

        function i() {
            function t() {
                return Math.floor(65536 * (1 + Math.random())).toString(16).substring(1)
            }
            return t() + t() + "-" + t() + "-" + t() + "-" + t() + "-" + t() + t() + t()
        }

        function n(t) {
            var e = {};
            this.settings = t, this.on = function(t, i) {
                e[t] = i
            }, this.emit = function(t) {
                var i = e[t];
                i && i.apply(null, Array.prototype.slice.call(arguments, 1))
            }, this.filename = t.name || i(), this.extension = "", this.mimeType = ""
        }

        function r(t) {
            n.call(this, t), this.extension = ".tar", this.mimeType = "application/x-tar", this.fileExtension = "", this.baseFilename = this.filename, this.tape = null, this.count = 0, this.part = 1, this.frames = 0
        }

        function o(t) {
            r.call(this, t), this.type = "image/png", this.fileExtension = ".png"
        }

        function a(t) {
            r.call(this, t), this.type = "image/jpeg", this.fileExtension = ".jpg", this.quality = t.quality / 100 || .8
        }

        function s(t) {
            var e = document.createElement("canvas");
            "image/webp" !== e.toDataURL("image/webp").substr(5, 10) && console.log("WebP not supported - try another export format"), n.call(this, t), this.quality = t.quality / 100 || .8, this.extension = ".webm", this.mimeType = "video/webm", this.baseFilename = this.filename, this.framerate = t.framerate, this.frames = 0, this.part = 1, this.videoWriter = new WebMWriter({
                quality: this.quality,
                fileWriter: null,
                fd: null,
                frameRate: this.framerate
            })
        }

        function h(t) {
            n.call(this, t), t.quality = t.quality / 100 || .8, this.encoder = new FFMpegServer.Video(t), this.encoder.on("process", function() {
                this.emit("process")
            }.bind(this)), this.encoder.on("finished", function(t, e) {
                var i = this.callback;
                i && (this.callback = void 0, i(t, e))
            }.bind(this)), this.encoder.on("progress", function(t) {
                this.settings.onProgress && this.settings.onProgress(t)
            }.bind(this)), this.encoder.on("error", function(t) {
                alert(JSON.stringify(t, null, 2))
            }.bind(this))
        }

        function f(t) {
            n.call(this, t), this.framerate = this.settings.framerate, this.type = "video/webm", this.extension = ".webm", this.stream = null, this.mediaRecorder = null, this.chunks = []
        }

        function u(t) {
            n.call(this, t), t.quality = 31 - (30 * t.quality / 100 || 10), t.workers = t.workers || 4, this.extension = ".gif", this.mimeType = "image/gif", this.canvas = document.createElement("canvas"), this.ctx = this.canvas.getContext("2d"), this.sizeSet = !1, this.encoder = new GIF({
                workers: t.workers,
                quality: t.quality,
                workerScript: t.workersPath + "gif.worker.js"
            }), this.encoder.on("progress", function(t) {
                this.settings.onProgress && this.settings.onProgress(t)
            }.bind(this)), this.encoder.on("finished", function(t) {
                var e = this.callback;
                e && (this.callback = void 0, e(t))
            }.bind(this))
        }

        function d(t) {
            function e() {
                function t() {
                    return this._hooked || (this._hooked = !0, this._hookedTime = this.currentTime || 0, this.pause(), it.push(this)), this._hookedTime + M.startTime
                }
                b("Capturer start"), U = window.Date.now(), T = U + M.startTime, I = window.performance.now(), F = I + M.startTime, window.Date.prototype.getTime = function() {
                    return T
                }, window.Date.now = function() {
                    return T
                }, window.setTimeout = function(t, e) {
                    var i = {
                        callback: t,
                        time: e,
                        triggerTime: T + e
                    };
                    return _.push(i), b("Timeout set to " + i.time), i
                }, window.clearTimeout = function(t) {
                    for (var e = 0; e < _.length; e++) _[e] != t || (_.splice(e, 1), b("Timeout cleared"))
                }, window.setInterval = function(t, e) {
                    var i = {
                        callback: t,
                        time: e,
                        triggerTime: T + e
                    };
                    return S.push(i), b("Interval set to " + i.time), i
                }, window.clearInterval = function(t) {
                    return b("clear Interval"), null
                }, window.requestAnimationFrame = function(t) {
                    W.push(t)
                }, window.performance.now = function() {
                    return F
                };
                try {
                    Object.defineProperty(HTMLVideoElement.prototype, "currentTime", {
                        get: t
                    }), Object.defineProperty(HTMLAudioElement.prototype, "currentTime", {
                        get: t
                    })
                } catch (t) {
                    b(t)
                }
            }

            function i() {
                e(), D.start(), R = !0
            }

            function n() {
                R = !1, D.stop(), l()
            }

            function r(t, e) {
                Z(t, 0, e)
            }

            function d() {
                r(y)
            }

            function l() {
                b("Capturer stop"), window.setTimeout = Z, window.setInterval = J, window.clearInterval = Y, window.clearTimeout = $, window.requestAnimationFrame = Q, window.Date.prototype.getTime = et, window.Date.now = X, window.performance.now = tt
            }

            function c() {
                var t = C / M.framerate;
                (M.frameLimit && C >= M.frameLimit || M.timeLimit && t >= M.timeLimit) && (n(), v());
                var e = new Date(null);
                e.setSeconds(t), M.motionBlurFrames > 2 ? j.textContent = "CCapture " + M.format + " | " + C + " frames (" + O + " inter) | " + e.toISOString().substr(11, 8) : j.textContent = "CCapture " + M.format + " | " + C + " frames | " + e.toISOString().substr(11, 8)
            }

            function p(t) {
                N.width === t.width && N.height === t.height || (N.width = t.width, N.height = t.height, z = new Uint16Array(N.height * N.width * 4), V.fillStyle = "#0", V.fillRect(0, 0, N.width, N.height))
            }

            function m(t) {
                V.drawImage(t, 0, 0), q = V.getImageData(0, 0, N.width, N.height);
                for (var e = 0; e < z.length; e += 4) z[e] += q.data[e], z[e + 1] += q.data[e + 1], z[e + 2] += q.data[e + 2];
                O++
            }

            function w() {
                for (var t = q.data, e = 0; e < z.length; e += 4) t[e] = 2 * z[e] / M.motionBlurFrames, t[e + 1] = 2 * z[e + 1] / M.motionBlurFrames, t[e + 2] = 2 * z[e + 2] / M.motionBlurFrames;
                V.putImageData(q, 0, 0), D.add(N), C++, O = 0, b("Full MB Frame! " + C + " " + T);
                for (var e = 0; e < z.length; e += 4) z[e] = 0, z[e + 1] = 0, z[e + 2] = 0;
                gc()
            }

            function g(t) {
                R && (M.motionBlurFrames > 2 ? (p(t), m(t), O >= .5 * M.motionBlurFrames ? w() : d()) : (D.add(t), C++, b("Full Frame! " + C)))
            }

            function y() {
                var t = 1e3 / M.framerate,
                    e = (C + O / M.motionBlurFrames) * t;
                T = U + e, F = I + e, it.forEach(function(t) {
                    t._hookedTime = e / 1e3
                }), c(), b("Frame: " + C + " " + O);
                for (var i = 0; i < _.length; i++) T >= _[i].triggerTime && (r(_[i].callback), _.splice(i, 1));
                for (var i = 0; i < S.length; i++) T >= S[i].triggerTime && (r(S[i].callback), S[i].triggerTime += S[i].time);
                W.forEach(function(t) {
                    r(t, T - k)
                }), W = []
            }

            function v(t) {
                t || (t = function(t) {
                    return download(t, D.filename + D.extension, D.mimeType), !1
                }), D.save(t)
            }

            function b(t) {
                A && console.log(t)
            }

            function B(t, e) {
                P[t] = e
            }

            function x(t) {
                var e = P[t];
                e && e.apply(null, Array.prototype.slice.call(arguments, 1))
            }

            function E(t) {
                x("progress", t)
            }
            var A, L, T, U, F, I, d, D, M = t || {},
                _ = (new Date, []),
                S = [],
                C = 0,
                O = 0,
                W = [],
                R = !1,
                P = {};
            M.framerate = M.framerate || 60, M.motionBlurFrames = 2 * (M.motionBlurFrames || 1), A = M.verbose || !1, L = M.display || !1, M.step = 1e3 / M.framerate, M.timeLimit = M.timeLimit || 0, M.frameLimit = M.frameLimit || 0, M.startTime = M.startTime || 0;
            var j = document.createElement("div");
            j.style.position = "absolute", j.style.left = j.style.top = 0, j.style.backgroundColor = "black", j.style.fontFamily = "monospace", j.style.fontSize = "11px", j.style.padding = "5px", j.style.color = "red", j.style.zIndex = 1e5, M.display && document.body.appendChild(j);
            var z, q, N = document.createElement("canvas"),
                V = N.getContext("2d");
            b("Step is set to " + M.step + "ms");
            var G = {
                    gif: u,
                    webm: s,
                    ffmpegserver: h,
                    png: o,
                    jpg: a,
                    "webm-mediarecorder": f
                },
                H = G[M.format];
            if (!H) throw "Error: Incorrect or missing format: Valid formats are " + Object.keys(G).join(", ");
            if (D = new H(M), D.step = d, D.on("process", y), D.on("progress", E), "performance" in window == 0 && (window.performance = {}), Date.now = Date.now || function() {
                    return (new Date).getTime()
                }, "now" in window.performance == 0) {
                var K = Date.now();
                performance.timing && performance.timing.navigationStart && (K = performance.timing.navigationStart), window.performance.now = function() {
                    return Date.now() - K
                }
            }
            var Z = window.setTimeout,
                J = window.setInterval,
                Y = window.clearInterval,
                $ = window.clearTimeout,
                Q = window.requestAnimationFrame,
                X = window.Date.now,
                tt = window.performance.now,
                et = window.Date.prototype.getTime,
                it = [];
            return {
                start: i,
                capture: g,
                stop: n,
                save: v,
                on: B
            }
        }
        var l = {
                function: !0,
                object: !0
            },
            c = (parseFloat, parseInt, l[typeof exports] && exports && !exports.nodeType ? exports : void 0),
            p = l[typeof module] && module && !module.nodeType ? module : void 0,
            m = p && p.exports === c ? c : void 0,
            w = t(c && p && "object" == typeof global && global),
            g = t(l[typeof self] && self),
            y = t(l[typeof window] && window),
            v = t(l[typeof this] && this),
            b = w || y !== (v && v.window) && y || g || v || Function("return this")();
        "gc" in window || (window.gc = function() {}), HTMLCanvasElement.prototype.toBlob || Object.defineProperty(HTMLCanvasElement.prototype, "toBlob", {
                value: function(t, e, i) {
                    for (var n = atob(this.toDataURL(e, i).split(",")[1]), r = n.length, o = new Uint8Array(r), a = 0; a < r; a++) o[a] = n.charCodeAt(a);
                    t(new Blob([o], {
                        type: e || "image/png"
                    }))
                }
            }),
            function() {
                if ("performance" in window == 0 && (window.performance = {}), Date.now = Date.now || function() {
                        return (new Date).getTime()
                    }, "now" in window.performance == 0) {
                    var t = Date.now();
                    performance.timing && performance.timing.navigationStart && (t = performance.timing.navigationStart), window.performance.now = function() {
                        return Date.now() - t
                    }
                }
            }();
        var k = window.Date.now();
        n.prototype.start = function() {}, n.prototype.stop = function() {}, n.prototype.add = function() {}, n.prototype.save = function() {}, n.prototype.dispose = function() {}, n.prototype.safeToProceed = function() {
            return !0
        }, n.prototype.step = function() {
            console.log("Step not set!")
        }, r.prototype = Object.create(n.prototype), r.prototype.start = function() {
            this.dispose()
        }, r.prototype.add = function(t) {
            var i = new FileReader;
            i.onload = function() {
                this.tape.append(e(this.count) + this.fileExtension, new Uint8Array(i.result)), this.settings.autoSaveTime > 0 && this.frames / this.settings.framerate >= this.settings.autoSaveTime ? this.save(function(t) {
                    this.filename = this.baseFilename + "-part-" + e(this.part), download(t, this.filename + this.extension, this.mimeType);
                    var i = this.count;
                    this.dispose(), this.count = i + 1, this.part++, this.filename = this.baseFilename + "-part-" + e(this.part), this.frames = 0, this.step()
                }.bind(this)) : (this.count++, this.frames++, this.step())
            }.bind(this), i.readAsArrayBuffer(t)
        }, r.prototype.save = function(t) {
            t(this.tape.save())
        }, r.prototype.dispose = function() {
            this.tape = new Tar, this.count = 0
        }, o.prototype = Object.create(r.prototype), o.prototype.add = function(t) {
            t.toBlob(function(t) {
                r.prototype.add.call(this, t)
            }.bind(this), this.type)
        }, a.prototype = Object.create(r.prototype), a.prototype.add = function(t) {
            t.toBlob(function(t) {
                r.prototype.add.call(this, t)
            }.bind(this), this.type, this.quality)
        }, s.prototype = Object.create(n.prototype), s.prototype.start = function(t) {
            this.dispose()
        }, s.prototype.add = function(t) {
            this.videoWriter.addFrame(t), this.settings.autoSaveTime > 0 && this.frames / this.settings.framerate >= this.settings.autoSaveTime ? this.save(function(t) {
                this.filename = this.baseFilename + "-part-" + e(this.part), download(t, this.filename + this.extension, this.mimeType), this.dispose(), this.part++, this.filename = this.baseFilename + "-part-" + e(this.part), this.step()
            }.bind(this)) : (this.frames++, this.step())
        }, s.prototype.save = function(t) {
            this.videoWriter.complete().then(t)
        }, s.prototype.dispose = function(t) {
            this.frames = 0, this.videoWriter = new WebMWriter({
                quality: this.quality,
                fileWriter: null,
                fd: null,
                frameRate: this.framerate
            })
        }, h.prototype = Object.create(n.prototype), h.prototype.start = function() {
            this.encoder.start(this.settings)
        }, h.prototype.add = function(t) {
            this.encoder.add(t)
        }, h.prototype.save = function(t) {
            this.callback = t, this.encoder.end()
        }, h.prototype.safeToProceed = function() {
            return this.encoder.safeToProceed()
        }, f.prototype = Object.create(n.prototype), f.prototype.add = function(t) {
            this.stream || (this.stream = t.captureStream(this.framerate), this.mediaRecorder = new MediaRecorder(this.stream), this.mediaRecorder.start(), this.mediaRecorder.ondataavailable = function(t) {
                this.chunks.push(t.data)
            }.bind(this)), this.step()
        }, f.prototype.save = function(t) {
            this.mediaRecorder.onstop = function(e) {
                var i = new Blob(this.chunks, {
                    type: "video/webm"
                });
                this.chunks = [], t(i)
            }.bind(this), this.mediaRecorder.stop()
        }, u.prototype = Object.create(n.prototype), u.prototype.add = function(t) {
            this.sizeSet || (this.encoder.setOption("width", t.width), this.encoder.setOption("height", t.height), this.sizeSet = !0), this.canvas.width = t.width, this.canvas.height = t.height, this.ctx.drawImage(t, 0, 0), this.encoder.addFrame(this.ctx, {
                copy: !0,
                delay: this.settings.step
            }), this.step()
        }, u.prototype.save = function(t) {
            this.callback = t, this.encoder.render()
        }, (y || g || {}).CCapture = d, "function" == typeof define && "object" == typeof define.amd && define.amd ? define(function() {
            return d
        }) : c && p ? (m && ((p.exports = d).CCapture = d), c.CCapture = d) : b.CCapture = d
    }();