{"version":3,"file":"opusEncoderWorklet.js","mappings":"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","sources":["webpack:///./node_modules/denque/index.js","webpack:///webpack/bootstrap","webpack:///webpack/runtime/define property getters","webpack:///webpack/runtime/hasOwnProperty shorthand","webpack:///./src/_constants.ts","webpack:///./src/object-pool.ts","webpack:///./src/resettable.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:///../dotnet/UI.Blazor.App/Components/AudioRecorder/audio-ring-buffer.ts","webpack:///./src/math.ts","webpack:///../dotnet/UI.Blazor.App/Components/AudioRecorder/worklets/opus-encoder-worklet-processor.ts"],"sourcesContent":["'use strict';\n\n/**\n * Custom implementation of a double ended queue.\n */\nfunction Denque(array, options) {\n  var options = options || {};\n  this._capacity = options.capacity;\n\n  this._head = 0;\n  this._tail = 0;\n\n  if (Array.isArray(array)) {\n    this._fromArray(array);\n  } else {\n    this._capacityMask = 0x3;\n    this._list = new Array(4);\n  }\n}\n\n/**\n * --------------\n *  PUBLIC API\n * -------------\n */\n\n/**\n * Returns the item at the specified index from the list.\n * 0 is the first element, 1 is the second, and so on...\n * Elements at negative values are that many from the end: -1 is one before the end\n * (the last element), -2 is two before the end (one before last), etc.\n * @param index\n * @returns {*}\n */\nDenque.prototype.peekAt = function peekAt(index) {\n  var i = index;\n  // expect a number or return undefined\n  if ((i !== (i | 0))) {\n    return void 0;\n  }\n  var len = this.size();\n  if (i >= len || i < -len) return undefined;\n  if (i < 0) i += len;\n  i = (this._head + i) & this._capacityMask;\n  return this._list[i];\n};\n\n/**\n * Alias for peekAt()\n * @param i\n * @returns {*}\n */\nDenque.prototype.get = function get(i) {\n  return this.peekAt(i);\n};\n\n/**\n * Returns the first item in the list without removing it.\n * @returns {*}\n */\nDenque.prototype.peek = function peek() {\n  if (this._head === this._tail) return undefined;\n  return this._list[this._head];\n};\n\n/**\n * Alias for peek()\n * @returns {*}\n */\nDenque.prototype.peekFront = function peekFront() {\n  return this.peek();\n};\n\n/**\n * Returns the item that is at the back of the queue without removing it.\n * Uses peekAt(-1)\n */\nDenque.prototype.peekBack = function peekBack() {\n  return this.peekAt(-1);\n};\n\n/**\n * Returns the current length of the queue\n * @return {Number}\n */\nObject.defineProperty(Denque.prototype, 'length', {\n  get: function length() {\n    return this.size();\n  }\n});\n\n/**\n * Return the number of items on the list, or 0 if empty.\n * @returns {number}\n */\nDenque.prototype.size = function size() {\n  if (this._head === this._tail) return 0;\n  if (this._head < this._tail) return this._tail - this._head;\n  else return this._capacityMask + 1 - (this._head - this._tail);\n};\n\n/**\n * Add an item at the beginning of the list.\n * @param item\n */\nDenque.prototype.unshift = function unshift(item) {\n  if (arguments.length === 0) return this.size();\n  var len = this._list.length;\n  this._head = (this._head - 1 + len) & this._capacityMask;\n  this._list[this._head] = item;\n  if (this._tail === this._head) this._growArray();\n  if (this._capacity && this.size() > this._capacity) this.pop();\n  if (this._head < this._tail) return this._tail - this._head;\n  else return this._capacityMask + 1 - (this._head - this._tail);\n};\n\n/**\n * Remove and return the first item on the list,\n * Returns undefined if the list is empty.\n * @returns {*}\n */\nDenque.prototype.shift = function shift() {\n  var head = this._head;\n  if (head === this._tail) return undefined;\n  var item = this._list[head];\n  this._list[head] = undefined;\n  this._head = (head + 1) & this._capacityMask;\n  if (head < 2 && this._tail > 10000 && this._tail <= this._list.length >>> 2) this._shrinkArray();\n  return item;\n};\n\n/**\n * Add an item to the bottom of the list.\n * @param item\n */\nDenque.prototype.push = function push(item) {\n  if (arguments.length === 0) return this.size();\n  var tail = this._tail;\n  this._list[tail] = item;\n  this._tail = (tail + 1) & this._capacityMask;\n  if (this._tail === this._head) {\n    this._growArray();\n  }\n  if (this._capacity && this.size() > this._capacity) {\n    this.shift();\n  }\n  if (this._head < this._tail) return this._tail - this._head;\n  else return this._capacityMask + 1 - (this._head - this._tail);\n};\n\n/**\n * Remove and return the last item on the list.\n * Returns undefined if the list is empty.\n * @returns {*}\n */\nDenque.prototype.pop = function pop() {\n  var tail = this._tail;\n  if (tail === this._head) return undefined;\n  var len = this._list.length;\n  this._tail = (tail - 1 + len) & this._capacityMask;\n  var item = this._list[this._tail];\n  this._list[this._tail] = undefined;\n  if (this._head < 2 && tail > 10000 && tail <= len >>> 2) this._shrinkArray();\n  return item;\n};\n\n/**\n * Remove and return the item at the specified index from the list.\n * Returns undefined if the list is empty.\n * @param index\n * @returns {*}\n */\nDenque.prototype.removeOne = function removeOne(index) {\n  var i = index;\n  // expect a number or return undefined\n  if ((i !== (i | 0))) {\n    return void 0;\n  }\n  if (this._head === this._tail) return void 0;\n  var size = this.size();\n  var len = this._list.length;\n  if (i >= size || i < -size) return void 0;\n  if (i < 0) i += size;\n  i = (this._head + i) & this._capacityMask;\n  var item = this._list[i];\n  var k;\n  if (index < size / 2) {\n    for (k = index; k > 0; k--) {\n      this._list[i] = this._list[i = (i - 1 + len) & this._capacityMask];\n    }\n    this._list[i] = void 0;\n    this._head = (this._head + 1 + len) & this._capacityMask;\n  } else {\n    for (k = size - 1 - index; k > 0; k--) {\n      this._list[i] = this._list[i = (i + 1 + len) & this._capacityMask];\n    }\n    this._list[i] = void 0;\n    this._tail = (this._tail - 1 + len) & this._capacityMask;\n  }\n  return item;\n};\n\n/**\n * Remove number of items from the specified index from the list.\n * Returns array of removed items.\n * Returns undefined if the list is empty.\n * @param index\n * @param count\n * @returns {array}\n */\nDenque.prototype.remove = function remove(index, count) {\n  var i = index;\n  var removed;\n  var del_count = count;\n  // expect a number or return undefined\n  if ((i !== (i | 0))) {\n    return void 0;\n  }\n  if (this._head === this._tail) return void 0;\n  var size = this.size();\n  var len = this._list.length;\n  if (i >= size || i < -size || count < 1) return void 0;\n  if (i < 0) i += size;\n  if (count === 1 || !count) {\n    removed = new Array(1);\n    removed[0] = this.removeOne(i);\n    return removed;\n  }\n  if (i === 0 && i + count >= size) {\n    removed = this.toArray();\n    this.clear();\n    return removed;\n  }\n  if (i + count > size) count = size - i;\n  var k;\n  removed = new Array(count);\n  for (k = 0; k < count; k++) {\n    removed[k] = this._list[(this._head + i + k) & this._capacityMask];\n  }\n  i = (this._head + i) & this._capacityMask;\n  if (index + count === size) {\n    this._tail = (this._tail - count + len) & this._capacityMask;\n    for (k = count; k > 0; k--) {\n      this._list[i = (i + 1 + len) & this._capacityMask] = void 0;\n    }\n    return removed;\n  }\n  if (index === 0) {\n    this._head = (this._head + count + len) & this._capacityMask;\n    for (k = count - 1; k > 0; k--) {\n      this._list[i = (i + 1 + len) & this._capacityMask] = void 0;\n    }\n    return removed;\n  }\n  if (i < size / 2) {\n    this._head = (this._head + index + count + len) & this._capacityMask;\n    for (k = index; k > 0; k--) {\n      this.unshift(this._list[i = (i - 1 + len) & this._capacityMask]);\n    }\n    i = (this._head - 1 + len) & this._capacityMask;\n    while (del_count > 0) {\n      this._list[i = (i - 1 + len) & this._capacityMask] = void 0;\n      del_count--;\n    }\n    if (index < 0) this._tail = i;\n  } else {\n    this._tail = i;\n    i = (i + count + len) & this._capacityMask;\n    for (k = size - (count + index); k > 0; k--) {\n      this.push(this._list[i++]);\n    }\n    i = this._tail;\n    while (del_count > 0) {\n      this._list[i = (i + 1 + len) & this._capacityMask] = void 0;\n      del_count--;\n    }\n  }\n  if (this._head < 2 && this._tail > 10000 && this._tail <= len >>> 2) this._shrinkArray();\n  return removed;\n};\n\n/**\n * Native splice implementation.\n * Remove number of items from the specified index from the list and/or add new elements.\n * Returns array of removed items or empty array if count == 0.\n * Returns undefined if the list is empty.\n *\n * @param index\n * @param count\n * @param {...*} [elements]\n * @returns {array}\n */\nDenque.prototype.splice = function splice(index, count) {\n  var i = index;\n  // expect a number or return undefined\n  if ((i !== (i | 0))) {\n    return void 0;\n  }\n  var size = this.size();\n  if (i < 0) i += size;\n  if (i > size) return void 0;\n  if (arguments.length > 2) {\n    var k;\n    var temp;\n    var removed;\n    var arg_len = arguments.length;\n    var len = this._list.length;\n    var arguments_index = 2;\n    if (!size || i < size / 2) {\n      temp = new Array(i);\n      for (k = 0; k < i; k++) {\n        temp[k] = this._list[(this._head + k) & this._capacityMask];\n      }\n      if (count === 0) {\n        removed = [];\n        if (i > 0) {\n          this._head = (this._head + i + len) & this._capacityMask;\n        }\n      } else {\n        removed = this.remove(i, count);\n        this._head = (this._head + i + len) & this._capacityMask;\n      }\n      while (arg_len > arguments_index) {\n        this.unshift(arguments[--arg_len]);\n      }\n      for (k = i; k > 0; k--) {\n        this.unshift(temp[k - 1]);\n      }\n    } else {\n      temp = new Array(size - (i + count));\n      var leng = temp.length;\n      for (k = 0; k < leng; k++) {\n        temp[k] = this._list[(this._head + i + count + k) & this._capacityMask];\n      }\n      if (count === 0) {\n        removed = [];\n        if (i != size) {\n          this._tail = (this._head + i + len) & this._capacityMask;\n        }\n      } else {\n        removed = this.remove(i, count);\n        this._tail = (this._tail - leng + len) & this._capacityMask;\n      }\n      while (arguments_index < arg_len) {\n        this.push(arguments[arguments_index++]);\n      }\n      for (k = 0; k < leng; k++) {\n        this.push(temp[k]);\n      }\n    }\n    return removed;\n  } else {\n    return this.remove(i, count);\n  }\n};\n\n/**\n * Soft clear - does not reset capacity.\n */\nDenque.prototype.clear = function clear() {\n  this._list = new Array(this._list.length);\n  this._head = 0;\n  this._tail = 0;\n};\n\n/**\n * Returns true or false whether the list is empty.\n * @returns {boolean}\n */\nDenque.prototype.isEmpty = function isEmpty() {\n  return this._head === this._tail;\n};\n\n/**\n * Returns an array of all queue items.\n * @returns {Array}\n */\nDenque.prototype.toArray = function toArray() {\n  return this._copyArray(false);\n};\n\n/**\n * -------------\n *   INTERNALS\n * -------------\n */\n\n/**\n * Fills the queue with items from an array\n * For use in the constructor\n * @param array\n * @private\n */\nDenque.prototype._fromArray = function _fromArray(array) {\n  var length = array.length;\n  var capacity = this._nextPowerOf2(length);\n\n  this._list = new Array(capacity);\n  this._capacityMask = capacity - 1;\n  this._tail = length;\n\n  for (var i = 0; i < length; i++) this._list[i] = array[i];\n};\n\n/**\n *\n * @param fullCopy\n * @param size Initialize the array with a specific size. Will default to the current list size\n * @returns {Array}\n * @private\n */\nDenque.prototype._copyArray = function _copyArray(fullCopy, size) {\n  var src = this._list;\n  var capacity = src.length;\n  var length = this.length;\n  size = size | length;\n\n  // No prealloc requested and the buffer is contiguous\n  if (size == length && this._head < this._tail) {\n    // Simply do a fast slice copy\n    return this._list.slice(this._head, this._tail);\n  }\n\n  var dest = new Array(size);\n\n  var k = 0;\n  var i;\n  if (fullCopy || this._head > this._tail) {\n    for (i = this._head; i < capacity; i++) dest[k++] = src[i];\n    for (i = 0; i < this._tail; i++) dest[k++] = src[i];\n  } else {\n    for (i = this._head; i < this._tail; i++) dest[k++] = src[i];\n  }\n\n  return dest;\n}\n\n/**\n * Grows the internal list array.\n * @private\n */\nDenque.prototype._growArray = function _growArray() {\n  if (this._head != 0) {\n    // double array size and copy existing data, head to end, then beginning to tail.\n    var newList = this._copyArray(true, this._list.length << 1);\n\n    this._tail = this._list.length;\n    this._head = 0;\n\n    this._list = newList;\n  } else {\n    this._tail = this._list.length;\n    this._list.length <<= 1;\n  }\n\n  this._capacityMask = (this._capacityMask << 1) | 1;\n};\n\n/**\n * Shrinks the internal list array.\n * @private\n */\nDenque.prototype._shrinkArray = function _shrinkArray() {\n  this._list.length >>>= 1;\n  this._capacityMask >>>= 1;\n};\n\n/**\n * Find the next power of 2, at least 4\n * @private\n * @param {number} num \n * @returns {number}\n */\nDenque.prototype._nextPowerOf2 = function _nextPowerOf2(num) {\n  var log2 = Math.log(num) / Math.log(2);\n  var nextPow2 = 1 << (log2 + 1);\n\n  return Math.max(nextPow2, 4);\n}\n\nmodule.exports = Denque;\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\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","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","// 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","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 Denque from 'denque';\n\nexport class Vector2D {\n    public static readonly zero = new Vector2D(0, 0);\n    public static readonly unitX = new Vector2D(1, 0);\n    public static readonly unitY = new Vector2D(0, 1);\n\n    constructor(public x: number, public y: number) { }\n\n    public add(other: Vector2D): Vector2D {\n        return new Vector2D(this.x + other.x, this.y + other.y);\n    }\n\n    public sub(other: Vector2D): Vector2D {\n        return new Vector2D(this.x - other.x, this.y - other.y);\n    }\n\n    public mul(multiplier: number): Vector2D {\n        return new Vector2D(this.x * multiplier, this.y * multiplier);\n    }\n\n    public dotProduct(other: Vector2D): number {\n        return this.x * other.x + this.y * other.y;\n    }\n\n    public get length(): number {\n        return Math.sqrt(this.squareLength);\n    }\n\n    public get squareLength(): number {\n        return this.x * this.x + this.y * this.y;\n    }\n\n    public isHorizontal(minRatio = 1) {\n        return Math.abs(this.x) > minRatio * Math.abs(this.y);\n    }\n\n    public isVertical(minRatio = 1) {\n        return Math.abs(this.y) > minRatio * Math.abs(this.x);\n    }\n}\n\nexport function clamp(n: number, min: number, max: number) {\n    return Math.max(min, Math.min(max, n));\n}\n\nexport function lerp(x: number, y: number, alpha: number) {\n    return x + alpha*(y - x);\n}\n\nexport interface RunningCounter {\n    readonly sampleCount: number;\n    readonly value: number;\n\n    reset(): void;\n    appendSample(value: number): void;\n}\n\nexport class RunningAverage implements RunningCounter {\n    private _sampleCount = 0;\n    private _sum = 0;\n\n    constructor(private readonly defaultValue: number)\n    { }\n\n    public get sampleCount(): number {\n        return this._sampleCount;\n    }\n\n    public get value(): number {\n        return this._sampleCount <= 0\n            ? this.defaultValue\n            : this._sum / this.sampleCount;\n    }\n\n    public reset(): void {\n        this._sampleCount = 0;\n        this._sum = 0;\n    }\n\n    public appendSample(value: number): void {\n        this._sum += value;\n        this._sampleCount++;\n    }\n\n    public removeSample(value: number): void {\n        if (this._sampleCount <= 0)\n            return;\n\n        this._sum -= value;\n        this._sampleCount--;\n    }\n}\n\nexport class RunningUnitMedian implements RunningCounter {\n    private readonly _halfBucketSize: number;\n    private readonly _buckets: Int32Array;\n    private _sampleCount = 0;\n    private _value: number | null = null;\n\n    constructor(\n        bucketCount = 100,\n        private readonly defaultValue = 0.5\n    ) {\n        this._buckets = new Int32Array(bucketCount).fill(0);\n        this._halfBucketSize = 0.5 / bucketCount;\n    }\n\n    public get sampleCount(): number {\n        return this._sampleCount;\n    }\n\n    public get value(): number {\n        if (this._value !== null)\n            return this._value;\n\n        if (this._sampleCount <= 0)\n            return this._value = this.defaultValue; // No samples\n\n        const halfSampleCount = this._sampleCount / 2;\n        let runningCount = 0;\n        for (let i = 0; i < this._buckets.length; i++) {\n            runningCount += this._buckets[i];\n            if (runningCount >= halfSampleCount) {\n                // Ideally we should distribute the weight here\n                return this._value = (2*i + 1) * this._halfBucketSize;\n            }\n        }\n\n        // We shouldn't land here, but just in case:\n        return this._value = (2*this._buckets.length - 1) * this._halfBucketSize;\n    }\n\n    public reset(): void {\n        this._buckets.fill(0);\n        this._sampleCount = 0;\n        this._value = null;\n    }\n\n    public appendSample(value: number): void {\n        value = clamp(value, 0, 1);\n        this._buckets[Math.floor(value * this._buckets.length)]++;\n        this._sampleCount++;\n        this._value = null;\n    }\n}\n\nexport class RunningMA implements RunningCounter {\n    private readonly _samples = new Denque<number>();\n    private readonly _average: RunningAverage;\n\n    constructor(\n        private readonly windowSize: number,\n        defaultValue: number,\n    ) {\n        this._average = new RunningAverage(defaultValue);\n    }\n\n    public get sampleCount(): number {\n        return this._average.sampleCount;\n    }\n\n    public get value(): number {\n        return this._average.value;\n    }\n\n    public reset(): void {\n        this._samples.clear();\n        this._average.reset();\n    }\n\n    public appendSample(value: number): void {\n        const samples = this._samples;\n        const average = this._average;\n        samples.push(value);\n        average.appendSample(value);\n        if (average.sampleCount > this.windowSize)\n            average.removeSample(samples.shift())\n    }\n}\n\nexport class RunningEMA implements RunningCounter {\n    private _sampleCount = 0;\n    private _average: RunningAverage;\n    private _value: number | null = null;\n\n    constructor(\n        defaultValue: number,\n        private readonly minSampleCount: number, // Uses RunningMA unless sampleCount > minSampleCount\n        private readonly smoothingFactor: number = null,\n    ) {\n        if (smoothingFactor === null)\n            this.smoothingFactor = 2 / (minSampleCount + 1);\n        this._average = new RunningAverage(defaultValue);\n    }\n\n    public get sampleCount(): number {\n        return this._sampleCount;\n    }\n\n    public get value(): number {\n        return this._value ?? this._average.value;\n    }\n\n    public reset(): void {\n        this._sampleCount = 0;\n        this._average.reset();\n        this._value = null;\n    }\n\n    public appendSample(value: number): void {\n        this._sampleCount++;\n        const last = this._value;\n        if (last === null) {\n            this._average.appendSample(value);\n            if (this._sampleCount >= this.minSampleCount)\n                this._value = this._average.value;\n        } else {\n            this._value =  last + this.smoothingFactor * (value - last);\n        }\n    }\n}\n\nexport class RunningMax implements RunningCounter {\n    private readonly defaultValue: number;\n    private readonly _samples = new Array<number>();\n    private max: number;\n\n    constructor(\n        private readonly windowSize: number,\n        defaultValue: number,\n    ) {\n        this.defaultValue = defaultValue;\n        this.max = defaultValue;\n    }\n\n    public get sampleCount(): number {\n        return this._samples.length;\n    }\n\n    public get value(): number {\n        return this.max;\n    }\n\n    public get samples(): number[] {\n        return this._samples;\n    }\n\n    public reset(): void {\n        this._samples.length = 0;\n        this.max = this.defaultValue;\n    }\n\n    public appendSample(value: number): void {\n        if (value > this.max)\n            this.max = value;\n        this._samples.push(value);\n\n        if (this._samples.length > this.windowSize)\n            this._samples.shift();\n    }\n}\n\nconst BESSEL_I0_ITER = 50;\n\nexport function KaiserBesselDerivedWindow(windowSize: number, alpha: number): Float32Array {\n    const window = new Float32Array(windowSize);\n    const alpha2 = (alpha * Math.PI / windowSize) * (alpha * Math.PI / windowSize);\n\n    let sum = 0.0;\n    for (let i = 0; i < windowSize; i++) {\n        const tmp = i * (windowSize - i) * alpha2;\n        let bessel = 1.0;\n        for (let j = BESSEL_I0_ITER; j > 0; j--)\n            bessel = bessel * tmp / (j * j) + 1;\n        sum += bessel;\n        window[i] = sum;\n    }\n    sum++;\n    for (let i = 0; i < windowSize; i++)\n        window[i] = Math.sqrt(window[i] / sum);\n\n    return window;\n}\n\nexport function approximateGain(monoPcm: Float32Array, stride = 5): number {\n    let sum = 0;\n    // every 5th sample as usually it's enough to assess speech gain\n    for (let i = 0; i < monoPcm.length; i+=stride) {\n        const e = monoPcm[i];\n        sum += e * e;\n    }\n    return Math.sqrt(sum / Math.floor(monoPcm.length / stride));\n}\n\nexport function translate(number: number, [inMin, inMax]: Array<number>, [outMin, outMax]: Array<number>) {\n    const result = (number - inMin) / (inMax - inMin) * (outMax - outMin) + outMin;\n    if (isNaN(result))\n        return outMin;\n\n    return result;\n}\n\nexport function average(array: Array<number> | Float32Array): number {\n    let sum = 0;\n    for (let i = 0; i < array.length; i++)\n        sum += array[i];\n    return sum / array.length;\n}\n","import { AUDIO_REC as AR } from '_constants';\nimport { Disposable } from 'disposable';\nimport { ObjectPool } from 'object-pool';\nimport { rpcClientServer, RpcNoWait, rpcNoWait, rpcServer } from 'rpc';\nimport { timerQueue } from 'timerQueue';\nimport { AudioRingBuffer } from '../audio-ring-buffer';\nimport { AudioDiagnosticsState } from \"../audio-recorder\";\nimport { OpusEncoderWorklet } from './opus-encoder-worklet-contract';\nimport { OpusEncoderWorker } from '../workers/opus-encoder-worker-contract';\nimport { RecorderStateServer } from \"../opus-media-recorder-contracts\";\nimport { Log } from 'logging';\nimport { approximateGain } from 'math';\n\nconst { logScope, debugLog, warnLog, errorLog } = Log.get('OpusEncoderWorkletProcessor');\n\nexport interface OpusEncoderProcessorOptions {\n    timeSlice: number;\n    sampleRate: number;\n}\n\nexport class OpusEncoderWorkletProcessor extends AudioWorkletProcessor implements OpusEncoderWorklet {\n    private static allowedTimeSlice = [20, 40, 60, 80];\n    private readonly samplesPerWindow: number;\n    private readonly buffer: AudioRingBuffer;\n    private readonly bufferPool: ObjectPool<ArrayBuffer>;\n\n    private state: 'running' | 'ready' | 'inactive' | 'terminated' = 'inactive';\n    private stateServer: RecorderStateServer & Disposable;\n    private worker: OpusEncoderWorker & Disposable;\n    private samplesSinceLastReport: number = null;\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        debugLog?.log('ctor');\n        const { timeSlice, sampleRate } = options.processorOptions as OpusEncoderProcessorOptions;\n\n        if (!OpusEncoderWorkletProcessor.allowedTimeSlice.some(val => val === timeSlice)) {\n            const allowedTimeSliceJson = JSON.stringify(OpusEncoderWorkletProcessor.allowedTimeSlice);\n            throw new Error(`OpusEncoderWorkletProcessor supports only ${ allowedTimeSliceJson } options as timeSlice argument.`);\n        }\n\n        this.samplesPerWindow = Math.ceil(timeSlice * sampleRate / 1000);\n        this.buffer = new AudioRingBuffer(8192, 1);\n        this.bufferPool = new ObjectPool<ArrayBuffer>(() => new ArrayBuffer(this.samplesPerWindow * 4)).expandTo(4);\n        this.stateServer = rpcClientServer<RecorderStateServer>(`${logScope}.stateServer`, this.port, this);\n    }\n\n    public async init(workerPort: MessagePort): Promise<void> {\n        this.worker = rpcClientServer<OpusEncoderWorker>(`${logScope}.worker`, workerPort, this);\n        this.state = 'ready';\n        this.samplesSinceLastReport = null;\n        this.frameCount = 0;\n        this.lastFrameProcessedAt = 0;\n    }\n\n    public async start(_noWait?: RpcNoWait): Promise<void> {\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        this.samplesSinceLastReport = null;\n        this.frameCount = 0;\n        this.lastFrameProcessedAt = 0;\n        this.buffer.reset();\n    }\n\n    public async releaseBuffer(buffer: ArrayBuffer, noWait?: RpcNoWait): Promise<void> {\n        this.bufferPool.release(buffer);\n    }\n\n    // called for each 128 samples ~ 2.5ms\n    public process(inputs: Float32Array[][], outputs: Float32Array[][]): boolean {\n        // if (inputs[0].length)\n        //     console.log(\"RECORD:\", approximateGain(inputs[0][0]));\n        if (this.frameCount++ > 100) {\n            this.frameCount = 0;\n            this.lastFrameProcessedAt = Date.now();\n        }\n\n        timerQueue?.triggerExpired();\n        try {\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            this.buffer.push(input);\n            if (this.buffer.samplesAvailable >= this.samplesPerWindow) {\n                const audioArrayBuffer = this.bufferPool.get();\n                const audioArray = new Float32Array(audioArrayBuffer, 0, this.samplesPerWindow)\n\n                if (this.buffer.pull([audioArray])) {\n                    if (this.worker != null)\n                        this.promiseQueue = this.promiseQueue.then(() =>\n                            this.worker.onEncoderWorkletSamples(audioArrayBuffer, rpcNoWait));\n                    else\n                        warnLog?.log('process: worklet port is still undefined!');\n                } else {\n                    this.bufferPool.release(audioArrayBuffer);\n                }\n            }\n\n            this.samplesSinceLastReport ??= AR.SAMPLES_PER_RECORDING_IN_PROGRESS_CALL;\n            this.samplesSinceLastReport += input[0].length;\n            const gain = approximateGain(input[0]);\n            if (this.samplesSinceLastReport >= AR.SAMPLES_PER_RECORDING_IN_PROGRESS_CALL) {\n                this.samplesSinceLastReport = 0;\n                void this.stateServer.recordingInProgress(gain, rpcNoWait);\n            }\n        }\n        catch (error) {\n            errorLog?.log(`process: unhandled error:`, error);\n        }\n\n        return true;\n    }\n\n    public async runDiagnostics(diagnosticsState: AudioDiagnosticsState): Promise<AudioDiagnosticsState> {\n        diagnosticsState.encoderWorkletState = this.state;\n        diagnosticsState.lastEncoderWorkletFrameProcessedAt = this.lastFrameProcessedAt;\n        warnLog?.log('runDiagnostics: ', diagnosticsState);\n        return diagnosticsState;\n    }\n}\n\nregisterProcessor('opus-encoder-worklet-processor', OpusEncoderWorkletProcessor);\n"],"names":["Denque","array","options","this","_capacity","capacity","_head","_tail","Array","isArray","_fromArray","_capacityMask","_list","prototype","peekAt","index","i","len","size","get","peek","peekFront","peekBack","Object","defineProperty","unshift","item","arguments","length","_growArray","pop","shift","head","undefined","_shrinkArray","push","tail","removeOne","k","remove","count","removed","del_count","toArray","clear","splice","temp","arg_len","arguments_index","leng","isEmpty","_copyArray","_nextPowerOf2","fullCopy","src","slice","dest","newList","num","nextPow2","Math","log","max","module","exports","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","d","definition","key","o","enumerable","obj","prop","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","round","ENC_BIT_RATE","sqrt","ObjectPool","constructor","factory","pool","expandTo","release","reset","LogLevel","StorageKey","DateStorageKey","MaxStorageAge","isWorkerOrWorklet","globalThis","initLogging","Log","Info","minLevels","wasRestored","LogLevelController","sessionStorage","dateJson","getItem","Date","now","JSON","parse","readJson","readMinLevels","Map","forEach","value","set","restore","console","override","scope","newLevel","persist","isProduction","defaultLevel","setItem","stringify","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","idSeed","items","itemIndex","findIndex","el","target","existentItem","touchedAt","id","newRef","removeOldest","newItem","indexToEliminate","itemToEliminate","toString","__generator","thisArg","body","f","y","t","g","_","label","sent","trys","ops","next","verb","Symbol","iterator","n","v","op","TypeError","done","e","step","__read","m","r","ar","__spreadArray","to","pack","l","concat","Heap","compare","minComparator","_this","heapArray","_limit","offer","add","element","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","contains","fn","_sortNodeDown","leafs","configurable","_l","last","_i","_topN_push","filter","getParentOf","rm","bottomHeap","limit","startAt","parentStartAt","indices","_moveNode","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","rpcClientServer","client","server","clientOnMessage","serverOnMessage","testLog","channel","mul","ping","reply","port","pingChannel","sideResult","whenNextMessage","AudioRingBuffer","bufferSize","channelCount","readIndex","writeIndex","_samplesAvailable","channelBuffers","Float32Array","fill","samplesAvailable","multiChannelData","sourceLength","endWriteIndex","firstPartEnd","firstPart","subarray","secondPart","pull","destinationLength","endReadIndex","Vector2D","other","sub","multiplier","dotProduct","squareLength","isHorizontal","minRatio","abs","isVertical","zero","unitX","unitY","OpusEncoderWorkletProcessor","AudioWorkletProcessor","state","samplesSinceLastReport","frameCount","lastFrameProcessedAt","promiseQueue","timeSlice","sampleRate","processorOptions","allowedTimeSlice","some","val","allowedTimeSliceJson","samplesPerWindow","buffer","bufferPool","stateServer","workerPort","worker","_noWait","terminate","releaseBuffer","process","inputs","outputs","hasInput","input","audioArrayBuffer","audioArray","onEncoderWorkletSamples","gain","monoPcm","stride","sum","approximateGain","recordingInProgress","runDiagnostics","diagnosticsState","encoderWorkletState","lastEncoderWorkletFrameProcessedAt","registerProcessor"],"sourceRoot":""}