{"version":3,"file":"vadWorklet.js","mappings":"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","sources":["webpack:///webpack/bootstrap","webpack:///webpack/runtime/define property getters","webpack:///webpack/runtime/hasOwnProperty shorthand","webpack:///./src/_constants.ts","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/timeout.ts","webpack:///./src/promises.ts","webpack:///./src/rpc.ts","webpack:///./src/object-pool.ts","webpack:///./src/resettable.ts","webpack:///../dotnet/UI.Blazor.App/Components/AudioRecorder/audio-ring-buffer.ts","webpack:///../dotnet/UI.Blazor.App/Components/AudioRecorder/worklets/audio-vad-worklet-processor.ts"],"sourcesContent":["// The require scope\nvar __webpack_require__ = {};\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// All crucial constants are here\n// !DELAYER means it affects on audio delay.\n\ntype AllowedSampleRate = 48000 | 16000;\n\nconst REC_SAMPLES_PER_MS = 16; // 16KHz\nexport const AUDIO_REC = {\n    SAMPLE_RATE: 1000 * REC_SAMPLES_PER_MS as AllowedSampleRate,\n    SAMPLES_PER_MS: REC_SAMPLES_PER_MS,\n    SAMPLES_PER_WINDOW_32: REC_SAMPLES_PER_MS * 32,\n    SAMPLES_PER_WINDOW_30: REC_SAMPLES_PER_MS * 30,\n    SAMPLES_PER_RECORDING_IN_PROGRESS_CALL: REC_SAMPLES_PER_MS * 200,\n    // In seconds:\n    SAMPLE_DURATION: 0.001 / REC_SAMPLES_PER_MS,\n    MIN_RECORDING_GAIN: 0.0005, // Min gain to consider recording as \"active\"\n    MIN_MICROPHONE_GAIN: 0, // Min gain to consider microphone sends real samples\n}\n\nconst PLAY_SAMPLES_PER_MS = 48; // 48KHz\nexport const AUDIO_PLAY = {\n    SAMPLE_RATE: 1000 * PLAY_SAMPLES_PER_MS as AllowedSampleRate,\n    SAMPLES_PER_MS: PLAY_SAMPLES_PER_MS,\n    SAMPLES_PER_WINDOW: 20 * PLAY_SAMPLES_PER_MS, // 20ms\n    // In seconds:\n    SAMPLE_DURATION: 0.001 / PLAY_SAMPLES_PER_MS,\n    BUFFER_TO_PLAY_DURATION: 0.1, // !DELAYER: How much to buffer before we start playing\n    BUFFER_LOW_DURATION: 10.0, // Buffer is \"low\" while it's less than this\n    STATE_UPDATE_PERIOD: 0.2, // The period between feeder state update signals\n    MEDIA_SESSION_RESET_DEBOUNCE_MS: 5000, // The period to debounce media session metadata (displays info that Actual Chat is playing at iOS) reset\n}\n\nconst ENC_FRAME_DURATION_MS = 20; // 20ms\nconst ENC_BIT_RATE = 32 * 1024; // 32Kbps = 4KB/s = ~80 bytes per frame\nconst ENC_BYTE_RATE = Math.round(ENC_BIT_RATE / 8);\nconst ENC_FRAME_BYTES = Math.round(ENC_BIT_RATE * ENC_FRAME_DURATION_MS / 1000 / 8);\nexport const AUDIO_ENCODER = {\n    FRAME_DURATION_MS: ENC_FRAME_DURATION_MS,\n    BIT_RATE: ENC_BIT_RATE,\n    BYTE_RATE: ENC_BYTE_RATE,\n    FRAME_SAMPLES: REC_SAMPLES_PER_MS * ENC_FRAME_DURATION_MS,\n    FRAME_BYTES: ENC_FRAME_BYTES,\n    FRAME_BUFFER_BYTES: 2 * ENC_FRAME_BYTES,\n    FADE_FRAMES: 3, // 60ms, it's fade-in @ start and fade-out @ the end\n    MAX_BUFFERED_FRAMES: 50, // 1s, it doesn't have to be large now, coz frames are instantly added to streams\n    DEFAULT_PRE_SKIP: 312, // Pre-skip / codec delay measured in samples. It's the default one, used w/ system encoder, which doesn't provide it.\n}\n\nexport const AUDIO_STREAMER = {\n    MAX_STREAMS: 3, // Max streams to keep sending\n    DELAY_FRAMES: 5, // 100ms - !DELAYER: streamer won't start sending until it gets these frames (~400 bytes)\n    MIN_PACK_FRAMES: 3, // 60ms - min. # of frames to send at once (~240 bytes)\n    MAX_PACK_FRAMES: 10, // 200ms - max. # of frames to send at once (~800 bytes)\n    MAX_BUFFERED_FRAMES: 1500, // 30s (~120KB)\n    MAX_SPEED: 2, // Max streaming speed - relative to real-time; must be >1, but not too high to avoid queued stream overlap\n    // In seconds:\n    INTER_STREAM_DELAY: 0.1, // Must be >0\n    MAX_CONNECT_DURATION: 5, // Max duration of \"connecting\" state of SignalR connection inside ensureConnected\n    MAX_QUICK_CONNECT_DURATION: 0.5, // Same as above, but when quickReconnect = true\n    STREAM_ERROR_DELAY: 1,\n    CONNECT_ERROR_DELAY: 1,\n    DEBUG: { // Debug switches\n        RANDOM_DISCONNECT_PERIOD_MS: 0, // Random disconnect period, 5000 is a good one\n    }\n}\n\nexport const AUDIO_VAD = {\n    // All durations below are in seconds\n    MIN_SPEECH: 0.5, // When the speech is detected, it will always send at this much at least\n    MAX_SPEECH: 60 * 2, // Max speech duration - if it takes longer, VAD will generate a hard split anyway\n    MIN_SPEECH_TO_CANCEL_PAUSE: 0.15, // Min. speech duration required to cancel non-materialized pause\n    MIN_PAUSE: 0.2, // Min pause duration that triggers split\n    MAX_PAUSE: 2.7, // Max pause duration that triggers split\n    MAX_CONV_PAUSE: 0.65, // Max pause duration that triggers pause in \"conversation\" mode\n    CONV_DURATION: 30, // A period from conversationSignal to the moment VAD assumes the conversation ended\n    PAUSE_VARIES_FROM: 10, // Pause starts to vary from (MAX_PAUSE or MAX_CONV_PAUSE) to MIN_PAUSE at this speech duration\n    PAUSE_VARY_POWER: Math.sqrt(2), // The power used in max_pause = lerp(MAX_PAUSE, MIN_PAUSE, pow(alpha, THIS_VALUE))\n    SKIP_FIRST_RECORDING_MS: 300, // Microphone stream begins with some noise that triggers WebRTC VAD\n    SKIP_SEQUENTIAL_CALLS_MS: 5, // Skip batch calls to VAD when duration between calls is less than 5ms - VAD works with 30ms and 32 ms chunks\n    // All durations below are in samples (16KHz = 16 samples per ms)\n    NN_VAD_CONTEXT_SAMPLES: 64, // 4ms, the length of NN VAD buffer \"prefix\" copied from the end of prev. buffer\n};\n","// 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","// nextTick & nextTickAsync are quite similar to polyfill of\n// [setImmediate](https://developer.mozilla.org/en-US/docs/Web/API/Window/setImmediate),\n// which we don't use because it relies on setTimeout, which is throttled in background tabs.\nimport { Disposable } from 'disposable';\nimport { setTimeout, clearTimeout } from 'timerQueue';\n\nlet nextTickImpl: (callback: () => unknown) => void = null;\n\nif (globalThis['MessageChannel']) {\n    const nextTickCallbacks = new Array<() => unknown>();\n    const nextTickChannel = new MessageChannel();\n    nextTickChannel.port1.onmessage = () => {\n        const callback = nextTickCallbacks.shift();\n        callback();\n    };\n\n    nextTickImpl = (callback: () => unknown) => {\n        nextTickCallbacks.push(callback);\n        nextTickChannel.port2.postMessage(null);\n    }\n}\nelse {\n    // MessageChannel is unavailable in AudioWorklets, so we use setTimeout-based version here,\n    // which implies ~ 8-9ms delay in average.\n    nextTickImpl = (callback: () => unknown) => setTimeout(callback, 0);\n}\n\nexport const nextTick = nextTickImpl;\nexport const nextTickAsync = () => new Promise<void>(resolve => nextTick(resolve));\n\n// Timeout: a nicer wrapper around setTimeout\n\nexport class Timeout implements Disposable {\n    protected handle: number | null = null;\n\n    static start(isPrecise: boolean, timeoutMs: number, callback: () => unknown): Timeout {\n        return isPrecise\n            ? new PreciseTimeout(timeoutMs, callback)\n            : new Timeout(timeoutMs, callback);\n    }\n\n    static startRegular(timeoutMs: number, callback: () => unknown): Timeout {\n        return new Timeout(timeoutMs, callback);\n    }\n\n    static startPrecise(timeoutMs: number, callback: () => unknown): PreciseTimeout {\n        return new PreciseTimeout(timeoutMs, callback);\n    }\n\n    constructor(timeoutMs?: number, callback?: () => unknown, handle?: number) {\n        if (handle) {\n            this.handle = handle;\n            return;\n        }\n\n        this.handle = setTimeout(callback, timeoutMs) as unknown as number;\n        return;\n    }\n\n    public dispose(): void {\n        this.clear();\n    }\n\n    public clear(): void {\n        if (this.handle) {\n            clearTimeout(this.handle)\n            this.handle = null;\n        }\n    }\n}\n\n// Precise timeout (5-16ms?) based on requestAnimationFrame\n\nconst disablePreciseTimeout = false;\n\nexport class PreciseTimeout extends Timeout {\n    constructor(timeoutMs: number, callback: () => unknown,) {\n        if (disablePreciseTimeout) {\n            super(timeoutMs, callback);\n            return;\n        }\n\n        // Precise timeout handling\n        const endsAt = Date.now() + timeoutMs;\n        const loop = () => {\n            if (Date.now() >= endsAt)\n                callback();\n            else\n                this.handle = requestAnimationFrame(loop);\n        };\n        super(undefined, undefined, requestAnimationFrame(loop));\n    }\n\n    public clear(): void {\n        if (disablePreciseTimeout)\n            return super.clear();\n\n        if (this.handle) {\n            cancelAnimationFrame(this.handle);\n            this.handle = null;\n        }\n    }\n}\n","import { Log } from 'logging';\nimport { PreciseTimeout, Timeout } from 'timeout';\nimport { Disposable } from 'disposable';\n\nconst { logScope, debugLog, warnLog, errorLog } = Log.get('promises');\n\nexport class TimedOut {\n    public static readonly instance: TimedOut = new TimedOut();\n}\n\nexport function isPromise<T, S>(obj: PromiseLike<T> | S): obj is PromiseLike<T> {\n    return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj['then'] === 'function';\n}\n\nexport class PromiseSource<T> implements Promise<T> {\n    public resolve: (T) => void;\n    public reject: (any) => void;\n\n    private readonly _promise: Promise<T>;\n    private _isCompleted = false;\n\n    constructor(resolve?: ((value: T) => void), reject?: ((reason?: unknown) => void)) {\n        this._promise = new Promise<T>((resolve1, reject1) => {\n            this.resolve = (value: T) => {\n                if (this._isCompleted)\n                    return;\n\n                this._isCompleted = true;\n                resolve1(value);\n                if (resolve)\n                    resolve(value);\n            };\n            this.reject = (reason: unknown) => {\n                if (this._isCompleted)\n                    return;\n\n                this._isCompleted = true;\n                reject1(reason);\n                if (reject)\n                    reject(reason);\n            };\n        })\n        this[Symbol.toStringTag] = this._promise[Symbol.toStringTag];\n    }\n\n    public isCompleted(): boolean {\n        return this._isCompleted;\n    }\n\n    // PromiseLike<T> implementation\n\n    readonly [Symbol.toStringTag]: string;\n\n    then<TResult1 = T, TResult2 = never>(\n        onfulfilled?: ((value: T) => (PromiseLike<TResult1> | TResult1)) | undefined | null,\n        onrejected?: ((reason: any) => (PromiseLike<TResult2> | TResult2)) | undefined | null\n    ): Promise<TResult1 | TResult2> {\n        return this._promise.then(onfulfilled, onrejected);\n    }\n\n    catch<TResult = never>(\n        onrejected?: ((reason: any) => (PromiseLike<TResult> | TResult)) | undefined | null\n    ): Promise<T | TResult> {\n        return this._promise.catch(onrejected);\n    }\n\n    finally(onfinally?: (() => void) | undefined | null): Promise<T> {\n        return this._promise.finally(onfinally);\n    }\n}\n\nexport class PromiseSourceWithTimeout<T> extends PromiseSource<T> {\n    private _timeout: Timeout = null;\n\n    constructor(resolve?: ((value: T) => void), reject?: ((reason?: unknown) => void)) {\n        super((value: T) => {\n            this.clearTimeout();\n            if (resolve)\n                resolve(value);\n        }, (reason: unknown) => {\n            this.clearTimeout();\n            if (reject)\n                reject(reason);\n        });\n    }\n\n    public hasTimeout(): boolean {\n        return this._timeout != null;\n    }\n\n    public setTimeout(timeoutMs: number | null, callback?: () => unknown): void {\n        if (this._timeout) {\n            this._timeout.clear();\n            this._timeout = null;\n        }\n        if (timeoutMs == null || this.isCompleted())\n            return;\n\n        this._timeout = new Timeout(timeoutMs, () => {\n            this._timeout = null;\n            if (callback != null)\n                callback();\n            else {\n                const error = new Error('The promise has timed out.');\n                this.reject(error);\n            }\n        })\n    }\n\n    public setPreciseTimeout(timeoutMs: number | null, callback?: () => unknown): void {\n        if (this._timeout) {\n            this._timeout.clear();\n            this._timeout = null;\n        }\n        if (timeoutMs == null || this.isCompleted())\n            return;\n\n        this._timeout = new PreciseTimeout(timeoutMs, () => {\n            this._timeout = null;\n            if (callback != null)\n                callback();\n            else {\n                const error = new Error('The promise has timed out.');\n                this.reject(error);\n            }\n        })\n    }\n\n    public clearTimeout(): void {\n        if (this._timeout == null)\n            return;\n\n        this._timeout.clear();\n        this._timeout = null;\n    }\n}\n\n// Cancellation\n\nexport type Cancelled = symbol;\nexport const cancelled : Cancelled = Symbol('Cancelled');\nexport class OperationCancelledError extends Error {\n    constructor(message?: string) {\n        super(message ?? 'The operation is cancelled.');\n    }\n}\n\nexport async function waitAsync<T>(promise: PromiseLike<T>, cancel?: Promise<Cancelled>): Promise<T> {\n    if (cancel === undefined)\n        return await promise;\n\n    const result = await Promise.race([promise, cancel]);\n    if (result === cancelled)\n        throw new OperationCancelledError();\n    return await promise;\n}\n\n// Async versions of setTimeout\n\nexport function delayAsync(delayMs: number): PromiseSourceWithTimeout<void> {\n    const promise = new PromiseSourceWithTimeout<void>();\n    promise.setTimeout(delayMs, () => promise.resolve(undefined))\n    return promise;\n}\n\nexport function delayAsyncWith<T>(delayMs: number, value: T): PromiseSourceWithTimeout<T> {\n    const promise = new PromiseSourceWithTimeout<T>();\n    promise.setTimeout(delayMs, () => { promise.resolve(value) });\n    return promise;\n}\n\nexport function preciseDelayAsync(delayMs: number): PromiseSourceWithTimeout<void> {\n    const promise = new PromiseSourceWithTimeout<void>();\n    promise.setPreciseTimeout(delayMs, () => promise.resolve(undefined))\n    return promise;\n}\n\nexport function flexibleDelayAsync(getNextTimeout: () => number): PromiseSourceWithTimeout<void> {\n    // eslint-disable-next-line no-constant-condition\n    const promise = new PromiseSourceWithTimeout<void>();\n    const timeoutHandler = () => {\n        const timeout = getNextTimeout();\n        if (timeout <= 0)\n            promise.resolve(undefined);\n        else\n            promise.setTimeout(timeout, timeoutHandler);\n    };\n    promise.setTimeout(getNextTimeout(), timeoutHandler);\n    return promise;\n}\n\n// Throttle & debounce\n\nexport interface ResettableFunc<T extends (...args: unknown[]) => unknown> {\n    (...args: Parameters<T>): void;\n    reset(): void;\n}\n\nclass Call<T extends (...args: unknown[]) => unknown> {\n    constructor(\n        readonly func: (...args: Parameters<T>) => ReturnType<T>,\n        readonly self: unknown,\n        readonly parameters: Parameters<T>\n    ) { }\n\n    public invoke(): unknown {\n        return this.func.apply(this.self, this.parameters);\n    }\n\n    public invokeSilently(): unknown {\n        try {\n            return this.invoke();\n        }\n        catch (error) {\n            errorLog?.log(`Call.invokeSafely: unhandled error:`, error)\n        }\n    }\n}\n\nexport type ThrottleMode = 'default' | 'skip' | 'delayHead';\n\nexport function throttle<T extends (...args: unknown[]) => unknown>(\n    func: (...args: Parameters<T>) => ReturnType<T>,\n    intervalMs: number,\n    mode: ThrottleMode = 'default',\n    name : string | undefined = undefined\n): ResettableFunc<T> {\n    let lastCall: Call<T> | null = null;\n    let nextFireTime = 0;\n    let timeoutHandle: ReturnType<typeof setTimeout> | null = null;\n\n    const reset = () => {\n        if (timeoutHandle !== null)\n            clearTimeout(timeoutHandle);\n        timeoutHandle = lastCall = null;\n        nextFireTime = 0;\n    }\n\n    const fire = () => {\n        if (timeoutHandle !== null)\n            clearTimeout(timeoutHandle);\n\n        if (lastCall !== null) {\n            if (name)\n                debugLog?.log(`throttle '${name}': fire`);\n            const call = lastCall;\n            lastCall = null;\n            nextFireTime = Date.now() + intervalMs;\n            timeoutHandle = setTimeout(fire, intervalMs);\n            call?.invokeSilently(); // This must be done at last\n        }\n        else {\n            if (name)\n                debugLog?.log(`throttle '${name}': delay ended`);\n            timeoutHandle = null;\n            nextFireTime = 0;\n        }\n    };\n\n    const result: ResettableFunc<T> = function(...callArgs: Parameters<T>): void {\n        const call = new Call<T>(func, this, callArgs);\n        const fireDelay = nextFireTime - Date.now();\n        if (timeoutHandle !== null && fireDelay <= 0) {\n            // Our delayed \"fire\" is ready to fire but not fired yet,\n            // so we \"flush\" it here.\n            fire();\n        }\n\n        if (timeoutHandle === null) {\n            // lastCall is null here\n            nextFireTime = Date.now() + intervalMs;\n            timeoutHandle = setTimeout(fire, intervalMs);\n            if (mode === 'delayHead') {\n                if (name)\n                    debugLog?.log(`throttle '${name}': delaying head call`);\n                lastCall = call;\n            } else { // skip or default mode\n                if (name)\n                    debugLog?.log(`throttle '${name}': fire (head call)`);\n                call?.invokeSilently();\n            }\n        } else {\n            // timeoutHandle !== null, so all we need to do here is to update lastCall\n            if (name)\n                debugLog?.log(`throttle '${name}': throttling, remaining delay = ${fireDelay}ms`);\n            if (mode !== 'skip') // i.e. delayHead\n                lastCall = call;\n        }\n    }\n    result.reset = reset;\n    return result;\n}\n\nexport function debounce<T extends (...args: unknown[]) => unknown>(\n    func: (...args: Parameters<T>) => ReturnType<T>,\n    intervalMs: number,\n    name : string | undefined = undefined\n): ResettableFunc<T> {\n    let lastCall: Call<T> | null = null;\n    let nextFireTime = 0;\n    let timeoutHandle: ReturnType<typeof setTimeout> | null = null;\n\n    const reset = () => {\n        // we should not clear timeout there because it leads to clear\\set timeout useless cycle\n        timeoutHandle = lastCall = null;\n        nextFireTime = 0;\n    }\n\n    const fire = () => {\n        if (timeoutHandle !== null)\n            clearTimeout(timeoutHandle);\n        timeoutHandle = null;\n\n        const fireDelay = nextFireTime - Date.now();\n        if (fireDelay <= 0) {\n            nextFireTime = 0;\n            if (lastCall !== null) {\n                if (name)\n                    debugLog?.log(`debounce '${name}': fire`);\n                const call = lastCall;\n                lastCall = null;\n                call?.invokeSilently(); // This must be done at last\n            }\n        }\n        else {\n            // debounce has already been called yet another time, but we have triggered on previous call timeout\n            // so let's schedule a new timer\n            timeoutHandle = setTimeout(fire, fireDelay);\n        }\n    };\n\n    const result: ResettableFunc<T> = function(...callArgs: Parameters<T>): void {\n        const call = new Call<T>(func, this, callArgs);\n\n        nextFireTime = Date.now() + intervalMs;\n        lastCall = call;\n\n        if (timeoutHandle === null)\n            timeoutHandle = setTimeout(fire, intervalMs);\n        if (name)\n            debugLog?.log(`debounce '${name}': debouncing`);\n    };\n    result.reset = reset;\n    return result;\n}\n\n// Serialize\n\nexport function serialize<T extends (...args: unknown[]) => PromiseLike<TResult> | TResult, TResult>(\n    func: (...args: Parameters<T>) => PromiseLike<TResult> | TResult,\n    limit: number | null = null\n): (...sArgs: Parameters<T>) => Promise<TResult> {\n    let lastCall: Promise<TResult> = Promise.resolve(null as TResult);\n    let queueSize = 0;\n\n    return function(...callArgs: Parameters<T>): Promise<TResult> {\n        if (limit != null && queueSize >= limit)\n            return lastCall;\n\n        queueSize++;\n        const prevCall = lastCall;\n        return lastCall = (async () => {\n            try {\n                await prevCall;\n                return (await func.apply(this, callArgs)) as TResult;\n            }\n            finally {\n                queueSize--;\n            }\n        })();\n    }\n}\n\n// Retry & catchErrors\n\ntype RetryDelaySeq = (tryIndex: number) => number;\nconst defaultRetryDelays: RetryDelaySeq = () => 50;\n\nexport async function retryForever<TResult>(\n    fn: (tryIndex: number, lastError: unknown) => PromiseLike<TResult> | TResult,\n    retryDelays?: RetryDelaySeq,\n) : Promise<TResult> {\n    retryDelays ??= defaultRetryDelays;\n    let lastError: unknown = undefined;\n    for (let tryIndex = 0;;) {\n        try {\n            return await fn(tryIndex, lastError);\n        }\n        catch (e) {\n            lastError = e;\n        }\n        ++tryIndex;\n        warnLog?.log(`retry(${tryIndex}): error:`, lastError);\n        await delayAsync(retryDelays(tryIndex));\n    }\n}\n\nexport async function retry<TResult>(\n    tryCount: number,\n    fn: (tryIndex: number, lastError: unknown) => PromiseLike<TResult> | TResult,\n    retryDelays?: RetryDelaySeq,\n) : Promise<TResult> {\n    retryDelays ??= defaultRetryDelays;\n    let lastError: unknown = undefined;\n    for (let tryIndex = 0;;) {\n        if (tryIndex >= tryCount)\n            throw lastError;\n\n        try {\n            return await fn(tryIndex, lastError);\n        }\n        catch (e) {\n            lastError = e;\n        }\n        ++tryIndex;\n        warnLog?.log(`retry(${tryIndex}/${tryCount}): error:`, lastError);\n        await delayAsync(retryDelays(tryIndex));\n    }\n}\n\nexport async function catchErrors<TResult>(\n    fn: () => PromiseLike<TResult> | TResult,\n    onError?: (e: unknown) => TResult,\n) : Promise<TResult> {\n    try {\n        return await fn();\n    }\n    catch (e) {\n        return onError ? onError(e) : undefined;\n    }\n}\n\nexport class AsyncLockReleaser implements Disposable {\n    private readonly _whenReleased: PromiseSource<void>;\n    constructor(public readonly asyncLock: AsyncLock) {\n        if (asyncLock.releaser != null)\n            throw new Error(`${logScope}.AsyncLockReleaser cannot be created while the lock is held.`);\n\n        asyncLock.releaser = this;\n        this._whenReleased = new PromiseSource<void>(\n            () => {\n                if (asyncLock.releaser != this)\n                    throw new Error(`${logScope}.AsyncLockReleaser is associated with another releaser.`);\n\n                asyncLock.releaser = null;\n                return;\n            },\n            () => `${logScope}.AsyncLockReleaser.released cannot be rejected.`);\n    }\n\n    public whenReleased(): Promise<void> {\n        return this._whenReleased;\n    }\n\n    dispose(): void {\n        this._whenReleased.resolve(undefined);\n    }\n}\n\nexport class AsyncLock {\n    public releaser: AsyncLockReleaser = null;\n\n    public async lock(): Promise<AsyncLockReleaser> {\n        if (this.releaser != null)\n            await this.releaser.whenReleased();\n        return new AsyncLockReleaser(this);\n    }\n}\n\nexport class ResolvedPromise {\n    public static readonly Void = new PromiseSource<void>();\n    public static readonly True = new PromiseSource<boolean>();\n    public static readonly False = new PromiseSource<boolean>();\n}\nResolvedPromise.Void.resolve(undefined);\nResolvedPromise.True.resolve(true);\nResolvedPromise.False.resolve(false);\n\n// Self-test - we don't want to run it in workers & worklets\nconst mustRunSelfTest = debugLog != null && globalThis['focus'];\nif (mustRunSelfTest) {\n    const testLog = errorLog;\n    if (!testLog)\n        throw new Error('testLog == null');\n    void (async () => {\n        const c = new PromiseSource<Cancelled>();\n        const p = waitAsync(delayAsync(1000), c);\n        c.resolve(cancelled);\n        try {\n            await p;\n            throw new Error('Failed!');\n        }\n        catch (e) {\n            if (!(e instanceof OperationCancelledError))\n                throw e;\n        }\n    })();\n}\n","import { delayAsync, PromiseSourceWithTimeout, ResolvedPromise } from 'promises';\nimport { Disposable } from 'disposable';\nimport { Log } from 'logging';\n\nconst { debugLog, warnLog, errorLog } = Log.get('Rpc');\n\nexport type RpcNoWait = symbol;\nexport const rpcNoWait : RpcNoWait = Symbol('RpcNoWait');\n\nexport interface RpcTimeout {\n    type: 'rpc-timeout',\n    timeoutMs: number;\n}\n\nexport class RpcCall {\n    public readonly timeoutMs?: number;\n\n    constructor(\n        public id: number,\n        public readonly method: string,\n        public readonly args: unknown[],\n        timeoutMs?: number,\n        public readonly noWait: boolean = false,\n    ) {\n        this.timeoutMs = timeoutMs ?? null;\n        if (args?.length > 0) {\n            const lastArg = args[args.length - 1];\n            if (lastArg == rpcNoWait) {\n                args.pop();\n                this.noWait = true;\n            }\n            else if (lastArg['type'] && lastArg['type'] === 'rpc-timeout') {\n                args.pop();\n                const rpcTimeout = lastArg as RpcTimeout;\n                this.timeoutMs = rpcTimeout.timeoutMs;\n            }\n        }\n    }\n}\n\nexport class RpcResult {\n    public static value(id: number, value: unknown): RpcResult {\n        return new RpcResult(id, value, undefined);\n    }\n\n    public static error(id: number, error: unknown): RpcResult {\n        return new RpcResult(id, undefined, error);\n    }\n\n    constructor(\n        public readonly id: number,\n        public readonly value: unknown,\n        public readonly error: unknown,\n    ) { }\n}\n\nlet nextRpcPromiseId = 1;\nconst rpcPromisesInProgress = new Map<number, RpcPromise<unknown>>();\n\nexport class RpcPromise<T> extends PromiseSourceWithTimeout<T> {\n    public readonly id: number;\n    public static Void = new RpcPromise<void>('Void' as unknown as number);\n\n    constructor(id?: number) {\n        super();\n        this.id = id ?? nextRpcPromiseId++;\n        const oldResolve = this.resolve;\n        const oldReject = this.reject;\n        this.resolve = (value: T) => {\n            debugLog?.log(`RpcPromise.resolve[#${this.id}] =`, value)\n            this.unregister();\n            oldResolve(value);\n        };\n        this.reject = (reason: unknown) => {\n            debugLog?.log(`RpcPromise.reject[#${this.id}] =`, reason)\n            this.unregister();\n            oldReject(reason);\n        };\n        rpcPromisesInProgress.set(this.id, this);\n        // debugLog?.log(`RpcPromise.ctor[#${this.id}]`);\n    }\n\n    public static get<T>(id: number): RpcPromise<T> | null {\n        return rpcPromisesInProgress.get(id) as RpcPromise<T> ?? null;\n    }\n\n    public unregister(): boolean {\n        return rpcPromisesInProgress.delete(this.id);\n    }\n}\n\nRpcPromise.Void.resolve(undefined);\n\nexport function completeRpc(result: RpcResult): void {\n    const promise = RpcPromise.get<unknown>(result.id);\n    if (promise == null) {\n        // eslint-disable-next-line no-debugger\n        warnLog?.log(`completeRpc: RpcPromise #${result.id} is not found`);\n        return;\n    }\n    try {\n        if (result.error !== undefined)\n            promise.reject(result.error);\n        else\n            promise.resolve(result.value);\n    }\n    catch (error) {\n        promise.reject(error);\n    }\n}\n\nexport function isTransferable(x: unknown): x is Transferable {\n    if (x instanceof ArrayBuffer)\n        return true;\n    if (x instanceof MessagePort)\n        return true;\n    // we don' use those objects yet\n    // if (x instanceof ReadableStream)\n    //     return true;\n    // if (x instanceof WritableStream)\n    //     return true;\n    // if (x instanceof TransformStream)\n    //     return true;\n    return false;\n}\n\nfunction getTransferables(args: unknown[]): Transferable[] | undefined {\n    let result: Transferable[] | undefined = undefined;\n    for (let i = args.length - 1; i >= 0; i--) {\n        const value = args[i];\n        if (!isTransferable(value)) {\n            if (result !== undefined)\n                // transferable parameters should be placed one after another\n                break;\n            continue;\n        }\n\n        if (!result)\n            result = new Array<Transferable>(value);\n        else\n            result.push(value);\n    }\n    return result;\n}\n\nexport function rpcServer(\n    name: string,\n    messagePort: MessagePort | Worker,\n    serverImpl: object,\n    onUnhandledMessage?: (event: MessageEvent<unknown>) => Promise<void>,\n    onDispose?: () => void,\n) : Disposable {\n    if (!serverImpl)\n        throw new Error(`${name}: serverImpl == null!`);\n\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    onUnhandledMessage ??= (event: MessageEvent<unknown>): Promise<void> => {\n        throw new Error(`${name}: unhandled message.`);\n    }\n\n    const onMessage = async (event: MessageEvent<RpcCall>): Promise<void> => {\n        const rpcCall = event.data;\n        if (!rpcCall?.id) {\n            await onUnhandledMessage(event);\n            return;\n        }\n        debugLog?.log(`-> ${name}.onMessage[#${rpcCall.id}]:`, rpcCall)\n        let value: unknown = undefined;\n        let error: unknown = undefined;\n        try {\n            // eslint-disable-next-line @typescript-eslint/ban-types\n            const method = serverImpl[rpcCall.method] as Function;\n            if (!method) {\n                await onUnhandledMessage(event);\n                return;\n            }\n            value = await method.apply(serverImpl, rpcCall.args);\n        }\n        catch (e) {\n            error = e;\n        }\n        const result = new RpcResult(rpcCall.id, value, error);\n        debugLog?.log(`<- ${name}.onMessage[#${rpcCall.id}]:`, result)\n        if (!rpcCall.noWait)\n            messagePort.postMessage(result);\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    const onMessageError = (event: MessageEvent): Promise<void> => {\n        throw new Error(`${name}: couldn't deserialize the message.`);\n    }\n\n    let isDisposed = false;\n    const oldOnMessage = messagePort.onmessage;\n    const oldOnMessageError = messagePort.onmessageerror;\n    messagePort.onmessage = onMessage;\n    messagePort.onmessageerror = onMessageError;\n\n    return {\n        dispose() {\n            if (!isDisposed) {\n                isDisposed = true;\n                messagePort.onmessage = oldOnMessage;\n                messagePort.onmessageerror = oldOnMessageError;\n                if (onDispose)\n                    onDispose();\n            }\n        }\n    }\n}\n\nconst DefaultRpcClientTimeoutMs = 5_000;\n\nexport function rpcClient<TService extends object>(\n    name: string,\n    messagePort: MessagePort | Worker,\n    timeoutMs = DefaultRpcClientTimeoutMs,\n    onDispose?: () => void,\n) : TService & Disposable {\n    const onMessage = (event: MessageEvent<RpcResult>): void => {\n        if (isDisposed)\n            return;\n\n        const result = event.data;\n        if (result['method']) {\n            errorLog?.log(`${name}: got an RpcCall message:`, result);\n            throw new Error(`${name}: got an RpcCall message.`);\n        }\n        if (result.id)\n            void completeRpc(result);\n    }\n\n    const onMessageError = (event: MessageEvent<RpcResult>): void => {\n        if (isDisposed)\n            return;\n\n        errorLog?.log(`${name}.onMessageError:`, event);\n    }\n\n    const proxyMethodCache = new Map<string, ((...args: unknown[]) => RpcPromise<unknown>)>();\n\n    function getProxyMethod(method: string): ((...args: unknown[]) => RpcPromise<unknown>) {\n        let result = proxyMethodCache.get(method);\n        if (!result) {\n            result = (...args: unknown[]): RpcPromise<unknown> => {\n                if (isDisposed)\n                    throw new Error(`${name}.call: already disposed.`);\n\n                const rpcCall = new RpcCall(nextRpcPromiseId++, method, args, timeoutMs);\n                const rpcPromise = rpcCall.noWait ? RpcPromise.Void : new RpcPromise<unknown>(rpcCall.id);\n                if (rpcCall.timeoutMs && !rpcCall.noWait)\n                    rpcPromise.setTimeout(rpcCall.timeoutMs);\n\n                const transferables = getTransferables(args);\n                debugLog?.log(`${name}.call:`, rpcCall, ', transfer:', transferables);\n                messagePort.postMessage(rpcCall, transferables);\n                return rpcPromise;\n            }\n            proxyMethodCache.set(method, result);\n        }\n\n        return result;\n    }\n\n    const proxyTarget: Disposable = {\n        dispose(): void {\n            if (!isDisposed) {\n                isDisposed = true;\n                messagePort.onmessage = oldOnMessage;\n                messagePort.onmessageerror = oldOnMessageError;\n                if (onDispose)\n                    onDispose();\n            }\n        }\n    }\n    const proxy = new Proxy<TService & Disposable>(proxyTarget as (TService & Disposable), {\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        get(target: TService, p: string | symbol, receiver: unknown): unknown {\n            const ownValue = target[p] as unknown;\n            if (ownValue || typeof(p) !== 'string')\n                return ownValue;\n            return getProxyMethod(p);\n        }\n    })\n\n    let isDisposed = false;\n    const oldOnMessage = messagePort.onmessage;\n    const oldOnMessageError = messagePort.onmessageerror;\n    messagePort.onmessage = onMessage;\n    messagePort.onmessageerror = onMessageError;\n\n    return proxy;\n}\n\nexport function rpcClientServer<TClient extends object>(\n    name: string,\n    messagePort: MessagePort | Worker,\n    serverImpl: object,\n    timeoutMs?: number,\n    onUnhandledMessage?: (event: MessageEvent<unknown>) => Promise<void>,\n) : TClient & Disposable {\n    if (!serverImpl)\n        throw new Error(`${name}: serverImpl == null!`);\n\n    const oldOnMessage = messagePort.onmessage;\n    const oldOnMessageError = messagePort.onmessageerror;\n\n    const onDispose = () => {\n        server.dispose();\n        messagePort.onmessage = oldOnMessage;\n        messagePort.onmessageerror = oldOnMessageError;\n    }\n\n    const client = rpcClient<TClient>(name, messagePort, timeoutMs, onDispose);\n    const clientOnMessage = messagePort.onmessage; // rpcClient(...) call sets it\n    const server = rpcServer(name, messagePort, serverImpl, onUnhandledMessage);\n    const serverOnMessage = messagePort.onmessage; // rpcServer(...) call sets it\n\n    messagePort.onmessage = async (event: MessageEvent<RpcCall | RpcResult>): Promise<void> => {\n        const data = event.data;\n        if (data['method']) // RpcCall message, we process it via serverOnMessage\n            await serverOnMessage.call(messagePort, event);\n        else // RpcResult message, we process it via clientOnMessage\n            await clientOnMessage.call(messagePort, event);\n    }\n    return client;\n}\n\n// This function is used only in tests below\nasync function whenNextMessage<T>(messagePort: MessagePort | Worker, timeoutMs?: number) : Promise<MessageEvent<T>> {\n    const result = new PromiseSourceWithTimeout<MessageEvent<T>>();\n    if (timeoutMs)\n        result.setTimeout(timeoutMs);\n\n    const oldOnMessage = messagePort.onmessage;\n    messagePort.onmessage = (event: MessageEvent<T>) => result.resolve(event);\n    try {\n        return await result;\n    }\n    finally {\n        messagePort.onmessage = oldOnMessage;\n    }\n}\n\n\n// Self-test - we don't want to run it in workers & worklets\nconst mustRunSelfTest = debugLog != null && globalThis['focus'];\nif (mustRunSelfTest) {\n    const testLog = errorLog;\n    if (!testLog)\n        throw new Error('testLog == null');\n    void (async () => {\n        // Basic test\n\n        let rpcPromise = new RpcPromise<string>();\n        testLog.assert(!rpcPromise.isCompleted());\n        void completeRpc(RpcResult.value(rpcPromise.id, 'x'));\n        testLog.assert(rpcPromise.isCompleted());\n        testLog.assert('x' == await rpcPromise);\n\n        rpcPromise = new RpcPromise<string>();\n        testLog.assert(!rpcPromise.isCompleted());\n        void completeRpc(RpcResult.error(rpcPromise.id, 'Error'));\n        testLog.assert(rpcPromise.isCompleted());\n        try {\n            await rpcPromise;\n            testLog?.log('rpcPromise.Error is undefined.');\n        }\n        catch (error) {\n            testLog.assert(error == 'Error', 'error != \"Error\"');\n        }\n\n        // RpcServer & rpcClient test\n\n        interface TestService {\n            mul(x: number, y: number): Promise<number>;\n            ping(reply: string, port: MessagePort, noWait?: RpcNoWait): Promise<void>;\n        }\n\n        class TestServer implements TestService {\n            mul(x: number, y: number): Promise<number> {\n                if (x === 1 || y === 1)\n                    throw '1';\n                return Promise.resolve(x * y);\n            }\n\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            async ping(reply: string, port: MessagePort, noWait?: RpcNoWait): Promise<void> {\n                await delayAsync(500);\n                port.postMessage(reply);\n                return ResolvedPromise.Void;\n            }\n        }\n\n        const channel = new MessageChannel();\n        const client = rpcClient<TestService>(`client`, channel.port1, 300);\n        const server = rpcServer(`server`, channel.port2, new TestServer());\n\n        // Normal call\n        testLog.assert(await client.mul(3, 4) == 12);\n\n        // Normal call w/ transferable\n        const pingChannel = new MessageChannel();\n        await client.ping('Pong', pingChannel.port2, rpcNoWait);\n        const sideResult = (await whenNextMessage<string>(pingChannel.port1, 1000)).data;\n        debugLog?.log('Side channel result:', sideResult);\n        testLog.assert(sideResult === 'Pong');\n\n        // Error call\n        try {\n            await client.mul(1, 5);\n            testLog.assert(false);\n        }\n        catch (e) {\n            testLog.assert(e === '1');\n        }\n\n        // Post-dispose call\n        client.dispose();\n        try {\n            await client.mul(3, 5);\n            testLog.assert(false);\n        }\n        catch (e) {\n            testLog.assert(!!e);\n        }\n    })();\n}\n","import { isResettable } from 'resettable';\n\nexport class ObjectPool<T>\n{\n    private readonly pool = new Array<T>();\n    private readonly factory: () => T;\n\n    constructor(factory: () => T) {\n        this.factory = factory;\n    }\n\n    public expandTo(count: number): ObjectPool<T> {\n        while (this.pool.length < count)\n            this.pool.push(this.factory());\n        return this;\n    }\n\n    public get(): T {\n        let item = this.pool.pop();\n        if (item === undefined)\n            item = this.factory();\n        return item;\n    }\n\n    public release(obj: T): void {\n        if (!obj)\n            return;\n\n        if (isResettable(obj)) {\n            void (async () => {\n                await obj.reset();\n                this.pool.push(obj);\n            })();\n        }\n        else\n            this.pool.push(obj);\n    }\n}\n\nexport class AsyncObjectPool<T>\n{\n    private readonly pool = new Array<T>();\n    private readonly factory: () => T | PromiseLike<T>;\n\n    constructor(factory: () => T | PromiseLike<T>) {\n        this.factory = factory;\n    }\n\n    public async expandTo(count: number): Promise<AsyncObjectPool<T>> {\n        while (this.pool.length < count)\n            this.pool.push(await this.factory());\n        return this;\n    }\n\n    public async get(): Promise<T> {\n        let item = this.pool.pop();\n        if (item === undefined)\n            item = await this.factory();\n        return item;\n    }\n\n    public async release(obj: T): Promise<void> {\n        if (!obj)\n            return;\n\n        if (isResettable(obj))\n            await obj.reset();\n        this.pool.push(obj);\n    }\n}\n","export interface Resettable {\n    reset(): void | PromiseLike<void>;\n}\n\nexport function isResettable<T>(obj: T | Resettable): obj is Resettable {\n    return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj['reset'] === 'function';\n}\n","export class AudioRingBuffer {\n    private readonly channelCount: number;\n    private readonly bufferSize: number;\n    private readonly channelBuffers: Float32Array[];\n    private readIndex: number;\n    private writeIndex: number;\n\n    constructor(bufferSize: number, channelCount: number) {\n        this.readIndex = 0;\n        this.writeIndex = 0;\n        this._samplesAvailable = 0;\n\n        if (bufferSize < 1024) {\n            throw new Error(`Min. buffer size is 1024, but specified bufferSize is ${bufferSize}.`);\n        }\n        this.channelCount = channelCount;\n        this.bufferSize = bufferSize;\n        this.channelBuffers = [];\n        for (let channel = 0; channel < this.channelCount; channel++) {\n            this.channelBuffers[channel] = new Float32Array(bufferSize).fill(0);\n        }\n    }\n\n    private _samplesAvailable: number;\n    public get samplesAvailable() {\n        return this._samplesAvailable;\n    }\n\n    public push(multiChannelData: Float32Array[]): void {\n        if (multiChannelData == null) {\n            throw new Error(`multiChannelData is null or undefined.`);\n        }\n        if (multiChannelData.length == 0) {\n            throw new Error(`multiChannelData is empty.`);\n        }\n        const sourceLength = multiChannelData[0].length;\n        if (sourceLength > this.bufferSize / 2) {\n            throw new Error(`multiChannelData should not contain frames more than half of the bufferSize, length of multichannelData=${sourceLength}, bufferSize=${this.bufferSize}.`);\n        }\n\n        const writeIndex = this.writeIndex;\n        const endWriteIndex = (writeIndex + sourceLength) % this.bufferSize;\n        if (endWriteIndex < writeIndex && endWriteIndex > this.readIndex) {\n            throw new Error(`Buffer can't be overwritten.`);\n        }\n\n        for (let channel = 0; channel < this.channelCount; channel++) {\n            if (endWriteIndex >= writeIndex) {\n                this.channelBuffers[channel].set(multiChannelData[channel], writeIndex);\n            }\n            else {\n                const firstPartEnd = sourceLength - endWriteIndex;\n                const firstPart = multiChannelData[channel].subarray(0, firstPartEnd);\n                const secondPart = multiChannelData[channel].subarray(firstPartEnd);\n                this.channelBuffers[channel].set(firstPart, writeIndex);\n                this.channelBuffers[channel].set(secondPart, 0);\n            }\n        }\n        this.writeIndex = endWriteIndex;\n        this._samplesAvailable += sourceLength;\n    }\n\n    public pull(multiChannelData: Float32Array[]): boolean {\n        if (multiChannelData == null) {\n            throw new Error(`multiChannelData is null or undefined.`);\n        }\n        if (multiChannelData.length == 0) {\n            throw new Error(`multiChannelData is empty.`);\n        }\n        const destinationLength = multiChannelData[0].length;\n        if (destinationLength > this.bufferSize / 2) {\n            throw new Error(`multiChannelData should not have length longer than half of the bufferSize, length of multichannelData=${destinationLength}, bufferSize=${this.bufferSize}.`);\n        }\n        if (this._samplesAvailable === 0) {\n            return false;\n        }\n        if (this._samplesAvailable < destinationLength) {\n            return false;\n        }\n\n        const readIndex = this.readIndex;\n        const endReadIndex = (readIndex + destinationLength) % this.bufferSize;\n\n        for (let channel = 0; channel < this.channelCount; channel++) {\n            if (endReadIndex >= readIndex) {\n                multiChannelData[channel].set(this.channelBuffers[channel].subarray(readIndex, endReadIndex));\n            }\n            else {\n                const firstPartEnd = destinationLength - endReadIndex;\n                const firstPart = this.channelBuffers[channel].subarray(readIndex);\n                const secondPart = this.channelBuffers[channel].subarray(0, endReadIndex);\n                multiChannelData[channel].set(firstPart, 0);\n                multiChannelData[channel].set(secondPart, firstPartEnd);\n            }\n        }\n\n        this.readIndex = endReadIndex;\n        this._samplesAvailable -= destinationLength;\n\n        return true;\n    }\n\n    public reset(): void {\n        this.readIndex = 0;\n        this.writeIndex = 0;\n        this._samplesAvailable = 0;\n        for (let channel = 0; channel < this.channelCount; channel++) {\n            this.channelBuffers[channel].fill(0);\n        }\n    }\n}\n","import { AUDIO_REC as AR } from '_constants';\nimport { Disposable } from 'disposable';\nimport { rpcClientServer, rpcNoWait, RpcNoWait, rpcServer } from 'rpc';\nimport { timerQueue } from 'timerQueue';\nimport { ObjectPool } from 'object-pool';\nimport { AudioRingBuffer } from '../audio-ring-buffer';\nimport { AudioVadWorker } from '../workers/audio-vad-worker-contract';\nimport { AudioVadWorklet } from './audio-vad-worklet-contract';\nimport { AudioDiagnosticsState } from \"../audio-recorder\";\nimport { Log } from 'logging';\n\nconst { logScope, debugLog, warnLog } = Log.get('AudioVadWorkletProcessor');\n\nexport interface AudioVadProcessorOptions {\n    sampleRate: number;\n}\n\nexport class AudioVadWorkletProcessor extends AudioWorkletProcessor implements AudioVadWorklet {\n    private readonly buffer: AudioRingBuffer;\n    private readonly sampleRate: number;\n\n    private state: 'running' | 'ready' | 'inactive' | 'terminated' = 'inactive';\n    private samplesPerWindow: number = AR.SAMPLES_PER_WINDOW_32;\n    private bufferPool: ObjectPool<ArrayBuffer>;\n    private server: Disposable;\n    private worker: AudioVadWorker & Disposable;\n    private frameCount: number = 0;\n    private lastFrameProcessedAt: number = 0;\n    private promiseQueue: Promise<void> = Promise.resolve();\n\n    constructor(options: AudioWorkletNodeOptions) {\n        super(options);\n        const { sampleRate } = options.processorOptions as AudioVadProcessorOptions;\n        this.sampleRate = sampleRate;\n        this.buffer = new AudioRingBuffer(8192, 1);\n        this.server = rpcServer(`${logScope}.server`, this.port, this);\n    }\n\n    public async init(workerPort: MessagePort): Promise<void> {\n        this.worker = rpcClientServer<AudioVadWorker>(`${logScope}.worker`, workerPort, this);\n        this.state = 'ready';\n        this.frameCount = 0;\n        this.lastFrameProcessedAt = 0;\n    }\n\n    public async start(windowSizeMs: 30 | 32): Promise<void> {\n        this.samplesPerWindow = Math.ceil(windowSizeMs == 30\n           ? 30 * this.sampleRate / 1000\n           : 32 * this.sampleRate / 1000);\n        this.bufferPool = new ObjectPool<ArrayBuffer>(() => new ArrayBuffer(this.samplesPerWindow * 4)).expandTo(4);\n        this.state = 'running';\n        this.frameCount = 0;\n        this.lastFrameProcessedAt = 0;\n        this.buffer.reset();\n    }\n\n    public async terminate(_noWait?: RpcNoWait): Promise<void> {\n        this.state = 'terminated';\n    }\n\n    public async releaseBuffer(buffer: ArrayBuffer, noWait?: RpcNoWait): Promise<void> {\n        // we can change samplesPerWindow on the fly when switching to NN VAD\n        if (buffer.byteLength !== this.samplesPerWindow * 4)\n            return;\n\n        this.bufferPool.release(buffer);\n    }\n\n    public process(inputs: Float32Array[][], outputs: Float32Array[][]): boolean {\n        // debugLog?.log(`process:`, this.state);\n        // if (inputs[0].length)\n        //     console.log(\"VAD:\", approximateGain(inputs[0][0]));\n        if (this.frameCount++ > 100) {\n            this.frameCount = 0;\n            this.lastFrameProcessedAt = Date.now();\n        }\n        timerQueue?.triggerExpired();\n        const hasInput = inputs\n            && inputs.length !== 0\n            && inputs[0].length !== 0;\n\n        if (this.state === 'terminated')\n            return false;\n\n        if (this.state === 'inactive')\n            return true;\n\n        if (!hasInput)\n            return true;\n\n        const input = inputs[0];\n        const { samplesPerWindow } = this;\n\n        this.buffer.push(input);\n        if (this.buffer.samplesAvailable >= samplesPerWindow) {\n            const vadArrayBuffer = this.bufferPool.get();\n            const vadArray = new Float32Array(vadArrayBuffer, 0, samplesPerWindow);\n\n            if (this.buffer.pull([vadArray])) {\n                if (this.worker)\n                    this.promiseQueue = this.promiseQueue.then(() =>\n                        this.worker.onFrame(vadArrayBuffer, rpcNoWait));\n                else\n                    warnLog?.log('process: worklet port is still undefined!');\n            } else {\n                this.bufferPool.release(vadArrayBuffer);\n            }\n        }\n\n        return true;\n    }\n\n    public async runDiagnostics(diagnosticsState: AudioDiagnosticsState): Promise<AudioDiagnosticsState> {\n        diagnosticsState.vadWorkletState = this.state;\n        diagnosticsState.lastVadWorkletFrameProcessedAt = this.lastFrameProcessedAt;\n        warnLog?.log('runDiagnostics: ', diagnosticsState);\n        return diagnosticsState;\n    }\n}\n\nregisterProcessor('audio-vad-worklet-processor', AudioVadWorkletProcessor);\n"],"names":["__webpack_require__","exports","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","REC_SAMPLES_PER_MS","AUDIO_REC","SAMPLE_RATE","SAMPLES_PER_MS","SAMPLES_PER_WINDOW_32","SAMPLES_PER_WINDOW_30","SAMPLES_PER_RECORDING_IN_PROGRESS_CALL","SAMPLE_DURATION","MIN_RECORDING_GAIN","MIN_MICROPHONE_GAIN","Math","round","ENC_BIT_RATE","sqrt","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","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","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","done","pop","e","step","__read","m","r","ar","__spreadArray","to","pack","arguments","l","slice","concat","Heap","compare","minComparator","_this","heapArray","_limit","offer","add","element","peek","poll","_invertedCompare","a","b","getChildrenIndexOf","idx","getParentIndexOf","whichChildren","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","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","nextTickImpl","nextTickCallbacks","nextTickChannel","MessageChannel","port1","onmessage","port2","postMessage","Timeout","start","isPrecise","timeoutMs","PreciseTimeout","startRegular","startPrecise","dispose","endsAt","loop","requestAnimationFrame","super","cancelAnimationFrame","TimedOut","instance","PromiseSource","resolve","reject","_isCompleted","_promise","Promise","resolve1","reject1","reason","toStringTag","isCompleted","then","onfulfilled","onrejected","catch","onfinally","finally","PromiseSourceWithTimeout","_timeout","hasTimeout","setPreciseTimeout","cancelled","OperationCancelledError","message","delayAsync","promise","ResolvedPromise","Void","True","False","c","p","async","cancel","race","waitAsync","rpcNoWait","RpcCall","method","args","noWait","lastArg","rpcTimeout","RpcResult","nextRpcPromiseId","rpcPromisesInProgress","RpcPromise","oldResolve","oldReject","unregister","completeRpc","rpcServer","name","messagePort","serverImpl","onUnhandledMessage","onDispose","event","isDisposed","oldOnMessage","oldOnMessageError","onmessageerror","rpcCall","DefaultRpcClientTimeoutMs","rpcClient","proxyMethodCache","getProxyMethod","rpcPromise","transferables","x","ArrayBuffer","MessagePort","getTransferables","proxy","Proxy","receiver","ownValue","testLog","channel","client","mul","ping","reply","port","pingChannel","sideResult","whenNextMessage","ObjectPool","factory","pool","expandTo","count","release","AudioRingBuffer","bufferSize","channelCount","readIndex","writeIndex","_samplesAvailable","channelBuffers","Float32Array","fill","samplesAvailable","multiChannelData","sourceLength","endWriteIndex","firstPartEnd","firstPart","subarray","secondPart","pull","destinationLength","endReadIndex","AudioVadWorkletProcessor","AudioWorkletProcessor","options","state","samplesPerWindow","frameCount","lastFrameProcessedAt","promiseQueue","sampleRate","processorOptions","buffer","server","workerPort","worker","clientOnMessage","serverOnMessage","rpcClientServer","windowSizeMs","bufferPool","terminate","_noWait","releaseBuffer","byteLength","process","inputs","outputs","hasInput","input","vadArrayBuffer","vadArray","onFrame","runDiagnostics","diagnosticsState","vadWorkletState","lastVadWorkletFrameProcessedAt","registerProcessor"],"sourceRoot":""}