{"version":3,"file":"feederWorklet.js","mappings":"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","sources":["webpack:///./node_modules/denque/index.js","webpack:///webpack/bootstrap","webpack:///webpack/runtime/compat get default export","webpack:///webpack/runtime/define property getters","webpack:///webpack/runtime/hasOwnProperty shorthand","webpack:///./src/_constants.ts","webpack:///./src/logging-init.ts","webpack:///./node_modules/heap-js/dist/heap-js.es5.js","webpack:///./src/logging.ts","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:///../dotnet/UI.Blazor.App/Components/AudioPlayer/worklets/feeder-audio-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","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// All crucial constants are here\n// !DELAYER means it affects on audio delay.\n\ntype AllowedSampleRate = 48000 | 16000;\n\nconst REC_SAMPLES_PER_MS = 16; // 16KHz\nexport const AUDIO_REC = {\n    SAMPLE_RATE: 1000 * REC_SAMPLES_PER_MS as AllowedSampleRate,\n    SAMPLES_PER_MS: REC_SAMPLES_PER_MS,\n    SAMPLES_PER_WINDOW_32: REC_SAMPLES_PER_MS * 32,\n    SAMPLES_PER_WINDOW_30: REC_SAMPLES_PER_MS * 30,\n    SAMPLES_PER_RECORDING_IN_PROGRESS_CALL: REC_SAMPLES_PER_MS * 200,\n    // In seconds:\n    SAMPLE_DURATION: 0.001 / REC_SAMPLES_PER_MS,\n    MIN_RECORDING_GAIN: 0.0005, // Min gain to consider recording as \"active\"\n    MIN_MICROPHONE_GAIN: 0, // Min gain to consider microphone sends real samples\n}\n\nconst PLAY_SAMPLES_PER_MS = 48; // 48KHz\nexport const AUDIO_PLAY = {\n    SAMPLE_RATE: 1000 * PLAY_SAMPLES_PER_MS as AllowedSampleRate,\n    SAMPLES_PER_MS: PLAY_SAMPLES_PER_MS,\n    SAMPLES_PER_WINDOW: 20 * PLAY_SAMPLES_PER_MS, // 20ms\n    // In seconds:\n    SAMPLE_DURATION: 0.001 / PLAY_SAMPLES_PER_MS,\n    BUFFER_TO_PLAY_DURATION: 0.1, // !DELAYER: How much to buffer before we start playing\n    BUFFER_LOW_DURATION: 10.0, // Buffer is \"low\" while it's less than this\n    STATE_UPDATE_PERIOD: 0.2, // The period between feeder state update signals\n    MEDIA_SESSION_RESET_DEBOUNCE_MS: 5000, // The period to debounce media session metadata (displays info that Actual Chat is playing at iOS) reset\n}\n\nconst ENC_FRAME_DURATION_MS = 20; // 20ms\nconst ENC_BIT_RATE = 32 * 1024; // 32Kbps = 4KB/s = ~80 bytes per frame\nconst ENC_BYTE_RATE = Math.round(ENC_BIT_RATE / 8);\nconst ENC_FRAME_BYTES = Math.round(ENC_BIT_RATE * ENC_FRAME_DURATION_MS / 1000 / 8);\nexport const AUDIO_ENCODER = {\n    FRAME_DURATION_MS: ENC_FRAME_DURATION_MS,\n    BIT_RATE: ENC_BIT_RATE,\n    BYTE_RATE: ENC_BYTE_RATE,\n    FRAME_SAMPLES: REC_SAMPLES_PER_MS * ENC_FRAME_DURATION_MS,\n    FRAME_BYTES: ENC_FRAME_BYTES,\n    FRAME_BUFFER_BYTES: 2 * ENC_FRAME_BYTES,\n    FADE_FRAMES: 3, // 60ms, it's fade-in @ start and fade-out @ the end\n    MAX_BUFFERED_FRAMES: 50, // 1s, it doesn't have to be large now, coz frames are instantly added to streams\n    DEFAULT_PRE_SKIP: 312, // Pre-skip / codec delay measured in samples. It's the default one, used w/ system encoder, which doesn't provide it.\n}\n\nexport const AUDIO_STREAMER = {\n    MAX_STREAMS: 3, // Max streams to keep sending\n    DELAY_FRAMES: 5, // 100ms - !DELAYER: streamer won't start sending until it gets these frames (~400 bytes)\n    MIN_PACK_FRAMES: 3, // 60ms - min. # of frames to send at once (~240 bytes)\n    MAX_PACK_FRAMES: 10, // 200ms - max. # of frames to send at once (~800 bytes)\n    MAX_BUFFERED_FRAMES: 1500, // 30s (~120KB)\n    MAX_SPEED: 2, // Max streaming speed - relative to real-time; must be >1, but not too high to avoid queued stream overlap\n    // In seconds:\n    INTER_STREAM_DELAY: 0.1, // Must be >0\n    MAX_CONNECT_DURATION: 5, // Max duration of \"connecting\" state of SignalR connection inside ensureConnected\n    MAX_QUICK_CONNECT_DURATION: 0.5, // Same as above, but when quickReconnect = true\n    STREAM_ERROR_DELAY: 1,\n    CONNECT_ERROR_DELAY: 1,\n    DEBUG: { // Debug switches\n        RANDOM_DISCONNECT_PERIOD_MS: 0, // Random disconnect period, 5000 is a good one\n    }\n}\n\nexport const AUDIO_VAD = {\n    // All durations below are in seconds\n    MIN_SPEECH: 0.5, // When the speech is detected, it will always send at this much at least\n    MAX_SPEECH: 60 * 2, // Max speech duration - if it takes longer, VAD will generate a hard split anyway\n    MIN_SPEECH_TO_CANCEL_PAUSE: 0.15, // Min. speech duration required to cancel non-materialized pause\n    MIN_PAUSE: 0.2, // Min pause duration that triggers split\n    MAX_PAUSE: 2.7, // Max pause duration that triggers split\n    MAX_CONV_PAUSE: 0.65, // Max pause duration that triggers pause in \"conversation\" mode\n    CONV_DURATION: 30, // A period from conversationSignal to the moment VAD assumes the conversation ended\n    PAUSE_VARIES_FROM: 10, // Pause starts to vary from (MAX_PAUSE or MAX_CONV_PAUSE) to MIN_PAUSE at this speech duration\n    PAUSE_VARY_POWER: Math.sqrt(2), // The power used in max_pause = lerp(MAX_PAUSE, MIN_PAUSE, pow(alpha, THIS_VALUE))\n    SKIP_FIRST_RECORDING_MS: 300, // Microphone stream begins with some noise that triggers WebRTC VAD\n    SKIP_SEQUENTIAL_CALLS_MS: 5, // Skip batch calls to VAD when duration between calls is less than 5ms - VAD works with 30ms and 32 ms chunks\n    // All durations below are in samples (16KHz = 16 samples per ms)\n    NN_VAD_CONTEXT_SAMPLES: 64, // 4ms, the length of NN VAD buffer \"prefix\" copied from the end of prev. buffer\n};\n","// Should be the same as logging.LogLevel, but local to this module\nexport enum LogLevel {\n    Debug = 1,\n    Info,\n    Warn,\n    Error,\n    None = 1000,\n}\n\nexport type LogScope =\n    'default'\n    // Library\n    | 'AsyncProcessor'\n    | 'BrowserInfo'\n    | 'BrowserInit'\n    | 'BubbleHost'\n    | 'Connectivity'\n    | 'Gestures'\n    | 'event-handling'\n    | 'InertialScroll'\n    | 'NoSleep'\n    | 'History'\n    | 'Interactive'\n    | 'Kvas'\n    | 'KvasBackend'\n    | 'MenuHost'\n    | 'ModalHost'\n    | 'OnDeviceAwake'\n    | 'promises'\n    | 'Rpc'\n    | 'ScreenSize'\n    | 'ServiceWorker'\n    | 'SessionTokens'\n    | 'TimerQueue'\n    | 'UndoStack'\n    | 'Versioning'\n    | 'VirtualList'\n    // XxxUI\n    | 'DebugUI'\n    | 'DeviceAwakeUI'\n    | 'FocusUI'\n    | 'InteractiveUI'\n    | 'KeepAwakeUI'\n    | 'LanguageUI'\n    | 'NotificationUI'\n    | 'TuneUI'\n    | 'UserActivityUI'\n    | 'VibrationUI'\n    | 'Share'\n    // Audio\n    | 'AudioContextRef'\n    | 'AudioContextSource'\n    | 'AudioInfo'\n    // Audio playback\n    | 'AudioPlayer'\n    | 'FallbackPlayback'\n    | 'OpusDecoder'\n    | 'OpusDecoderWorker'\n    | 'FeederNode'\n    | 'FeederProcessor'\n    | 'SoundsPlayer'\n    // Audio recording\n    | 'AudioRecorder'\n    | 'AudioStreamer'\n    | 'OpusMediaRecorder'\n    | 'AudioVadWorker'\n    | 'AudioVadWorkletProcessor'\n    | 'OpusEncoderWorkletProcessor'\n    | 'OpusEncoderWorker'\n    | 'WarmUpAudioWorkletProcessor'\n    | 'WebRtcAec' // Unused\n    // Isolated components\n    | 'Attachments'\n    | 'ChatMessageEditor'\n    | 'CodeBlockMarkupView'\n    | 'CopyTrigger'\n    | 'FontSizes'\n    | 'Landing'\n    | 'LandingLeftMenu'\n    | 'MarkupEditor'\n    | 'MessageEditor'\n    | 'SearchPanel'\n    | 'SideNav'\n    | 'SelectionHost'\n    | 'TextBox'\n    | 'Theme'\n    | 'TooltipHost'\n    | 'UserInterface'\n    | 'VisualMediaViewer'\n    | 'WebAuth';\n\nconst GlobalThisKey = 'logLevels';\nconst StorageKey = 'logLevels';\nconst DateStorageKey = `${StorageKey}.date`;\nconst MaxStorageAge = 86_400_000 * 3; // 3 days\n\nconst app = globalThis?.['App'] as unknown;\nconst isWorkerOrWorklet = !app;\n\nexport function initLogging(Log: unknown): void {\n    Log['defaultMinLevel'] = LogLevel.Info;\n    const minLevels = Log['minLevels'] as Map<LogScope, LogLevel>;\n\n    let wasRestored = false;\n    if (globalThis && !isWorkerOrWorklet) {\n        globalThis[GlobalThisKey] = new LogLevelController(minLevels);\n        wasRestored = restore(minLevels);\n    }\n    if (wasRestored) {\n        console.log(`Logging: logLevels are restored`);\n    }\n    else {\n        if (!isWorkerOrWorklet)\n            console.log(`Logging: logLevels are reset`);\n        reset(minLevels);\n    }\n}\n\nclass LogLevelController {\n    constructor (private minLevels: Map<LogScope, LogLevel>)\n    { }\n\n    public override(scope: LogScope, newLevel: LogLevel): void {\n        this.minLevels.set(scope, newLevel);\n        persist(this.minLevels);\n    }\n\n    public reset(isProduction?: boolean) {\n        reset(this.minLevels, isProduction);\n        persist(this.minLevels);\n    }\n\n    public clear(defaultLevel?: LogLevel) {\n        this.minLevels.clear();\n        if (defaultLevel !== undefined)\n            this.minLevels['default'] = defaultLevel;\n        persist(this.minLevels);\n    }\n}\n\nconst sessionStorage = globalThis?.sessionStorage;\n\nfunction restore(minLevels: Map<string, LogLevel>): boolean {\n    if (!sessionStorage)\n        return false;\n\n    const dateJson = sessionStorage.getItem(DateStorageKey);\n    if (!dateJson)\n        return false;\n    if (Date.now() - JSON.parse(dateJson) > MaxStorageAge)\n        return false;\n\n    const readJson = sessionStorage.getItem(StorageKey);\n    if (!readJson)\n        return false;\n\n    const readMinLevels = new Map(JSON.parse(readJson) as [string, LogLevel][]);\n    if (!(typeof readMinLevels.size === 'number'))\n        return false;\n\n    minLevels.clear();\n    readMinLevels.forEach((value, key) => minLevels.set(key, value));\n    return true;\n}\n\nfunction persist(minLevels: Map<string, LogLevel>): boolean {\n    if (!sessionStorage)\n        return false;\n\n    sessionStorage.setItem(DateStorageKey, JSON.stringify(Date.now()));\n    sessionStorage.setItem(StorageKey, JSON.stringify(Array.from(minLevels.entries())));\n    return true;\n}\n\nfunction reset(minLevels: Map<LogScope, LogLevel>, isProduction?: boolean): void {\n    minLevels.clear();\n    // enabled debug logging temporarily - do not add chatty log scopes!! - 14.11.2023 AK\n\n    // isProduction ??= app?.['environment'] == 'Production';\n    // if (isProduction)\n    //     return;\n\n    // Bumping down levels of in-dev scopes\n    // minLevels.set('Versioning', LogLevel.Debug);\n    // minLevels.set('Gestures', LogLevel.Debug);\n    // minLevels.set('event-handling', LogLevel.Debug);\n    // minLevels.set('Rpc', LogLevel.Debug);\n    // minLevels.set('AsyncProcessor', LogLevel.Debug);\n    // minLevels.set('promises', LogLevel.Debug);\n    minLevels.set('Interactive', LogLevel.Debug);\n    minLevels.set('OnDeviceAwake', LogLevel.Debug);\n    minLevels.set('AudioContextRef', LogLevel.Debug);\n    minLevels.set('AudioContextSource', LogLevel.Debug);\n    minLevels.set('AudioPlayer', LogLevel.Debug);\n    // minLevels.set('FallbackPlayback', LogLevel.Debug);\n    // minLevels.set('OpusDecoder', LogLevel.Debug);\n    // minLevels.set('OpusDecoderWorker', LogLevel.Debug);\n    // minLevels.set('FeederProcessor', LogLevel.Debug);\n    minLevels.set('AudioRecorder', LogLevel.Debug);\n    // minLevels.set('AudioStreamer', LogLevel.Debug);\n    minLevels.set('OpusMediaRecorder', LogLevel.Debug);\n    // minLevels.set('AudioVadWorker', LogLevel.Debug);\n    // minLevels.set('AudioVadWorkletProcessor', LogLevel.Debug);\n    // minLevels.set('OpusEncoderWorker', LogLevel.Debug);\n    // minLevels.set('OpusEncoderWorkletProcessor', LogLevel.Debug);\n    // minLevels.set('InertialScroll', LogLevel.Debug);\n    minLevels.set('VirtualList', LogLevel.Debug);\n    // minLevels.set('Landing', LogLevel.Debug);\n    // minLevels.set('LandingLeftMenu', LogLevel.Debug);\n    // minLevels.set('SideNav', LogLevel.Debug);\n\n    // XxxUI\n    // minLevels.set('FocusUI', LogLevel.Debug);\n    // minLevels.set('KeepAwakeUI', LogLevel.Debug);\n    // minLevels.set('NoSleep', LogLevel.Debug);\n    // minLevels.set('NotificationUI', LogLevel.Debug);\n    // minLevels.set('TuneUI', LogLevel.Debug);\n    // minLevels.set('SoundsPlayer', LogLevel.Debug);\n\n    // Isolated components\n    // minLevels.set('History', LogLevel.Debug);\n    // minLevels.set('MenuHost', LogLevel.Debug);\n    // minLevels.set('MarkupEditor', LogLevel.Debug);\n    // minLevels.set('ChatMessageEditor', LogLevel.Debug);\n\n    // minLevels.clear(); // To quickly discard any tweaks :)\n    persist(minLevels);\n}\n","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 { 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","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 { AUDIO_PLAY as AP } from '_constants';\nimport Denque from 'denque';\nimport { timerQueue } from 'timerQueue';\nimport {\n    BufferState,\n    FeederAudioWorkletEventHandler,\n    FeederAudioWorklet,\n    FeederState,\n    PlaybackState,\n} from './feeder-audio-worklet-contract';\nimport { rpcClientServer, rpcNoWait, RpcNoWait } from 'rpc';\nimport { Disposable } from 'disposable';\nimport { ResolvedPromise } from 'promises';\nimport { Log } from 'logging';\nimport { BufferHandler } from '../workers/opus-decoder-worker-contract';\nimport { AudioRingBuffer } from '../../AudioRecorder/audio-ring-buffer';\n\nconst { logScope, debugLog, warnLog } = Log.get('FeederProcessor');\n\n/** Part of the feeder that lives in [AudioWorkletGlobalScope]{@link https://developer.mozilla.org/en-US/docs/Web/API/AudioWorkletGlobalScope} */\nclass FeederAudioWorkletProcessor extends AudioWorkletProcessor implements FeederAudioWorklet {\n    private readonly chunks = new Denque<Float32Array | 'end'>();\n    private readonly buffer: AudioRingBuffer;\n    /**\n     * 128 samples at 48 kHz ~= 2.67 ms\n     * 240_000 samples at 48 kHz ~= 5_000 ms\n     * 480_000 samples at 48 kHz ~= 10_000 ms\n     */\n    private id: string;\n    private node: FeederAudioWorkletEventHandler & Disposable;\n    private decoder: BufferHandler & Disposable;\n    /** In seconds from the start of playing, excluding starving time and processing time */\n    private playingAt = 0;\n    private skipSamples = 0;\n    private playbackState: PlaybackState = 'paused';\n    private bufferState: BufferState = 'ok';\n    private lastReportedState: FeederState = null;\n    private isEnding = false;\n    private bufferSizeToStartPlayback = AP.BUFFER_TO_PLAY_DURATION;\n    private lastStarvingEventAt: number = 0;\n\n    constructor(options: AudioWorkletNodeOptions) {\n        super(options);\n        this.node = rpcClientServer<FeederAudioWorkletEventHandler>(`${logScope}.server`, this.port, this);\n        this.buffer = new AudioRingBuffer(8192, 1);\n    }\n\n    private get bufferedDuration(): number {\n        return this.bufferedSampleCount * AP.SAMPLE_DURATION;\n    }\n\n    private get bufferedSampleCount(): number {\n        const { chunks, buffer } = this;\n        let result = buffer.samplesAvailable;\n        for (let i = 0; i <  chunks.length; ++i) {\n            const chunk = chunks.peekAt(i);\n            result += chunk.length;\n        }\n        return result;\n    }\n\n    public async init(id: string, workerPort: MessagePort): Promise<void> {\n        this.id = id;\n        this.decoder = rpcClientServer<BufferHandler>(`${logScope}.worker`, workerPort, this);\n        debugLog?.log(`#${this.id}.init`);\n    }\n\n    public frame(buffer: ArrayBuffer, offset: number, length: number, noWait?: RpcNoWait): Promise<void> {\n        // debugLog?.log(`#${this.id} -> frame()`);\n        if (this.playbackState === 'ended' || this.isEnding) {\n            // Send buffer back\n            void this.decoder.releaseBuffer(buffer, rpcNoWait);\n            return;\n        }\n\n        this.chunks.push(new Float32Array(buffer, offset, length));\n        this.tryBeginPlaying();\n        // debugLog?.log(`#${this.id} <- frame()`);\n        return ResolvedPromise.Void;\n    }\n\n    public pause(_noWait?: RpcNoWait): Promise<void> {\n        if (this.playbackState === 'paused' || this.playbackState === 'ended')\n            return;\n\n        debugLog?.log(`#${this.id}.pause`);\n        this.playbackState = 'paused';\n        this.stateHasChanged();\n        return ResolvedPromise.Void;\n    }\n\n    public resume(preSkip: number): Promise<void> {\n        this.playingAt = 0;\n        this.skipSamples = preSkip;\n\n        if (this.playbackState === 'playing')\n            return;\n\n        debugLog?.log(`#${this.id}.resume`);\n        this.playbackState = this.playbackState === 'ended'\n            ? 'paused'\n            : 'playing';\n        this.stateHasChanged();\n        return ResolvedPromise.Void;\n    }\n\n    public async end(mustAbort: boolean, _noWait?: RpcNoWait): Promise<void> {\n        if (this.playbackState === 'ended') {\n            warnLog?.log(`#${this.id}.end, but playback is already ended`);\n            return;\n        }\n\n        debugLog?.log(`#${this.id}.end, mustAbort:`, mustAbort);\n\n        this.isEnding = true;\n        this.playbackState = 'playing';\n        if (mustAbort) {\n            this.chunks.clear();\n            this.playingAt = 0;\n            this.buffer.reset();\n        }\n        this.chunks.push('end');\n    }\n\n    public process(\n        _inputs: Float32Array[][],\n        outputs: Float32Array[][],\n        _parameters: { [name: string]: Float32Array; },\n    ): boolean {\n        timerQueue?.triggerExpired();\n        if (outputs == null || outputs.length === 0 || outputs[0].length === 0)\n            return true;\n\n        const output = outputs[0];\n        // We only support mono output at the moment\n        const channel = output[0];\n        warnLog?.assert(channel.length === 128, `#${this.id}.process: WebAudio's render quantum size must be 128`);\n\n        if (this.playbackState !== 'playing') {\n            // Write silence, because we aren't playing (even when starving)\n            channel.fill(0);\n            // Keep worklet up and running even in ended state for reuse\n            return true;\n        }\n\n        // We're in 'playing' state anywhere below this point\n        // @ts-ignore - accessible from the AudioWorkletGlobalScope\n        const time = currentTime;\n        if (this.buffer.samplesAvailable >= channel.length) {\n            this.buffer.pull([channel])\n            this.playingAt += channel.length * AP.SAMPLE_DURATION;\n            return true;\n        }\n\n        while (this.buffer.samplesAvailable < channel.length) {\n            const samplesAvailable = this.buffer.samplesAvailable;\n            let chunk = this.chunks.shift();\n            if (chunk === undefined) {\n                // Not enough data to continue playing => starving\n                channel.fill(0);\n                if (samplesAvailable) {\n                    const channelChunk = new Float32Array(channel.buffer, 0, samplesAvailable);\n                    this.buffer.pull([channelChunk]);\n                    this.playingAt += channelChunk.length * AP.SAMPLE_DURATION;\n                }\n\n                this.playbackState = 'starving';\n                if (time - this.lastStarvingEventAt > 1000)\n                    // Increase buffer size to prevent starving if previous event has happened earlier than 1s before\n                    this.bufferSizeToStartPlayback += AP.BUFFER_TO_PLAY_DURATION;\n                this.lastStarvingEventAt = time;\n                this.stateHasChanged();\n                return true;\n            }\n            else if (chunk === 'end') {\n                channel.fill(0);\n                debugLog?.log(`#${this.id}.process: got 'end'`);\n                this.isEnding = false;\n                this.playbackState = 'ended';\n                this.playingAt = 0;\n                this.buffer.reset();\n                while (chunk) {\n                    chunk = this.chunks.shift();\n                    if (chunk !== 'end' && chunk)\n                        void this.decoder.releaseBuffer(chunk.buffer, rpcNoWait);\n                }\n                this.chunks.clear();\n                this.stateHasChanged();\n                // Keep worklet up and running even in ended state for reuse\n                return true;\n            }\n            this.buffer.push([chunk]);\n            void this.decoder.releaseBuffer(chunk.buffer, rpcNoWait);\n            if (this.skipSamples) {\n                const skipSamples = Math.min(this.skipSamples, this.buffer.samplesAvailable);\n                this.buffer.pull([new Float32Array(skipSamples)]);\n                this.skipSamples -= skipSamples;\n            }\n        }\n        this.buffer.pull([channel]);\n        this.playingAt += channel.length * AP.SAMPLE_DURATION;\n        // Decrease buffer size when there were no starving events during last 5s\n        if (time - this.lastStarvingEventAt > 5000)\n            this.bufferSizeToStartPlayback = Math.max(\n                this.bufferSizeToStartPlayback - AP.BUFFER_TO_PLAY_DURATION,\n                AP.BUFFER_TO_PLAY_DURATION);\n\n        this.stateHasChanged();\n        return true;\n    }\n\n    private stateHasChanged() {\n        const bufferedDuration = this.bufferedDuration;\n        if (this.isEnding)\n            this.bufferState = 'ok';\n        else {\n            this.bufferState = bufferedDuration < AP.BUFFER_LOW_DURATION ? 'low' : 'ok';\n        }\n\n        const state: FeederState = {\n            playbackState: this.playbackState,\n            bufferState: this.bufferState,\n            playingAt: this.playingAt,\n            bufferedDuration: bufferedDuration,\n        };\n        const mustSkip =\n            this.lastReportedState\n            && state.playbackState === this.lastReportedState.playbackState\n            && state.bufferState === this.lastReportedState.bufferState\n            && Math.abs(state.playingAt - this.lastReportedState.playingAt) < AP.STATE_UPDATE_PERIOD;\n        if (mustSkip)\n            return;\n\n        this.lastReportedState = state;\n        void this.node.onStateChanged(state, rpcNoWait);\n    }\n\n    private tryBeginPlaying(): void {\n        if (this.playbackState === 'playing' || this.bufferedDuration < this.bufferSizeToStartPlayback)\n            return;\n\n        debugLog?.log(`#${this.id}.tryBeginPlaying: starting playback`);\n        this.isEnding = false;\n        this.playbackState = 'playing';\n        this.stateHasChanged();\n    }\n}\n\nregisterProcessor('feederWorklet', FeederAudioWorkletProcessor);\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__","n","getter","__esModule","d","a","definition","key","o","enumerable","obj","prop","hasOwnProperty","call","AUDIO_PLAY","round","ENC_BIT_RATE","sqrt","LogLevel","__generator","thisArg","body","f","y","t","g","_","label","sent","trys","ops","next","verb","Symbol","iterator","v","op","TypeError","done","value","e","step","__read","m","r","ar","error","__spreadArray","to","from","pack","l","concat","Heap","compare","minComparator","_this","heapArray","_limit","offer","add","element","poll","_invertedCompare","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","el","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","findIndex","_sortNodeDown","leafs","configurable","set","_l","last","_i","_topN_push","toString","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","StorageKey","DateStorageKey","MaxStorageAge","isWorkerOrWorklet","globalThis","initLogging","Log","Info","minLevels","wasRestored","LogLevelController","sessionStorage","dateJson","getItem","Date","now","JSON","parse","readJson","readMinLevels","Map","forEach","restore","console","constructor","override","scope","newLevel","persist","reset","isProduction","defaultLevel","setItem","stringify","entries","Debug","level","prefix","data","debug","Warn","warn","Error","None","trace","isInitialized","minLevel","defaultMinLevel","getLogger","loggerFactory","logScope","debugLog","infoLog","warnLog","errorLog","ref","logRefs","assert","predicate","idSeed","items","itemIndex","target","existentItem","touchedAt","id","newRef","removeOldest","newItem","indexToEliminate","itemToEliminate","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","FeederAudioWorkletProcessor","AudioWorkletProcessor","chunks","playingAt","skipSamples","playbackState","bufferState","lastReportedState","isEnding","bufferSizeToStartPlayback","lastStarvingEventAt","buffer","bufferedDuration","bufferedSampleCount","workerPort","decoder","frame","offset","tryBeginPlaying","releaseBuffer","pause","_noWait","stateHasChanged","resume","preSkip","end","mustAbort","process","_inputs","outputs","_parameters","currentTime","chunk","channelChunk","min","state","abs","onStateChanged","registerProcessor"],"sourceRoot":""}