{"version":3,"file":"warmUpWorklet.js","mappings":"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","sources":["webpack:///./src/logging-init.ts","webpack:///./src/logging.ts","webpack:///./node_modules/heap-js/dist/heap-js.es5.js","webpack:///./src/timerQueue.ts","webpack:///./src/worklets/warm-up-worklet-processor.ts"],"sourcesContent":["// Should be the same as logging.LogLevel, but local to this module\nexport enum LogLevel {\n    Debug = 1,\n    Info,\n    Warn,\n    Error,\n    None = 1000,\n}\n\nexport type LogScope =\n    'default'\n    // Library\n    | 'AsyncProcessor'\n    | 'BrowserInfo'\n    | 'BrowserInit'\n    | 'BubbleHost'\n    | 'Connectivity'\n    | 'Gestures'\n    | 'event-handling'\n    | 'InertialScroll'\n    | 'NoSleep'\n    | 'History'\n    | 'Interactive'\n    | 'Kvas'\n    | 'KvasBackend'\n    | 'MenuHost'\n    | 'ModalHost'\n    | 'OnDeviceAwake'\n    | 'promises'\n    | 'Rpc'\n    | 'ScreenSize'\n    | 'ServiceWorker'\n    | 'SessionTokens'\n    | 'TimerQueue'\n    | 'UndoStack'\n    | 'Versioning'\n    | 'VirtualList'\n    // XxxUI\n    | 'DebugUI'\n    | 'DeviceAwakeUI'\n    | 'FocusUI'\n    | 'InteractiveUI'\n    | 'KeepAwakeUI'\n    | 'LanguageUI'\n    | 'NotificationUI'\n    | 'TuneUI'\n    | 'UserActivityUI'\n    | 'VibrationUI'\n    | 'Share'\n    // Audio\n    | 'AudioContextRef'\n    | 'AudioContextSource'\n    | 'AudioInfo'\n    // Audio playback\n    | 'AudioPlayer'\n    | 'FallbackPlayback'\n    | 'OpusDecoder'\n    | 'OpusDecoderWorker'\n    | 'FeederNode'\n    | 'FeederProcessor'\n    | 'SoundsPlayer'\n    // Audio recording\n    | 'AudioRecorder'\n    | 'AudioStreamer'\n    | 'OpusMediaRecorder'\n    | 'AudioVadWorker'\n    | 'AudioVadWorkletProcessor'\n    | 'OpusEncoderWorkletProcessor'\n    | 'OpusEncoderWorker'\n    | 'WarmUpAudioWorkletProcessor'\n    | 'WebRtcAec' // Unused\n    // Isolated components\n    | 'Attachments'\n    | 'ChatMessageEditor'\n    | 'CodeBlockMarkupView'\n    | 'CopyTrigger'\n    | 'FontSizes'\n    | 'Landing'\n    | 'LandingLeftMenu'\n    | 'MarkupEditor'\n    | 'MessageEditor'\n    | 'SearchPanel'\n    | 'SideNav'\n    | 'SelectionHost'\n    | 'TextBox'\n    | 'Theme'\n    | 'TooltipHost'\n    | 'UserInterface'\n    | 'VisualMediaViewer'\n    | 'WebAuth';\n\nconst GlobalThisKey = 'logLevels';\nconst StorageKey = 'logLevels';\nconst DateStorageKey = `${StorageKey}.date`;\nconst MaxStorageAge = 86_400_000 * 3; // 3 days\n\nconst app = globalThis?.['App'] as unknown;\nconst isWorkerOrWorklet = !app;\n\nexport function initLogging(Log: unknown): void {\n    Log['defaultMinLevel'] = LogLevel.Info;\n    const minLevels = Log['minLevels'] as Map<LogScope, LogLevel>;\n\n    let wasRestored = false;\n    if (globalThis && !isWorkerOrWorklet) {\n        globalThis[GlobalThisKey] = new LogLevelController(minLevels);\n        wasRestored = restore(minLevels);\n    }\n    if (wasRestored) {\n        console.log(`Logging: logLevels are restored`);\n    }\n    else {\n        if (!isWorkerOrWorklet)\n            console.log(`Logging: logLevels are reset`);\n        reset(minLevels);\n    }\n}\n\nclass LogLevelController {\n    constructor (private minLevels: Map<LogScope, LogLevel>)\n    { }\n\n    public override(scope: LogScope, newLevel: LogLevel): void {\n        this.minLevels.set(scope, newLevel);\n        persist(this.minLevels);\n    }\n\n    public reset(isProduction?: boolean) {\n        reset(this.minLevels, isProduction);\n        persist(this.minLevels);\n    }\n\n    public clear(defaultLevel?: LogLevel) {\n        this.minLevels.clear();\n        if (defaultLevel !== undefined)\n            this.minLevels['default'] = defaultLevel;\n        persist(this.minLevels);\n    }\n}\n\nconst sessionStorage = globalThis?.sessionStorage;\n\nfunction restore(minLevels: Map<string, LogLevel>): boolean {\n    if (!sessionStorage)\n        return false;\n\n    const dateJson = sessionStorage.getItem(DateStorageKey);\n    if (!dateJson)\n        return false;\n    if (Date.now() - JSON.parse(dateJson) > MaxStorageAge)\n        return false;\n\n    const readJson = sessionStorage.getItem(StorageKey);\n    if (!readJson)\n        return false;\n\n    const readMinLevels = new Map(JSON.parse(readJson) as [string, LogLevel][]);\n    if (!(typeof readMinLevels.size === 'number'))\n        return false;\n\n    minLevels.clear();\n    readMinLevels.forEach((value, key) => minLevels.set(key, value));\n    return true;\n}\n\nfunction persist(minLevels: Map<string, LogLevel>): boolean {\n    if (!sessionStorage)\n        return false;\n\n    sessionStorage.setItem(DateStorageKey, JSON.stringify(Date.now()));\n    sessionStorage.setItem(StorageKey, JSON.stringify(Array.from(minLevels.entries())));\n    return true;\n}\n\nfunction reset(minLevels: Map<LogScope, LogLevel>, isProduction?: boolean): void {\n    minLevels.clear();\n    // enabled debug logging temporarily - do not add chatty log scopes!! - 14.11.2023 AK\n\n    // isProduction ??= app?.['environment'] == 'Production';\n    // if (isProduction)\n    //     return;\n\n    // Bumping down levels of in-dev scopes\n    // minLevels.set('Versioning', LogLevel.Debug);\n    // minLevels.set('Gestures', LogLevel.Debug);\n    // minLevels.set('event-handling', LogLevel.Debug);\n    // minLevels.set('Rpc', LogLevel.Debug);\n    // minLevels.set('AsyncProcessor', LogLevel.Debug);\n    // minLevels.set('promises', LogLevel.Debug);\n    minLevels.set('Interactive', LogLevel.Debug);\n    minLevels.set('OnDeviceAwake', LogLevel.Debug);\n    minLevels.set('AudioContextRef', LogLevel.Debug);\n    minLevels.set('AudioContextSource', LogLevel.Debug);\n    minLevels.set('AudioPlayer', LogLevel.Debug);\n    // minLevels.set('FallbackPlayback', LogLevel.Debug);\n    // minLevels.set('OpusDecoder', LogLevel.Debug);\n    // minLevels.set('OpusDecoderWorker', LogLevel.Debug);\n    // minLevels.set('FeederProcessor', LogLevel.Debug);\n    minLevels.set('AudioRecorder', LogLevel.Debug);\n    // minLevels.set('AudioStreamer', LogLevel.Debug);\n    minLevels.set('OpusMediaRecorder', LogLevel.Debug);\n    // minLevels.set('AudioVadWorker', LogLevel.Debug);\n    // minLevels.set('AudioVadWorkletProcessor', LogLevel.Debug);\n    // minLevels.set('OpusEncoderWorker', LogLevel.Debug);\n    // minLevels.set('OpusEncoderWorkletProcessor', LogLevel.Debug);\n    // minLevels.set('InertialScroll', LogLevel.Debug);\n    minLevels.set('VirtualList', LogLevel.Debug);\n    // minLevels.set('Landing', LogLevel.Debug);\n    // minLevels.set('LandingLeftMenu', LogLevel.Debug);\n    // minLevels.set('SideNav', LogLevel.Debug);\n\n    // XxxUI\n    // minLevels.set('FocusUI', LogLevel.Debug);\n    // minLevels.set('KeepAwakeUI', LogLevel.Debug);\n    // minLevels.set('NoSleep', LogLevel.Debug);\n    // minLevels.set('NotificationUI', LogLevel.Debug);\n    // minLevels.set('TuneUI', LogLevel.Debug);\n    // minLevels.set('SoundsPlayer', LogLevel.Debug);\n\n    // Isolated components\n    // minLevels.set('History', LogLevel.Debug);\n    // minLevels.set('MenuHost', LogLevel.Debug);\n    // minLevels.set('MarkupEditor', LogLevel.Debug);\n    // minLevels.set('ChatMessageEditor', LogLevel.Debug);\n\n    // minLevels.clear(); // To quickly discard any tweaks :)\n    persist(minLevels);\n}\n","import { initLogging, LogLevel, LogScope } from 'logging-init';\nimport 'logging-init';\n\nexport { LogLevel } from './logging-init';\nexport type { LogScope } from './logging-init';\n\nexport interface LogRef {\n    target : unknown;\n    id : number;\n}\n\ninterface SetItem {\n    ref : LogRef;\n    touchedAt : number;\n}\n\nclass LogRefSet {\n    items : SetItem[];\n    capacity : number;\n    idSeed : number;\n\n    constructor(capacity : number) {\n        this.idSeed = 0;\n        this.capacity = capacity;\n        this.items = [];\n    }\n\n    public ref(data: object) : LogRef {\n        const itemIndex = this.items.findIndex(el => el.ref.target === data);\n        if (itemIndex >= 0) {\n            const existentItem = this.items[itemIndex];\n            existentItem.touchedAt = Date.now();\n            return existentItem.ref;\n        }\n        else {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n            const id = data['__logRefId'] as number ?? this.idSeed++;\n            const newRef = { target: data, id: id };\n            data['__logRefId'] = id;\n            if (this.items.length >= this.capacity)\n                this.removeOldest();\n            const newItem = { ref : newRef, touchedAt : Date.now() };\n            this.items.push(newItem);\n            return newRef;\n        }\n    }\n\n    private removeOldest() {\n        let indexToEliminate = 0;\n        let itemToEliminate = this.items[0];\n        for (let i = 1; i < this.items.length; i++) {\n            const item = this.items[i];\n            if (item.touchedAt < itemToEliminate.touchedAt) {\n                itemToEliminate = item;\n                indexToEliminate = i;\n            }\n        }\n        this.items.splice(indexToEliminate, 1);\n        // clear log ref target to prevent memory leaks\n        // and keep string representation of the target for tracing\n        const ref = itemToEliminate.ref;\n        ref.target = ref.target.toString();\n    }\n}\n\nexport class Log {\n    private static isInitialized = false;\n    private static logRefs : LogRefSet = new LogRefSet(10);\n    public static readonly minLevels: Map<LogScope, LogLevel> = new Map<LogScope, LogLevel>();\n    public static defaultMinLevel = LogLevel.Info;\n    public log: (...data: unknown[]) => void;\n    public trace: (...data: unknown[]) => void;\n\n    constructor(\n        public readonly scope: LogScope,\n        public readonly level: LogLevel,\n    ) {\n        const prefix = `[${scope}]`;\n        switch (level) {\n            case LogLevel.Debug:\n                this.log = (...data: unknown[]) => console.debug(prefix, ...data);\n                break;\n            case LogLevel.Info:\n                this.log = (...data: unknown[]) => console.log(prefix, ...data);\n                break;\n            case LogLevel.Warn:\n                this.log = (...data: unknown[]) => console.warn(prefix, ...data);\n                break;\n            case LogLevel.Error:\n                this.log = (...data: unknown[]) => console.error(prefix, ...data);\n                break;\n            case LogLevel.None:\n                throw new Error('LogLevel.None cannot be used here');\n        }\n        this.trace = (...data: unknown[]) => console.trace(prefix, ...data);\n    }\n\n    public static loggerFactory = (scope: LogScope, level: LogLevel) => new Log(scope, level);\n\n    public static get(scope: LogScope) {\n        if (!this.isInitialized) {\n            this.isInitialized = true;\n            initLogging(this);\n        }\n\n        const minLevels = this.minLevels;\n        const minLevel = minLevels.get(scope)\n            ?? minLevels.get('default')\n            ?? this.defaultMinLevel;\n\n        const getLogger = (level: LogLevel) => level >= minLevel ? this.loggerFactory(scope, level) : null;\n\n        return {\n            logScope: scope,\n            debugLog: getLogger(LogLevel.Debug),\n            infoLog: getLogger(LogLevel.Info),\n            warnLog: getLogger(LogLevel.Warn),\n            errorLog: getLogger(LogLevel.Error),\n        };\n    }\n\n    public static ref(data: object) : object {\n        if (!data)\n            return data;\n        return this.logRefs.ref(data);\n    }\n\n    public assert(predicate?: boolean, ...data: unknown[]): void {\n        if (!predicate)\n            this.log(data);\n    }\n}\n","var __generator = (undefined && undefined.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nvar __read = (undefined && undefined.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spreadArray = (undefined && undefined.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nvar toInt = function (n) { return ~~n; };\n/**\n * Heap\n * @type {Class}\n */\nvar Heap = /** @class */ (function () {\n    /**\n     * Heap instance constructor.\n     * @param  {Function} compare Optional comparison function, defaults to Heap.minComparator<number>\n     */\n    function Heap(compare) {\n        if (compare === void 0) { compare = Heap.minComparator; }\n        var _this = this;\n        this.compare = compare;\n        this.heapArray = [];\n        this._limit = 0;\n        /**\n         * Alias of add\n         */\n        this.offer = this.add;\n        /**\n         * Alias of peek\n         */\n        this.element = this.peek;\n        /**\n         * Alias of pop\n         */\n        this.poll = this.pop;\n        /**\n         * Returns the inverse to the comparison function.\n         * @return {Function}\n         */\n        this._invertedCompare = function (a, b) {\n            return -1 * _this.compare(a, b);\n        };\n    }\n    /*\n              Static methods\n     */\n    /**\n     * Gets children indices for given index.\n     * @param  {Number} idx     Parent index\n     * @return {Array(Number)}  Array of children indices\n     */\n    Heap.getChildrenIndexOf = function (idx) {\n        return [idx * 2 + 1, idx * 2 + 2];\n    };\n    /**\n     * Gets parent index for given index.\n     * @param  {Number} idx  Children index\n     * @return {Number | undefined}      Parent index, -1 if idx is 0\n     */\n    Heap.getParentIndexOf = function (idx) {\n        if (idx <= 0) {\n            return -1;\n        }\n        var whichChildren = idx % 2 ? 1 : 2;\n        return Math.floor((idx - whichChildren) / 2);\n    };\n    /**\n     * Gets sibling index for given index.\n     * @param  {Number} idx  Children index\n     * @return {Number | undefined}      Sibling index, -1 if idx is 0\n     */\n    Heap.getSiblingIndexOf = function (idx) {\n        if (idx <= 0) {\n            return -1;\n        }\n        var whichChildren = idx % 2 ? 1 : -1;\n        return idx + whichChildren;\n    };\n    /**\n     * Min heap comparison function, default.\n     * @param  {any} a     First element\n     * @param  {any} b     Second element\n     * @return {Number}    0 if they're equal, positive if `a` goes up, negative if `b` goes up\n     */\n    Heap.minComparator = function (a, b) {\n        if (a > b) {\n            return 1;\n        }\n        else if (a < b) {\n            return -1;\n        }\n        else {\n            return 0;\n        }\n    };\n    /**\n     * Max heap comparison function.\n     * @param  {any} a     First element\n     * @param  {any} b     Second element\n     * @return {Number}    0 if they're equal, positive if `a` goes up, negative if `b` goes up\n     */\n    Heap.maxComparator = function (a, b) {\n        if (b > a) {\n            return 1;\n        }\n        else if (b < a) {\n            return -1;\n        }\n        else {\n            return 0;\n        }\n    };\n    /**\n     * Min number heap comparison function, default.\n     * @param  {Number} a     First element\n     * @param  {Number} b     Second element\n     * @return {Number}    0 if they're equal, positive if `a` goes up, negative if `b` goes up\n     */\n    Heap.minComparatorNumber = function (a, b) {\n        return a - b;\n    };\n    /**\n     * Max number heap comparison function.\n     * @param  {Number} a     First element\n     * @param  {Number} b     Second element\n     * @return {Number}    0 if they're equal, positive if `a` goes up, negative if `b` goes up\n     */\n    Heap.maxComparatorNumber = function (a, b) {\n        return b - a;\n    };\n    /**\n     * Default equality function.\n     * @param  {any} a    First element\n     * @param  {any} b    Second element\n     * @return {Boolean}  True if equal, false otherwise\n     */\n    Heap.defaultIsEqual = function (a, b) {\n        return a === b;\n    };\n    /**\n     * Prints a heap.\n     * @param  {Heap} heap Heap to be printed\n     * @returns {String}\n     */\n    Heap.print = function (heap) {\n        function deep(i) {\n            var pi = Heap.getParentIndexOf(i);\n            return Math.floor(Math.log2(pi + 1));\n        }\n        function repeat(str, times) {\n            var out = '';\n            for (; times > 0; --times) {\n                out += str;\n            }\n            return out;\n        }\n        var node = 0;\n        var lines = [];\n        var maxLines = deep(heap.length - 1) + 2;\n        var maxLength = 0;\n        while (node < heap.length) {\n            var i = deep(node) + 1;\n            if (node === 0) {\n                i = 0;\n            }\n            // Text representation\n            var nodeText = String(heap.get(node));\n            if (nodeText.length > maxLength) {\n                maxLength = nodeText.length;\n            }\n            // Add to line\n            lines[i] = lines[i] || [];\n            lines[i].push(nodeText);\n            node += 1;\n        }\n        return lines\n            .map(function (line, i) {\n            var times = Math.pow(2, maxLines - i) - 1;\n            return (repeat(' ', Math.floor(times / 2) * maxLength) +\n                line\n                    .map(function (el) {\n                    // centered\n                    var half = (maxLength - el.length) / 2;\n                    return repeat(' ', Math.ceil(half)) + el + repeat(' ', Math.floor(half));\n                })\n                    .join(repeat(' ', times * maxLength)));\n        })\n            .join('\\n');\n    };\n    /*\n              Python style\n     */\n    /**\n     * Converts an array into an array-heap, in place\n     * @param  {Array}    arr      Array to be modified\n     * @param  {Function} compare  Optional compare function\n     * @return {Heap}              For convenience, it returns a Heap instance\n     */\n    Heap.heapify = function (arr, compare) {\n        var heap = new Heap(compare);\n        heap.heapArray = arr;\n        heap.init();\n        return heap;\n    };\n    /**\n     * Extract the peek of an array-heap\n     * @param  {Array}    heapArr  Array to be modified, should be a heap\n     * @param  {Function} compare  Optional compare function\n     * @return {any}               Returns the extracted peek\n     */\n    Heap.heappop = function (heapArr, compare) {\n        var heap = new Heap(compare);\n        heap.heapArray = heapArr;\n        return heap.pop();\n    };\n    /**\n     * Pushes a item into an array-heap\n     * @param  {Array}    heapArr  Array to be modified, should be a heap\n     * @param  {any}      item     Item to push\n     * @param  {Function} compare  Optional compare function\n     */\n    Heap.heappush = function (heapArr, item, compare) {\n        var heap = new Heap(compare);\n        heap.heapArray = heapArr;\n        heap.push(item);\n    };\n    /**\n     * Push followed by pop, faster\n     * @param  {Array}    heapArr  Array to be modified, should be a heap\n     * @param  {any}      item     Item to push\n     * @param  {Function} compare  Optional compare function\n     * @return {any}               Returns the extracted peek\n     */\n    Heap.heappushpop = function (heapArr, item, compare) {\n        var heap = new Heap(compare);\n        heap.heapArray = heapArr;\n        return heap.pushpop(item);\n    };\n    /**\n     * Replace peek with item\n     * @param  {Array}    heapArr  Array to be modified, should be a heap\n     * @param  {any}      item     Item as replacement\n     * @param  {Function} compare  Optional compare function\n     * @return {any}               Returns the extracted peek\n     */\n    Heap.heapreplace = function (heapArr, item, compare) {\n        var heap = new Heap(compare);\n        heap.heapArray = heapArr;\n        return heap.replace(item);\n    };\n    /**\n     * Return the `n` most valuable elements of a heap-like Array\n     * @param  {Array}    heapArr  Array, should be an array-heap\n     * @param  {number}   n        Max number of elements\n     * @param  {Function} compare  Optional compare function\n     * @return {any}               Elements\n     */\n    Heap.heaptop = function (heapArr, n, compare) {\n        if (n === void 0) { n = 1; }\n        var heap = new Heap(compare);\n        heap.heapArray = heapArr;\n        return heap.top(n);\n    };\n    /**\n     * Return the `n` least valuable elements of a heap-like Array\n     * @param  {Array}    heapArr  Array, should be an array-heap\n     * @param  {number}   n        Max number of elements\n     * @param  {Function} compare  Optional compare function\n     * @return {any}               Elements\n     */\n    Heap.heapbottom = function (heapArr, n, compare) {\n        if (n === void 0) { n = 1; }\n        var heap = new Heap(compare);\n        heap.heapArray = heapArr;\n        return heap.bottom(n);\n    };\n    /**\n     * Return the `n` most valuable elements of an iterable\n     * @param  {number}   n        Max number of elements\n     * @param  {Iterable} Iterable Iterable list of elements\n     * @param  {Function} compare  Optional compare function\n     * @return {any}               Elements\n     */\n    Heap.nlargest = function (n, iterable, compare) {\n        var heap = new Heap(compare);\n        heap.heapArray = __spreadArray([], __read(iterable), false);\n        heap.init();\n        return heap.top(n);\n    };\n    /**\n     * Return the `n` least valuable elements of an iterable\n     * @param  {number}   n        Max number of elements\n     * @param  {Iterable} Iterable Iterable list of elements\n     * @param  {Function} compare  Optional compare function\n     * @return {any}               Elements\n     */\n    Heap.nsmallest = function (n, iterable, compare) {\n        var heap = new Heap(compare);\n        heap.heapArray = __spreadArray([], __read(iterable), false);\n        heap.init();\n        return heap.bottom(n);\n    };\n    /*\n              Instance methods\n     */\n    /**\n     * Adds an element to the heap. Aliases: `offer`.\n     * Same as: push(element)\n     * @param {any} element Element to be added\n     * @return {Boolean} true\n     */\n    Heap.prototype.add = function (element) {\n        this._sortNodeUp(this.heapArray.push(element) - 1);\n        this._applyLimit();\n        return true;\n    };\n    /**\n     * Adds an array of elements to the heap.\n     * Similar as: push(element, element, ...).\n     * @param {Array} elements Elements to be added\n     * @return {Boolean} true\n     */\n    Heap.prototype.addAll = function (elements) {\n        var _a;\n        var i = this.length;\n        (_a = this.heapArray).push.apply(_a, __spreadArray([], __read(elements), false));\n        for (var l = this.length; i < l; ++i) {\n            this._sortNodeUp(i);\n        }\n        this._applyLimit();\n        return true;\n    };\n    /**\n     * Return the bottom (lowest value) N elements of the heap.\n     *\n     * @param  {Number} n  Number of elements.\n     * @return {Array}     Array of length <= N.\n     */\n    Heap.prototype.bottom = function (n) {\n        if (n === void 0) { n = 1; }\n        if (this.heapArray.length === 0 || n <= 0) {\n            // Nothing to do\n            return [];\n        }\n        else if (this.heapArray.length === 1) {\n            // Just the peek\n            return [this.heapArray[0]];\n        }\n        else if (n >= this.heapArray.length) {\n            // The whole heap\n            return __spreadArray([], __read(this.heapArray), false);\n        }\n        else {\n            // Some elements\n            var result = this._bottomN_push(~~n);\n            return result;\n        }\n    };\n    /**\n     * Check if the heap is sorted, useful for testing purposes.\n     * @return {Undefined | Element}  Returns an element if something wrong is found, otherwise it's undefined\n     */\n    Heap.prototype.check = function () {\n        var _this = this;\n        return this.heapArray.find(function (el, j) { return !!_this.getChildrenOf(j).find(function (ch) { return _this.compare(el, ch) > 0; }); });\n    };\n    /**\n     * Remove all of the elements from this heap.\n     */\n    Heap.prototype.clear = function () {\n        this.heapArray = [];\n    };\n    /**\n     * Clone this heap\n     * @return {Heap}\n     */\n    Heap.prototype.clone = function () {\n        var cloned = new Heap(this.comparator());\n        cloned.heapArray = this.toArray();\n        cloned._limit = this._limit;\n        return cloned;\n    };\n    /**\n     * Returns the comparison function.\n     * @return {Function}\n     */\n    Heap.prototype.comparator = function () {\n        return this.compare;\n    };\n    /**\n     * Returns true if this queue contains the specified element.\n     * @param  {any}      o   Element to be found\n     * @param  {Function} fn  Optional comparison function, receives (element, needle)\n     * @return {Boolean}\n     */\n    Heap.prototype.contains = function (o, fn) {\n        if (fn === void 0) { fn = Heap.defaultIsEqual; }\n        return this.heapArray.findIndex(function (el) { return fn(el, o); }) >= 0;\n    };\n    /**\n     * Initialise a heap, sorting nodes\n     * @param  {Array} array Optional initial state array\n     */\n    Heap.prototype.init = function (array) {\n        if (array) {\n            this.heapArray = __spreadArray([], __read(array), false);\n        }\n        for (var i = Math.floor(this.heapArray.length); i >= 0; --i) {\n            this._sortNodeDown(i);\n        }\n        this._applyLimit();\n    };\n    /**\n     * Test if the heap has no elements.\n     * @return {Boolean} True if no elements on the heap\n     */\n    Heap.prototype.isEmpty = function () {\n        return this.length === 0;\n    };\n    /**\n     * Get the leafs of the tree (no children nodes)\n     */\n    Heap.prototype.leafs = function () {\n        if (this.heapArray.length === 0) {\n            return [];\n        }\n        var pi = Heap.getParentIndexOf(this.heapArray.length - 1);\n        return this.heapArray.slice(pi + 1);\n    };\n    Object.defineProperty(Heap.prototype, \"length\", {\n        /**\n         * Length of the heap.\n         * @return {Number}\n         */\n        get: function () {\n            return this.heapArray.length;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Heap.prototype, \"limit\", {\n        /**\n         * Get length limit of the heap.\n         * @return {Number}\n         */\n        get: function () {\n            return this._limit;\n        },\n        /**\n         * Set length limit of the heap.\n         * @return {Number}\n         */\n        set: function (_l) {\n            this._limit = ~~_l;\n            this._applyLimit();\n        },\n        enumerable: false,\n        configurable: true\n    });\n    /**\n     * Top node. Aliases: `element`.\n     * Same as: `top(1)[0]`\n     * @return {any} Top node\n     */\n    Heap.prototype.peek = function () {\n        return this.heapArray[0];\n    };\n    /**\n     * Extract the top node (root). Aliases: `poll`.\n     * @return {any} Extracted top node, undefined if empty\n     */\n    Heap.prototype.pop = function () {\n        var last = this.heapArray.pop();\n        if (this.length > 0 && last !== undefined) {\n            return this.replace(last);\n        }\n        return last;\n    };\n    /**\n     * Pushes element(s) to the heap.\n     * @param  {...any} elements Elements to insert\n     * @return {Boolean} True if elements are present\n     */\n    Heap.prototype.push = function () {\n        var elements = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            elements[_i] = arguments[_i];\n        }\n        if (elements.length < 1) {\n            return false;\n        }\n        else if (elements.length === 1) {\n            return this.add(elements[0]);\n        }\n        else {\n            return this.addAll(elements);\n        }\n    };\n    /**\n     * Same as push & pop in sequence, but faster\n     * @param  {any} element Element to insert\n     * @return {any}  Extracted top node\n     */\n    Heap.prototype.pushpop = function (element) {\n        var _a;\n        if (this.compare(this.heapArray[0], element) < 0) {\n            _a = __read([this.heapArray[0], element], 2), element = _a[0], this.heapArray[0] = _a[1];\n            this._sortNodeDown(0);\n        }\n        return element;\n    };\n    /**\n     * Remove an element from the heap.\n     * @param  {any}   o      Element to be found\n     * @param  {Function} fn  Optional function to compare\n     * @return {Boolean}      True if the heap was modified\n     */\n    Heap.prototype.remove = function (o, fn) {\n        if (fn === void 0) { fn = Heap.defaultIsEqual; }\n        if (this.length > 0) {\n            if (o === undefined) {\n                this.pop();\n                return true;\n            }\n            else {\n                var idx = this.heapArray.findIndex(function (el) { return fn(el, o); });\n                if (idx >= 0) {\n                    if (idx === 0) {\n                        this.pop();\n                    }\n                    else if (idx === this.length - 1) {\n                        this.heapArray.pop();\n                    }\n                    else {\n                        this.heapArray.splice(idx, 1, this.heapArray.pop());\n                        this._sortNodeUp(idx);\n                        this._sortNodeDown(idx);\n                    }\n                    return true;\n                }\n            }\n        }\n        return false;\n    };\n    /**\n     * Pop the current peek value, and add the new item.\n     * @param  {any} element  Element to replace peek\n     * @return {any}         Old peek\n     */\n    Heap.prototype.replace = function (element) {\n        var peek = this.heapArray[0];\n        this.heapArray[0] = element;\n        this._sortNodeDown(0);\n        return peek;\n    };\n    /**\n     * Size of the heap\n     * @return {Number}\n     */\n    Heap.prototype.size = function () {\n        return this.length;\n    };\n    /**\n     * Return the top (highest value) N elements of the heap.\n     *\n     * @param  {Number} n  Number of elements.\n     * @return {Array}    Array of length <= N.\n     */\n    Heap.prototype.top = function (n) {\n        if (n === void 0) { n = 1; }\n        if (this.heapArray.length === 0 || n <= 0) {\n            // Nothing to do\n            return [];\n        }\n        else if (this.heapArray.length === 1 || n === 1) {\n            // Just the peek\n            return [this.heapArray[0]];\n        }\n        else if (n >= this.heapArray.length) {\n            // The whole peek\n            return __spreadArray([], __read(this.heapArray), false);\n        }\n        else {\n            // Some elements\n            var result = this._topN_push(~~n);\n            return result;\n        }\n    };\n    /**\n     * Clone the heap's internal array\n     * @return {Array}\n     */\n    Heap.prototype.toArray = function () {\n        return __spreadArray([], __read(this.heapArray), false);\n    };\n    /**\n     * String output, call to Array.prototype.toString()\n     * @return {String}\n     */\n    Heap.prototype.toString = function () {\n        return this.heapArray.toString();\n    };\n    /**\n     * Get the element at the given index.\n     * @param  {Number} i Index to get\n     * @return {any}       Element at that index\n     */\n    Heap.prototype.get = function (i) {\n        return this.heapArray[i];\n    };\n    /**\n     * Get the elements of these node's children\n     * @param  {Number} idx Node index\n     * @return {Array(any)}  Children elements\n     */\n    Heap.prototype.getChildrenOf = function (idx) {\n        var _this = this;\n        return Heap.getChildrenIndexOf(idx)\n            .map(function (i) { return _this.heapArray[i]; })\n            .filter(function (e) { return e !== undefined; });\n    };\n    /**\n     * Get the element of this node's parent\n     * @param  {Number} idx Node index\n     * @return {any}     Parent element\n     */\n    Heap.prototype.getParentOf = function (idx) {\n        var pi = Heap.getParentIndexOf(idx);\n        return this.heapArray[pi];\n    };\n    /**\n     * Iterator interface\n     */\n    Heap.prototype[Symbol.iterator] = function () {\n        return __generator(this, function (_a) {\n            switch (_a.label) {\n                case 0:\n                    if (!this.length) return [3 /*break*/, 2];\n                    return [4 /*yield*/, this.pop()];\n                case 1:\n                    _a.sent();\n                    return [3 /*break*/, 0];\n                case 2: return [2 /*return*/];\n            }\n        });\n    };\n    /**\n     * Returns an iterator. To comply with Java interface.\n     */\n    Heap.prototype.iterator = function () {\n        return this.toArray();\n    };\n    /**\n     * Limit heap size if needed\n     */\n    Heap.prototype._applyLimit = function () {\n        if (this._limit && this._limit < this.heapArray.length) {\n            var rm = this.heapArray.length - this._limit;\n            // It's much faster than splice\n            while (rm) {\n                this.heapArray.pop();\n                --rm;\n            }\n        }\n    };\n    /**\n     * Return the bottom (lowest value) N elements of the heap, without corner cases, unsorted\n     *\n     * @param  {Number} n  Number of elements.\n     * @return {Array}     Array of length <= N.\n     */\n    Heap.prototype._bottomN_push = function (n) {\n        // Use an inverted heap\n        var bottomHeap = new Heap(this.compare);\n        bottomHeap.limit = n;\n        bottomHeap.heapArray = this.heapArray.slice(-n);\n        bottomHeap.init();\n        var startAt = this.heapArray.length - 1 - n;\n        var parentStartAt = Heap.getParentIndexOf(startAt);\n        var indices = [];\n        for (var i = startAt; i > parentStartAt; --i) {\n            indices.push(i);\n        }\n        var arr = this.heapArray;\n        while (indices.length) {\n            var i = indices.shift();\n            if (this.compare(arr[i], bottomHeap.peek()) > 0) {\n                bottomHeap.replace(arr[i]);\n                if (i % 2) {\n                    indices.push(Heap.getParentIndexOf(i));\n                }\n            }\n        }\n        return bottomHeap.toArray();\n    };\n    /**\n     * Move a node to a new index, switching places\n     * @param  {Number} j First node index\n     * @param  {Number} k Another node index\n     */\n    Heap.prototype._moveNode = function (j, k) {\n        var _a;\n        _a = __read([this.heapArray[k], this.heapArray[j]], 2), this.heapArray[j] = _a[0], this.heapArray[k] = _a[1];\n    };\n    /**\n     * Move a node down the tree (to the leaves) to find a place where the heap is sorted.\n     * @param  {Number} i Index of the node\n     */\n    Heap.prototype._sortNodeDown = function (i) {\n        var _this = this;\n        var moveIt = i < this.heapArray.length - 1;\n        var self = this.heapArray[i];\n        var getPotentialParent = function (best, j) {\n            if (_this.heapArray.length > j && _this.compare(_this.heapArray[j], _this.heapArray[best]) < 0) {\n                best = j;\n            }\n            return best;\n        };\n        while (moveIt) {\n            var childrenIdx = Heap.getChildrenIndexOf(i);\n            var bestChildIndex = childrenIdx.reduce(getPotentialParent, childrenIdx[0]);\n            var bestChild = this.heapArray[bestChildIndex];\n            if (typeof bestChild !== 'undefined' && this.compare(self, bestChild) > 0) {\n                this._moveNode(i, bestChildIndex);\n                i = bestChildIndex;\n            }\n            else {\n                moveIt = false;\n            }\n        }\n    };\n    /**\n     * Move a node up the tree (to the root) to find a place where the heap is sorted.\n     * @param  {Number} i Index of the node\n     */\n    Heap.prototype._sortNodeUp = function (i) {\n        var moveIt = i > 0;\n        while (moveIt) {\n            var pi = Heap.getParentIndexOf(i);\n            if (pi >= 0 && this.compare(this.heapArray[pi], this.heapArray[i]) > 0) {\n                this._moveNode(i, pi);\n                i = pi;\n            }\n            else {\n                moveIt = false;\n            }\n        }\n    };\n    /**\n     * Return the top (highest value) N elements of the heap, without corner cases, unsorted\n     * Implementation: push.\n     *\n     * @param  {Number} n  Number of elements.\n     * @return {Array}     Array of length <= N.\n     */\n    Heap.prototype._topN_push = function (n) {\n        // Use an inverted heap\n        var topHeap = new Heap(this._invertedCompare);\n        topHeap.limit = n;\n        var indices = [0];\n        var arr = this.heapArray;\n        while (indices.length) {\n            var i = indices.shift();\n            if (i < arr.length) {\n                if (topHeap.length < n) {\n                    topHeap.push(arr[i]);\n                    indices.push.apply(indices, __spreadArray([], __read(Heap.getChildrenIndexOf(i)), false));\n                }\n                else if (this.compare(arr[i], topHeap.peek()) < 0) {\n                    topHeap.replace(arr[i]);\n                    indices.push.apply(indices, __spreadArray([], __read(Heap.getChildrenIndexOf(i)), false));\n                }\n            }\n        }\n        return topHeap.toArray();\n    };\n    /**\n     * Return the top (highest value) N elements of the heap, without corner cases, unsorted\n     * Implementation: init + push.\n     *\n     * @param  {Number} n  Number of elements.\n     * @return {Array}     Array of length <= N.\n     */\n    Heap.prototype._topN_fill = function (n) {\n        // Use an inverted heap\n        var heapArray = this.heapArray;\n        var topHeap = new Heap(this._invertedCompare);\n        topHeap.limit = n;\n        topHeap.heapArray = heapArray.slice(0, n);\n        topHeap.init();\n        var branch = Heap.getParentIndexOf(n - 1) + 1;\n        var indices = [];\n        for (var i = branch; i < n; ++i) {\n            indices.push.apply(indices, __spreadArray([], __read(Heap.getChildrenIndexOf(i).filter(function (l) { return l < heapArray.length; })), false));\n        }\n        if ((n - 1) % 2) {\n            indices.push(n);\n        }\n        while (indices.length) {\n            var i = indices.shift();\n            if (i < heapArray.length) {\n                if (this.compare(heapArray[i], topHeap.peek()) < 0) {\n                    topHeap.replace(heapArray[i]);\n                    indices.push.apply(indices, __spreadArray([], __read(Heap.getChildrenIndexOf(i)), false));\n                }\n            }\n        }\n        return topHeap.toArray();\n    };\n    /**\n     * Return the top (highest value) N elements of the heap, without corner cases, unsorted\n     * Implementation: heap.\n     *\n     * @param  {Number} n  Number of elements.\n     * @return {Array}     Array of length <= N.\n     */\n    Heap.prototype._topN_heap = function (n) {\n        var topHeap = this.clone();\n        var result = [];\n        for (var i = 0; i < n; ++i) {\n            result.push(topHeap.pop());\n        }\n        return result;\n    };\n    /**\n     * Return index of the top element\n     * @param list\n     */\n    Heap.prototype._topIdxOf = function (list) {\n        if (!list.length) {\n            return -1;\n        }\n        var idx = 0;\n        var top = list[idx];\n        for (var i = 1; i < list.length; ++i) {\n            var comp = this.compare(list[i], top);\n            if (comp < 0) {\n                idx = i;\n                top = list[i];\n            }\n        }\n        return idx;\n    };\n    /**\n     * Return the top element\n     * @param list\n     */\n    Heap.prototype._topOf = function () {\n        var list = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            list[_i] = arguments[_i];\n        }\n        var heap = new Heap(this.compare);\n        heap.init(list);\n        return heap.peek();\n    };\n    return Heap;\n}());\n\nexport { Heap, Heap as default, toInt };\n","import Heap from 'heap-js';\nimport { Log } from 'logging';\n\nconst { errorLog } = Log.get('TimerQueue');\n\nexport class TimerQueueTimer {\n    constructor(\n        public readonly handle: number,\n        public callback: () => unknown,\n        public readonly time: number) {\n    }\n\n    public clear() {\n        this.callback = null;\n    }\n}\n\nlet nextHandle = 1;\n\nexport class TimerQueue {\n    private readonly map = new Map<number, TimerQueueTimer>();\n    private readonly heap = new Heap<TimerQueueTimer>((a: TimerQueueTimer, b: TimerQueueTimer) => b.time - a.time);\n\n    public enqueue(delayMs: number, callback: () => unknown): TimerQueueTimer {\n        const handle = nextHandle++;\n        if (handle & 15) {\n            // We want to make sure expired timers trigger even if triggerExpired()\n            // somehow isn't invoked explicitly.\n            this.triggerExpired();\n        }\n\n        const now = Date.now();\n        const timer = new TimerQueueTimer(handle, callback, now + delayMs);\n        this.map.set(timer.handle, timer);\n        this.heap.add(timer);\n        return timer;\n    }\n\n    public get(handle: number): TimerQueueTimer | undefined {\n        return this.map.get(handle);\n    }\n\n    public readonly triggerExpired = (): void =>  {\n        const now = Date.now();\n        for (;;) {\n            const timer = this.heap.peek();\n            if (!timer || timer.time > now)\n                break;\n            this.heap.pop();\n            this.map.delete(timer.handle);\n            if (!timer.callback)\n                continue\n\n            try {\n                timer.callback();\n            }\n            catch (e) {\n                errorLog?.log('Callback failed:', e);\n            }\n        }\n    }\n\n    // setTimeout / clearTimeout\n\n    public readonly setTimeout = (callback: () => unknown, delayMs: number): number => {\n        return this.enqueue(delayMs, callback).handle;\n    }\n\n    public readonly clearTimeout = (handle: number): void => {\n        this.get(handle)?.clear();\n    }\n}\n\nconst setTimeoutImpl = globalThis['setTimeout'] as (callback: () => unknown, delayMs: number) => number;\nconst clearTimeoutImpl = globalThis['clearTimeout'] as (handle: number) => void;\n\nexport const timerQueue = !setTimeoutImpl ? new TimerQueue() : null;\nexport const setTimeout = timerQueue ? timerQueue.setTimeout : setTimeoutImpl;\nexport const clearTimeout = timerQueue ? timerQueue.clearTimeout : clearTimeoutImpl;\n","import { Log } from 'logging';\nimport { timerQueue } from 'timerQueue';\n\nconst { warnLog } = Log.get('WarmUpAudioWorkletProcessor');\n/* eslint-disable @typescript-eslint/ban-ts-comment */\n/**\n * Produces silence. We use the worklet to warm up a browser's audio pipeline.\n * Lives in [AudioWorkletGlobalScope]{@link https://developer.mozilla.org/en-US/docs/Web/API/AudioWorkletGlobalScope} */\nclass WarmUpAudioWorkletProcessor extends AudioWorkletProcessor {\n    private isStopped = false;\n    private wroteSilence = false;\n\n    constructor(options: AudioWorkletNodeOptions) {\n        super(options);\n        this.port.onmessage = this.onNodeMessage;\n    }\n\n    public process(\n        _inputs: Float32Array[][],\n        outputs: Float32Array[][],\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        _parameters: { [name: string]: Float32Array; }\n    ): boolean {\n        timerQueue?.triggerExpired();\n        // we should write silence at least once\n        if (this.isStopped && this.wroteSilence) {\n            this.port.postMessage('stopped');\n            return false;\n        }\n\n        if (outputs == null || outputs.length === 0 || outputs[0].length === 0) {\n            return true;\n        }\n        const output = outputs[0];\n        const channel = output[0];\n\n        // write silence\n        channel.fill(0);\n        this.wroteSilence = true;\n        return true;\n    }\n\n    private onNodeMessage = (ev: MessageEvent<string>): void => {\n        const msg = ev.data;\n        warnLog?.assert(msg === 'stop', `WarmUpAudioWorkletProcessor: Unsupported message: ${msg}`);\n        this.isStopped = true;\n    };\n}\n\nregisterProcessor('warmUpWorklet', WarmUpAudioWorkletProcessor);\n"],"names":["LogLevel","StorageKey","DateStorageKey","MaxStorageAge","isWorkerOrWorklet","globalThis","initLogging","Log","Info","minLevels","wasRestored","LogLevelController","sessionStorage","dateJson","getItem","Date","now","JSON","parse","readJson","readMinLevels","Map","size","clear","forEach","value","key","set","restore","console","log","constructor","override","scope","newLevel","this","persist","reset","isProduction","defaultLevel","undefined","setItem","stringify","Array","from","entries","Debug","level","prefix","data","debug","Warn","warn","Error","error","None","trace","get","isInitialized","minLevel","defaultMinLevel","getLogger","loggerFactory","logScope","debugLog","infoLog","warnLog","errorLog","ref","logRefs","assert","predicate","capacity","idSeed","items","itemIndex","findIndex","el","target","existentItem","touchedAt","id","newRef","length","removeOldest","newItem","push","indexToEliminate","itemToEliminate","i","item","splice","toString","__generator","thisArg","body","f","y","t","g","_","label","sent","trys","ops","next","verb","Symbol","iterator","n","v","op","TypeError","call","done","pop","e","step","__read","o","m","r","ar","__spreadArray","to","pack","arguments","l","prototype","slice","concat","Heap","compare","minComparator","_this","heapArray","_limit","offer","add","element","peek","poll","_invertedCompare","a","b","getChildrenIndexOf","idx","getParentIndexOf","whichChildren","Math","floor","getSiblingIndexOf","maxComparator","minComparatorNumber","maxComparatorNumber","defaultIsEqual","print","heap","deep","pi","log2","repeat","str","times","out","node","lines","maxLines","maxLength","nodeText","String","map","line","pow","half","ceil","join","heapify","arr","init","heappop","heapArr","heappush","heappushpop","pushpop","heapreplace","replace","heaptop","top","heapbottom","bottom","nlargest","iterable","nsmallest","_sortNodeUp","_applyLimit","addAll","elements","_a","apply","_bottomN_push","check","find","j","getChildrenOf","ch","clone","cloned","comparator","toArray","contains","fn","array","_sortNodeDown","isEmpty","leafs","Object","defineProperty","enumerable","configurable","_l","last","_i","remove","_topN_push","filter","getParentOf","rm","bottomHeap","limit","startAt","parentStartAt","indices","shift","_moveNode","k","moveIt","self","getPotentialParent","best","childrenIdx","bestChildIndex","reduce","bestChild","topHeap","_topN_fill","_topN_heap","result","_topIdxOf","list","_topOf","TimerQueueTimer","handle","callback","time","nextHandle","setTimeoutImpl","clearTimeoutImpl","timerQueue","triggerExpired","timer","delete","setTimeout","delayMs","enqueue","clearTimeout","WarmUpAudioWorkletProcessor","AudioWorkletProcessor","options","super","isStopped","wroteSilence","onNodeMessage","ev","msg","port","onmessage","process","_inputs","outputs","_parameters","postMessage","fill","registerProcessor"],"sourceRoot":""}