"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.VoiceBroadcastPlaybackState = exports.VoiceBroadcastPlaybackEvent = exports.VoiceBroadcastPlayback = void 0;
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _matrix = require("matrix-js-sdk/src/matrix");
var _matrixWidgetApi = require("matrix-widget-api");
var _logger = require("matrix-js-sdk/src/logger");
var _utils = require("matrix-js-sdk/src/utils");
var _Playback = require("../../audio/Playback");
var _PlaybackManager = require("../../audio/PlaybackManager");
var _AsyncStore = require("../../stores/AsyncStore");
var _MediaEventHelper = require("../../utils/MediaEventHelper");
var _ = require("..");
var _RelationsHelper = require("../../events/RelationsHelper");
var _VoiceBroadcastChunkEvents = require("../utils/VoiceBroadcastChunkEvents");
var _determineVoiceBroadcastLiveness = require("../utils/determineVoiceBroadcastLiveness");
var _languageHandler = require("../../languageHandler");
/*
Copyright 2024 New Vector Ltd.
Copyright 2022 The Matrix.org Foundation C.I.C.

SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only
Please see LICENSE files in the repository root for full details.
*/
let VoiceBroadcastPlaybackState = exports.VoiceBroadcastPlaybackState = /*#__PURE__*/function (VoiceBroadcastPlaybackState) {
  VoiceBroadcastPlaybackState["Paused"] = "pause";
  VoiceBroadcastPlaybackState["Playing"] = "playing";
  VoiceBroadcastPlaybackState["Stopped"] = "stopped";
  VoiceBroadcastPlaybackState["Buffering"] = "buffering";
  VoiceBroadcastPlaybackState["Error"] = "error";
  return VoiceBroadcastPlaybackState;
}({});
let VoiceBroadcastPlaybackEvent = exports.VoiceBroadcastPlaybackEvent = /*#__PURE__*/function (VoiceBroadcastPlaybackEvent) {
  VoiceBroadcastPlaybackEvent["TimesChanged"] = "times_changed";
  VoiceBroadcastPlaybackEvent["LivenessChanged"] = "liveness_changed";
  VoiceBroadcastPlaybackEvent["StateChanged"] = "state_changed";
  VoiceBroadcastPlaybackEvent["InfoStateChanged"] = "info_state_changed";
  return VoiceBroadcastPlaybackEvent;
}({});
class VoiceBroadcastPlayback extends _matrix.TypedEventEmitter {
  constructor(infoEvent, client, recordings) {
    super();
    (0, _defineProperty2.default)(this, "state", VoiceBroadcastPlaybackState.Stopped);
    (0, _defineProperty2.default)(this, "chunkEvents", new _VoiceBroadcastChunkEvents.VoiceBroadcastChunkEvents());
    /** @var Map: event Id → undecryptable event */
    (0, _defineProperty2.default)(this, "utdChunkEvents", new Map());
    (0, _defineProperty2.default)(this, "playbacks", new Map());
    (0, _defineProperty2.default)(this, "currentlyPlaying", null);
    /** @var total duration of all chunks in milliseconds */
    (0, _defineProperty2.default)(this, "duration", 0);
    /** @var current playback position in milliseconds */
    (0, _defineProperty2.default)(this, "position", 0);
    (0, _defineProperty2.default)(this, "liveData", new _matrixWidgetApi.SimpleObservable());
    (0, _defineProperty2.default)(this, "liveness", "not-live");
    // set via addInfoEvent() in constructor
    (0, _defineProperty2.default)(this, "infoState", void 0);
    (0, _defineProperty2.default)(this, "lastInfoEvent", void 0);
    // set via setUpRelationsHelper() in constructor
    (0, _defineProperty2.default)(this, "chunkRelationHelper", void 0);
    (0, _defineProperty2.default)(this, "infoRelationHelper", void 0);
    (0, _defineProperty2.default)(this, "skipToNext", void 0);
    (0, _defineProperty2.default)(this, "skipToDeferred", void 0);
    (0, _defineProperty2.default)(this, "addChunkEvent", async event => {
      if (!event.getId() && !event.getTxnId()) {
        // skip events without id and txn id
        return false;
      }
      if (event.isDecryptionFailure()) {
        this.onChunkEventDecryptionFailure(event);
        return false;
      }
      if (event.getContent()?.msgtype !== _matrix.MsgType.Audio) {
        // skip non-audio event
        return false;
      }
      this.chunkEvents.addEvent(event);
      this.setDuration(this.chunkEvents.getLength());
      if (this.getState() === VoiceBroadcastPlaybackState.Buffering) {
        await this.startOrPlayNext();
      }
      return true;
    });
    (0, _defineProperty2.default)(this, "onChunkEventDecryptionFailure", event => {
      const eventId = event.getId();
      if (!eventId) {
        // This should not happen, as the existence of the Id is checked before the call.
        // Log anyway and return.
        _logger.logger.warn("Broadcast chunk decryption failure for event without Id", {
          broadcast: this.infoEvent.getId()
        });
        return;
      }
      if (!this.utdChunkEvents.has(eventId)) {
        event.once(_matrix.MatrixEventEvent.Decrypted, this.onChunkEventDecrypted);
      }
      this.utdChunkEvents.set(eventId, event);
      this.setError();
    });
    (0, _defineProperty2.default)(this, "onChunkEventDecrypted", async event => {
      const eventId = event.getId();
      if (!eventId) {
        // This should not happen, as the existence of the Id is checked before the call.
        // Log anyway and return.
        _logger.logger.warn("Broadcast chunk decrypted for event without Id", {
          broadcast: this.infoEvent.getId()
        });
        return;
      }
      this.utdChunkEvents.delete(eventId);
      await this.addChunkEvent(event);
      if (this.utdChunkEvents.size === 0) {
        // no more UTD events, recover from error to paused
        this.setState(VoiceBroadcastPlaybackState.Paused);
      }
    });
    (0, _defineProperty2.default)(this, "startOrPlayNext", async () => {
      if (this.currentlyPlaying) {
        return this.playNext();
      }
      return await this.start();
    });
    (0, _defineProperty2.default)(this, "addInfoEvent", event => {
      if (this.lastInfoEvent && this.lastInfoEvent.getTs() >= event.getTs()) {
        // Only handle newer events
        return;
      }
      const state = event.getContent()?.state;
      if (!Object.values(_.VoiceBroadcastInfoState).includes(state)) {
        // Do not handle unknown voice broadcast states
        return;
      }
      this.lastInfoEvent = event;
      this.setInfoState(state);
    });
    (0, _defineProperty2.default)(this, "onBeforeRedaction", () => {
      if (this.getState() !== VoiceBroadcastPlaybackState.Stopped) {
        this.stop();
        // destroy cleans up everything
        this.destroy();
      }
    });
    (0, _defineProperty2.default)(this, "onPlaybackPositionUpdate", (event, position) => {
      if (event !== this.currentlyPlaying) return;
      const newPosition = this.chunkEvents.getLengthTo(event) + position * 1000; // observable sends seconds

      // do not jump backwards - this can happen when transiting from one to another chunk
      if (newPosition < this.position) return;
      this.setPosition(newPosition);
    });
    (0, _defineProperty2.default)(this, "onPlaybackStateChange", async (event, newState) => {
      if (event !== this.currentlyPlaying) return;
      if (newState !== _Playback.PlaybackState.Stopped) return;
      await this.playNext();
      this.unloadPlayback(event);
    });
    this.infoEvent = infoEvent;
    this.client = client;
    this.recordings = recordings;
    this.addInfoEvent(this.infoEvent);
    this.infoEvent.on(_matrix.MatrixEventEvent.BeforeRedaction, this.onBeforeRedaction);
    this.setUpRelationsHelper();
  }
  async setUpRelationsHelper() {
    this.infoRelationHelper = new _RelationsHelper.RelationsHelper(this.infoEvent, _matrix.RelationType.Reference, _.VoiceBroadcastInfoEventType, this.client);
    this.infoRelationHelper.getCurrent().forEach(this.addInfoEvent);
    if (this.infoState !== _.VoiceBroadcastInfoState.Stopped) {
      // Only required if not stopped. Stopped is the final state.
      this.infoRelationHelper.on(_RelationsHelper.RelationsHelperEvent.Add, this.addInfoEvent);
      try {
        await this.infoRelationHelper.emitFetchCurrent();
      } catch (err) {
        _logger.logger.warn("error fetching server side relation for voice broadcast info", err);
        // fall back to local events
        this.infoRelationHelper.emitCurrent();
      }
    }
    this.chunkRelationHelper = new _RelationsHelper.RelationsHelper(this.infoEvent, _matrix.RelationType.Reference, _matrix.EventType.RoomMessage, this.client);
    this.chunkRelationHelper.on(_RelationsHelper.RelationsHelperEvent.Add, this.addChunkEvent);
    try {
      // TODO Michael W: only fetch events if needed, blocked by PSF-1708
      await this.chunkRelationHelper.emitFetchCurrent();
    } catch (err) {
      _logger.logger.warn("error fetching server side relation for voice broadcast chunks", err);
      // fall back to local events
      this.chunkRelationHelper.emitCurrent();
    }
  }
  async tryLoadPlayback(chunkEvent) {
    try {
      return await this.loadPlayback(chunkEvent);
    } catch (err) {
      _logger.logger.warn("Unable to load broadcast playback", {
        message: err.message,
        broadcastId: this.infoEvent.getId(),
        chunkId: chunkEvent.getId()
      });
      this.setError();
    }
  }
  async loadPlayback(chunkEvent) {
    const eventId = chunkEvent.getId();
    if (!eventId) {
      throw new Error("Broadcast chunk event without Id occurred");
    }
    const helper = new _MediaEventHelper.MediaEventHelper(chunkEvent);
    const blob = await helper.sourceBlob.value;
    const buffer = await blob.arrayBuffer();
    const playback = _PlaybackManager.PlaybackManager.instance.createPlaybackInstance(buffer);
    await playback.prepare();
    playback.clockInfo.populatePlaceholdersFrom(chunkEvent);
    this.playbacks.set(eventId, playback);
    playback.on(_AsyncStore.UPDATE_EVENT, state => this.onPlaybackStateChange(chunkEvent, state));
    playback.clockInfo.liveData.onUpdate(([position]) => {
      this.onPlaybackPositionUpdate(chunkEvent, position);
    });
  }
  unloadPlayback(event) {
    const playback = this.playbacks.get(event.getId());
    if (!playback) return;
    playback.destroy();
    this.playbacks.delete(event.getId());
  }
  setDuration(duration) {
    if (this.duration === duration) return;
    this.duration = duration;
    this.emitTimesChanged();
    this.liveData.update([this.timeSeconds, this.durationSeconds]);
  }
  setPosition(position) {
    if (this.position === position) return;
    this.position = position;
    this.emitTimesChanged();
    this.liveData.update([this.timeSeconds, this.durationSeconds]);
  }
  emitTimesChanged() {
    this.emit(VoiceBroadcastPlaybackEvent.TimesChanged, {
      duration: this.durationSeconds,
      position: this.timeSeconds,
      timeLeft: this.timeLeftSeconds
    });
  }
  async playNext() {
    if (!this.currentlyPlaying) return;
    const next = this.chunkEvents.getNext(this.currentlyPlaying);
    if (next) {
      return this.playEvent(next);
    }
    if (this.getInfoState() === _.VoiceBroadcastInfoState.Stopped && this.chunkEvents.getSequenceForEvent(this.currentlyPlaying) === this.lastChunkSequence) {
      this.stop();
    } else {
      // No more chunks available, although the broadcast is not finished → enter buffering state.
      this.setState(VoiceBroadcastPlaybackState.Buffering);
    }
  }

  /**
   * @returns {number} The last chunk sequence from the latest info event.
   *                   Falls back to the length of received chunks if the info event does not provide the number.
   */
  get lastChunkSequence() {
    return this.lastInfoEvent.getContent()?.last_chunk_sequence || this.chunkEvents.getNumberOfEvents();
  }
  async playEvent(event) {
    this.setState(VoiceBroadcastPlaybackState.Playing);
    this.currentlyPlaying = event;
    const playback = await this.tryGetOrLoadPlaybackForEvent(event);
    playback?.play();
  }
  async tryGetOrLoadPlaybackForEvent(event) {
    try {
      return await this.getOrLoadPlaybackForEvent(event);
    } catch (err) {
      _logger.logger.warn("Unable to load broadcast playback", {
        message: err.message,
        broadcastId: this.infoEvent.getId(),
        chunkId: event.getId()
      });
      this.setError();
    }
  }
  async getOrLoadPlaybackForEvent(event) {
    const eventId = event.getId();
    if (!eventId) {
      throw new Error("Broadcast chunk event without Id occurred");
    }
    if (!this.playbacks.has(eventId)) {
      // set to buffering while loading the chunk data
      const currentState = this.getState();
      this.setState(VoiceBroadcastPlaybackState.Buffering);
      await this.loadPlayback(event);
      this.setState(currentState);
    }
    const playback = this.playbacks.get(eventId);
    if (!playback) {
      throw new Error(`Unable to find playback for event ${event.getId()}`);
    }

    // try to load the playback for the next event for a smooth(er) playback
    const nextEvent = this.chunkEvents.getNext(event);
    if (nextEvent) this.tryLoadPlayback(nextEvent);
    return playback;
  }
  getCurrentPlayback() {
    if (!this.currentlyPlaying) return;
    return this.playbacks.get(this.currentlyPlaying.getId());
  }
  getLiveness() {
    return this.liveness;
  }
  setLiveness(liveness) {
    if (this.liveness === liveness) return;
    this.liveness = liveness;
    this.emit(VoiceBroadcastPlaybackEvent.LivenessChanged, liveness);
  }
  get currentState() {
    return _Playback.PlaybackState.Playing;
  }
  get timeSeconds() {
    return this.position / 1000;
  }
  get durationSeconds() {
    return this.duration / 1000;
  }
  get timeLeftSeconds() {
    // Sometimes the meta data and the audio files are a little bit out of sync.
    // Be sure it never returns a negative value.
    return Math.max(0, Math.round(this.durationSeconds) - this.timeSeconds);
  }
  async skipTo(timeSeconds) {
    this.skipToNext = timeSeconds;
    if (this.skipToDeferred) {
      // Skip to position is already in progress. Return the promise for that.
      return this.skipToDeferred.promise;
    }
    this.skipToDeferred = (0, _utils.defer)();
    while (this.skipToNext !== undefined) {
      // Skip to position until skipToNext is undefined.
      // skipToNext can be set if skipTo is called while already skipping.
      const skipToNext = this.skipToNext;
      this.skipToNext = undefined;
      await this.doSkipTo(skipToNext);
    }
    this.skipToDeferred.resolve();
    this.skipToDeferred = undefined;
  }
  async doSkipTo(timeSeconds) {
    const time = timeSeconds * 1000;
    const event = this.chunkEvents.findByTime(time);
    if (!event) {
      _logger.logger.warn("voice broadcast chunk event to skip to not found");
      return;
    }
    const currentPlayback = this.getCurrentPlayback();
    const skipToPlayback = await this.tryGetOrLoadPlaybackForEvent(event);
    const currentPlaybackEvent = this.currentlyPlaying;
    if (!skipToPlayback) {
      _logger.logger.warn("voice broadcast chunk to skip to not found", event);
      return;
    }
    this.currentlyPlaying = event;
    if (currentPlayback && currentPlaybackEvent && currentPlayback !== skipToPlayback) {
      // only stop and unload the playback here without triggering other effects, e.g. play next
      currentPlayback.off(_AsyncStore.UPDATE_EVENT, this.onPlaybackStateChange);
      await currentPlayback.stop();
      currentPlayback.on(_AsyncStore.UPDATE_EVENT, this.onPlaybackStateChange);
      this.unloadPlayback(currentPlaybackEvent);
    }
    const offsetInChunk = time - this.chunkEvents.getLengthTo(event);
    await skipToPlayback.skipTo(offsetInChunk / 1000);
    if (this.state === VoiceBroadcastPlaybackState.Playing && !skipToPlayback.isPlaying) {
      await skipToPlayback.play();
    }
    this.setPosition(time);
  }
  async start() {
    if (this.state === VoiceBroadcastPlaybackState.Playing) return;
    const currentRecording = this.recordings.getCurrent();
    if (currentRecording && currentRecording.getState() !== _.VoiceBroadcastInfoState.Stopped) {
      const shouldStopRecording = await (0, _.showConfirmListenBroadcastStopCurrentDialog)();
      if (!shouldStopRecording) {
        // keep recording
        return;
      }
      await this.recordings.getCurrent()?.stop();
    }
    const chunkEvents = this.chunkEvents.getEvents();
    const toPlay = this.getInfoState() === _.VoiceBroadcastInfoState.Stopped ? chunkEvents[0] // start at the beginning for an ended voice broadcast
    : chunkEvents[chunkEvents.length - 1]; // start at the current chunk for an ongoing voice broadcast

    if (toPlay) {
      return this.playEvent(toPlay);
    }
    this.setState(VoiceBroadcastPlaybackState.Buffering);
  }
  stop() {
    // error is a final state
    if (this.getState() === VoiceBroadcastPlaybackState.Error) return;
    this.setState(VoiceBroadcastPlaybackState.Stopped);
    this.getCurrentPlayback()?.stop();
    this.currentlyPlaying = null;
    this.setPosition(0);
  }
  pause() {
    // error is a final state
    if (this.getState() === VoiceBroadcastPlaybackState.Error) return;

    // stopped voice broadcasts cannot be paused
    if (this.getState() === VoiceBroadcastPlaybackState.Stopped) return;
    this.setState(VoiceBroadcastPlaybackState.Paused);
    this.getCurrentPlayback()?.pause();
  }
  resume() {
    // error is a final state
    if (this.getState() === VoiceBroadcastPlaybackState.Error) return;
    if (!this.currentlyPlaying) {
      // no playback to resume, start from the beginning
      this.start();
      return;
    }
    this.setState(VoiceBroadcastPlaybackState.Playing);
    this.getCurrentPlayback()?.play();
  }

  /**
   * Toggles the playback:
   * stopped → playing
   * playing → paused
   * paused → playing
   */
  async toggle() {
    // error is a final state
    if (this.getState() === VoiceBroadcastPlaybackState.Error) return;
    if (this.state === VoiceBroadcastPlaybackState.Stopped) {
      await this.start();
      return;
    }
    if (this.state === VoiceBroadcastPlaybackState.Paused) {
      this.resume();
      return;
    }
    this.pause();
  }
  getState() {
    return this.state;
  }
  setState(state) {
    if (this.state === state) {
      return;
    }
    this.state = state;
    this.emit(VoiceBroadcastPlaybackEvent.StateChanged, state, this);
  }

  /**
   * Set error state. Stop current playback, if any.
   */
  setError() {
    this.setState(VoiceBroadcastPlaybackState.Error);
    this.getCurrentPlayback()?.stop();
    this.currentlyPlaying = null;
    this.setPosition(0);
  }
  getInfoState() {
    return this.infoState;
  }
  setInfoState(state) {
    if (this.infoState === state) {
      return;
    }
    this.infoState = state;
    this.emit(VoiceBroadcastPlaybackEvent.InfoStateChanged, state);
    this.setLiveness((0, _determineVoiceBroadcastLiveness.determineVoiceBroadcastLiveness)(this.infoState));
  }
  get errorMessage() {
    if (this.getState() !== VoiceBroadcastPlaybackState.Error) return "";
    if (this.utdChunkEvents.size) return (0, _languageHandler._t)("voice_broadcast|failed_decrypt");
    return (0, _languageHandler._t)("voice_broadcast|failed_generic");
  }
  destroy() {
    for (const [, utdEvent] of this.utdChunkEvents) {
      utdEvent.off(_matrix.MatrixEventEvent.Decrypted, this.onChunkEventDecrypted);
    }
    this.utdChunkEvents.clear();
    this.chunkRelationHelper.destroy();
    this.infoRelationHelper.destroy();
    this.removeAllListeners();
    this.chunkEvents = new _VoiceBroadcastChunkEvents.VoiceBroadcastChunkEvents();
    this.playbacks.forEach(p => p.destroy());
    this.playbacks = new Map();
  }
}
exports.VoiceBroadcastPlayback = VoiceBroadcastPlayback;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_matrix","require","_matrixWidgetApi","_logger","_utils","_Playback","_PlaybackManager","_AsyncStore","_MediaEventHelper","_","_RelationsHelper","_VoiceBroadcastChunkEvents","_determineVoiceBroadcastLiveness","_languageHandler","VoiceBroadcastPlaybackState","exports","VoiceBroadcastPlaybackEvent","VoiceBroadcastPlayback","TypedEventEmitter","constructor","infoEvent","client","recordings","_defineProperty2","default","Stopped","VoiceBroadcastChunkEvents","Map","SimpleObservable","event","getId","getTxnId","isDecryptionFailure","onChunkEventDecryptionFailure","getContent","msgtype","MsgType","Audio","chunkEvents","addEvent","setDuration","getLength","getState","Buffering","startOrPlayNext","eventId","logger","warn","broadcast","utdChunkEvents","has","once","MatrixEventEvent","Decrypted","onChunkEventDecrypted","set","setError","delete","addChunkEvent","size","setState","Paused","currentlyPlaying","playNext","start","lastInfoEvent","getTs","state","Object","values","VoiceBroadcastInfoState","includes","setInfoState","stop","destroy","position","newPosition","getLengthTo","setPosition","newState","PlaybackState","unloadPlayback","addInfoEvent","on","BeforeRedaction","onBeforeRedaction","setUpRelationsHelper","infoRelationHelper","RelationsHelper","RelationType","Reference","VoiceBroadcastInfoEventType","getCurrent","forEach","infoState","RelationsHelperEvent","Add","emitFetchCurrent","err","emitCurrent","chunkRelationHelper","EventType","RoomMessage","tryLoadPlayback","chunkEvent","loadPlayback","message","broadcastId","chunkId","Error","helper","MediaEventHelper","blob","sourceBlob","value","buffer","arrayBuffer","playback","PlaybackManager","instance","createPlaybackInstance","prepare","clockInfo","populatePlaceholdersFrom","playbacks","UPDATE_EVENT","onPlaybackStateChange","liveData","onUpdate","onPlaybackPositionUpdate","get","duration","emitTimesChanged","update","timeSeconds","durationSeconds","emit","TimesChanged","timeLeft","timeLeftSeconds","next","getNext","playEvent","getInfoState","getSequenceForEvent","lastChunkSequence","last_chunk_sequence","getNumberOfEvents","Playing","tryGetOrLoadPlaybackForEvent","play","getOrLoadPlaybackForEvent","currentState","nextEvent","getCurrentPlayback","getLiveness","liveness","setLiveness","LivenessChanged","Math","max","round","skipTo","skipToNext","skipToDeferred","promise","defer","undefined","doSkipTo","resolve","time","findByTime","currentPlayback","skipToPlayback","currentPlaybackEvent","off","offsetInChunk","isPlaying","currentRecording","shouldStopRecording","showConfirmListenBroadcastStopCurrentDialog","getEvents","toPlay","length","pause","resume","toggle","StateChanged","InfoStateChanged","determineVoiceBroadcastLiveness","errorMessage","_t","utdEvent","clear","removeAllListeners","p"],"sources":["../../../src/voice-broadcast/models/VoiceBroadcastPlayback.ts"],"sourcesContent":["/*\nCopyright 2024 New Vector Ltd.\nCopyright 2022 The Matrix.org Foundation C.I.C.\n\nSPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport {\n    EventType,\n    MatrixClient,\n    MatrixEvent,\n    MatrixEventEvent,\n    MsgType,\n    RelationType,\n    TypedEventEmitter,\n} from \"matrix-js-sdk/src/matrix\";\nimport { SimpleObservable } from \"matrix-widget-api\";\nimport { logger } from \"matrix-js-sdk/src/logger\";\nimport { defer, IDeferred } from \"matrix-js-sdk/src/utils\";\n\nimport { Playback, PlaybackInterface, PlaybackState } from \"../../audio/Playback\";\nimport { PlaybackManager } from \"../../audio/PlaybackManager\";\nimport { UPDATE_EVENT } from \"../../stores/AsyncStore\";\nimport { MediaEventHelper } from \"../../utils/MediaEventHelper\";\nimport { IDestroyable } from \"../../utils/IDestroyable\";\nimport {\n    VoiceBroadcastLiveness,\n    VoiceBroadcastInfoEventType,\n    VoiceBroadcastInfoState,\n    VoiceBroadcastInfoEventContent,\n    VoiceBroadcastRecordingsStore,\n    showConfirmListenBroadcastStopCurrentDialog,\n} from \"..\";\nimport { RelationsHelper, RelationsHelperEvent } from \"../../events/RelationsHelper\";\nimport { VoiceBroadcastChunkEvents } from \"../utils/VoiceBroadcastChunkEvents\";\nimport { determineVoiceBroadcastLiveness } from \"../utils/determineVoiceBroadcastLiveness\";\nimport { _t } from \"../../languageHandler\";\n\nexport enum VoiceBroadcastPlaybackState {\n    Paused = \"pause\",\n    Playing = \"playing\",\n    Stopped = \"stopped\",\n    Buffering = \"buffering\",\n    Error = \"error\",\n}\n\nexport enum VoiceBroadcastPlaybackEvent {\n    TimesChanged = \"times_changed\",\n    LivenessChanged = \"liveness_changed\",\n    StateChanged = \"state_changed\",\n    InfoStateChanged = \"info_state_changed\",\n}\n\nexport type VoiceBroadcastPlaybackTimes = {\n    duration: number;\n    position: number;\n    timeLeft: number;\n};\n\ninterface EventMap {\n    [VoiceBroadcastPlaybackEvent.TimesChanged]: (times: VoiceBroadcastPlaybackTimes) => void;\n    [VoiceBroadcastPlaybackEvent.LivenessChanged]: (liveness: VoiceBroadcastLiveness) => void;\n    [VoiceBroadcastPlaybackEvent.StateChanged]: (\n        state: VoiceBroadcastPlaybackState,\n        playback: VoiceBroadcastPlayback,\n    ) => void;\n    [VoiceBroadcastPlaybackEvent.InfoStateChanged]: (state: VoiceBroadcastInfoState) => void;\n}\n\nexport class VoiceBroadcastPlayback\n    extends TypedEventEmitter<VoiceBroadcastPlaybackEvent, EventMap>\n    implements IDestroyable, PlaybackInterface\n{\n    private state = VoiceBroadcastPlaybackState.Stopped;\n    private chunkEvents = new VoiceBroadcastChunkEvents();\n    /** @var Map: event Id → undecryptable event */\n    private utdChunkEvents: Map<string, MatrixEvent> = new Map();\n    private playbacks = new Map<string, Playback>();\n    private currentlyPlaying: MatrixEvent | null = null;\n    /** @var total duration of all chunks in milliseconds */\n    private duration = 0;\n    /** @var current playback position in milliseconds */\n    private position = 0;\n    public readonly liveData = new SimpleObservable<number[]>();\n    private liveness: VoiceBroadcastLiveness = \"not-live\";\n\n    // set via addInfoEvent() in constructor\n    private infoState!: VoiceBroadcastInfoState;\n    private lastInfoEvent!: MatrixEvent;\n\n    // set via setUpRelationsHelper() in constructor\n    private chunkRelationHelper!: RelationsHelper;\n    private infoRelationHelper!: RelationsHelper;\n\n    private skipToNext?: number;\n    private skipToDeferred?: IDeferred<void>;\n\n    public constructor(\n        public readonly infoEvent: MatrixEvent,\n        private client: MatrixClient,\n        private recordings: VoiceBroadcastRecordingsStore,\n    ) {\n        super();\n        this.addInfoEvent(this.infoEvent);\n        this.infoEvent.on(MatrixEventEvent.BeforeRedaction, this.onBeforeRedaction);\n        this.setUpRelationsHelper();\n    }\n\n    private async setUpRelationsHelper(): Promise<void> {\n        this.infoRelationHelper = new RelationsHelper(\n            this.infoEvent,\n            RelationType.Reference,\n            VoiceBroadcastInfoEventType,\n            this.client,\n        );\n        this.infoRelationHelper.getCurrent().forEach(this.addInfoEvent);\n\n        if (this.infoState !== VoiceBroadcastInfoState.Stopped) {\n            // Only required if not stopped. Stopped is the final state.\n            this.infoRelationHelper.on(RelationsHelperEvent.Add, this.addInfoEvent);\n\n            try {\n                await this.infoRelationHelper.emitFetchCurrent();\n            } catch (err) {\n                logger.warn(\"error fetching server side relation for voice broadcast info\", err);\n                // fall back to local events\n                this.infoRelationHelper.emitCurrent();\n            }\n        }\n\n        this.chunkRelationHelper = new RelationsHelper(\n            this.infoEvent,\n            RelationType.Reference,\n            EventType.RoomMessage,\n            this.client,\n        );\n        this.chunkRelationHelper.on(RelationsHelperEvent.Add, this.addChunkEvent);\n\n        try {\n            // TODO Michael W: only fetch events if needed, blocked by PSF-1708\n            await this.chunkRelationHelper.emitFetchCurrent();\n        } catch (err) {\n            logger.warn(\"error fetching server side relation for voice broadcast chunks\", err);\n            // fall back to local events\n            this.chunkRelationHelper.emitCurrent();\n        }\n    }\n\n    private addChunkEvent = async (event: MatrixEvent): Promise<boolean> => {\n        if (!event.getId() && !event.getTxnId()) {\n            // skip events without id and txn id\n            return false;\n        }\n\n        if (event.isDecryptionFailure()) {\n            this.onChunkEventDecryptionFailure(event);\n            return false;\n        }\n\n        if (event.getContent()?.msgtype !== MsgType.Audio) {\n            // skip non-audio event\n            return false;\n        }\n\n        this.chunkEvents.addEvent(event);\n        this.setDuration(this.chunkEvents.getLength());\n\n        if (this.getState() === VoiceBroadcastPlaybackState.Buffering) {\n            await this.startOrPlayNext();\n        }\n\n        return true;\n    };\n\n    private onChunkEventDecryptionFailure = (event: MatrixEvent): void => {\n        const eventId = event.getId();\n\n        if (!eventId) {\n            // This should not happen, as the existence of the Id is checked before the call.\n            // Log anyway and return.\n            logger.warn(\"Broadcast chunk decryption failure for event without Id\", {\n                broadcast: this.infoEvent.getId(),\n            });\n            return;\n        }\n\n        if (!this.utdChunkEvents.has(eventId)) {\n            event.once(MatrixEventEvent.Decrypted, this.onChunkEventDecrypted);\n        }\n\n        this.utdChunkEvents.set(eventId, event);\n        this.setError();\n    };\n\n    private onChunkEventDecrypted = async (event: MatrixEvent): Promise<void> => {\n        const eventId = event.getId();\n\n        if (!eventId) {\n            // This should not happen, as the existence of the Id is checked before the call.\n            // Log anyway and return.\n            logger.warn(\"Broadcast chunk decrypted for event without Id\", { broadcast: this.infoEvent.getId() });\n            return;\n        }\n\n        this.utdChunkEvents.delete(eventId);\n        await this.addChunkEvent(event);\n\n        if (this.utdChunkEvents.size === 0) {\n            // no more UTD events, recover from error to paused\n            this.setState(VoiceBroadcastPlaybackState.Paused);\n        }\n    };\n\n    private startOrPlayNext = async (): Promise<void> => {\n        if (this.currentlyPlaying) {\n            return this.playNext();\n        }\n\n        return await this.start();\n    };\n\n    private addInfoEvent = (event: MatrixEvent): void => {\n        if (this.lastInfoEvent && this.lastInfoEvent.getTs() >= event.getTs()) {\n            // Only handle newer events\n            return;\n        }\n\n        const state = event.getContent()?.state;\n\n        if (!Object.values(VoiceBroadcastInfoState).includes(state)) {\n            // Do not handle unknown voice broadcast states\n            return;\n        }\n\n        this.lastInfoEvent = event;\n        this.setInfoState(state);\n    };\n\n    private onBeforeRedaction = (): void => {\n        if (this.getState() !== VoiceBroadcastPlaybackState.Stopped) {\n            this.stop();\n            // destroy cleans up everything\n            this.destroy();\n        }\n    };\n\n    private async tryLoadPlayback(chunkEvent: MatrixEvent): Promise<void> {\n        try {\n            return await this.loadPlayback(chunkEvent);\n        } catch (err: any) {\n            logger.warn(\"Unable to load broadcast playback\", {\n                message: err.message,\n                broadcastId: this.infoEvent.getId(),\n                chunkId: chunkEvent.getId(),\n            });\n            this.setError();\n        }\n    }\n\n    private async loadPlayback(chunkEvent: MatrixEvent): Promise<void> {\n        const eventId = chunkEvent.getId();\n\n        if (!eventId) {\n            throw new Error(\"Broadcast chunk event without Id occurred\");\n        }\n\n        const helper = new MediaEventHelper(chunkEvent);\n        const blob = await helper.sourceBlob.value;\n        const buffer = await blob.arrayBuffer();\n        const playback = PlaybackManager.instance.createPlaybackInstance(buffer);\n        await playback.prepare();\n        playback.clockInfo.populatePlaceholdersFrom(chunkEvent);\n        this.playbacks.set(eventId, playback);\n        playback.on(UPDATE_EVENT, (state) => this.onPlaybackStateChange(chunkEvent, state));\n        playback.clockInfo.liveData.onUpdate(([position]) => {\n            this.onPlaybackPositionUpdate(chunkEvent, position);\n        });\n    }\n\n    private unloadPlayback(event: MatrixEvent): void {\n        const playback = this.playbacks.get(event.getId()!);\n        if (!playback) return;\n\n        playback.destroy();\n        this.playbacks.delete(event.getId()!);\n    }\n\n    private onPlaybackPositionUpdate = (event: MatrixEvent, position: number): void => {\n        if (event !== this.currentlyPlaying) return;\n\n        const newPosition = this.chunkEvents.getLengthTo(event) + position * 1000; // observable sends seconds\n\n        // do not jump backwards - this can happen when transiting from one to another chunk\n        if (newPosition < this.position) return;\n\n        this.setPosition(newPosition);\n    };\n\n    private setDuration(duration: number): void {\n        if (this.duration === duration) return;\n\n        this.duration = duration;\n        this.emitTimesChanged();\n        this.liveData.update([this.timeSeconds, this.durationSeconds]);\n    }\n\n    private setPosition(position: number): void {\n        if (this.position === position) return;\n\n        this.position = position;\n        this.emitTimesChanged();\n        this.liveData.update([this.timeSeconds, this.durationSeconds]);\n    }\n\n    private emitTimesChanged(): void {\n        this.emit(VoiceBroadcastPlaybackEvent.TimesChanged, {\n            duration: this.durationSeconds,\n            position: this.timeSeconds,\n            timeLeft: this.timeLeftSeconds,\n        });\n    }\n\n    private onPlaybackStateChange = async (event: MatrixEvent, newState: PlaybackState): Promise<void> => {\n        if (event !== this.currentlyPlaying) return;\n        if (newState !== PlaybackState.Stopped) return;\n\n        await this.playNext();\n        this.unloadPlayback(event);\n    };\n\n    private async playNext(): Promise<void> {\n        if (!this.currentlyPlaying) return;\n\n        const next = this.chunkEvents.getNext(this.currentlyPlaying);\n\n        if (next) {\n            return this.playEvent(next);\n        }\n\n        if (\n            this.getInfoState() === VoiceBroadcastInfoState.Stopped &&\n            this.chunkEvents.getSequenceForEvent(this.currentlyPlaying) === this.lastChunkSequence\n        ) {\n            this.stop();\n        } else {\n            // No more chunks available, although the broadcast is not finished → enter buffering state.\n            this.setState(VoiceBroadcastPlaybackState.Buffering);\n        }\n    }\n\n    /**\n     * @returns {number} The last chunk sequence from the latest info event.\n     *                   Falls back to the length of received chunks if the info event does not provide the number.\n     */\n    private get lastChunkSequence(): number {\n        return (\n            this.lastInfoEvent.getContent<VoiceBroadcastInfoEventContent>()?.last_chunk_sequence ||\n            this.chunkEvents.getNumberOfEvents()\n        );\n    }\n\n    private async playEvent(event: MatrixEvent): Promise<void> {\n        this.setState(VoiceBroadcastPlaybackState.Playing);\n        this.currentlyPlaying = event;\n        const playback = await this.tryGetOrLoadPlaybackForEvent(event);\n        playback?.play();\n    }\n\n    private async tryGetOrLoadPlaybackForEvent(event: MatrixEvent): Promise<Playback | undefined> {\n        try {\n            return await this.getOrLoadPlaybackForEvent(event);\n        } catch (err: any) {\n            logger.warn(\"Unable to load broadcast playback\", {\n                message: err.message,\n                broadcastId: this.infoEvent.getId(),\n                chunkId: event.getId(),\n            });\n            this.setError();\n        }\n    }\n\n    private async getOrLoadPlaybackForEvent(event: MatrixEvent): Promise<Playback | undefined> {\n        const eventId = event.getId();\n\n        if (!eventId) {\n            throw new Error(\"Broadcast chunk event without Id occurred\");\n        }\n\n        if (!this.playbacks.has(eventId)) {\n            // set to buffering while loading the chunk data\n            const currentState = this.getState();\n            this.setState(VoiceBroadcastPlaybackState.Buffering);\n            await this.loadPlayback(event);\n            this.setState(currentState);\n        }\n\n        const playback = this.playbacks.get(eventId);\n\n        if (!playback) {\n            throw new Error(`Unable to find playback for event ${event.getId()}`);\n        }\n\n        // try to load the playback for the next event for a smooth(er) playback\n        const nextEvent = this.chunkEvents.getNext(event);\n        if (nextEvent) this.tryLoadPlayback(nextEvent);\n\n        return playback;\n    }\n\n    private getCurrentPlayback(): Playback | undefined {\n        if (!this.currentlyPlaying) return;\n        return this.playbacks.get(this.currentlyPlaying.getId()!);\n    }\n\n    public getLiveness(): VoiceBroadcastLiveness {\n        return this.liveness;\n    }\n\n    private setLiveness(liveness: VoiceBroadcastLiveness): void {\n        if (this.liveness === liveness) return;\n\n        this.liveness = liveness;\n        this.emit(VoiceBroadcastPlaybackEvent.LivenessChanged, liveness);\n    }\n\n    public get currentState(): PlaybackState {\n        return PlaybackState.Playing;\n    }\n\n    public get timeSeconds(): number {\n        return this.position / 1000;\n    }\n\n    public get durationSeconds(): number {\n        return this.duration / 1000;\n    }\n\n    public get timeLeftSeconds(): number {\n        // Sometimes the meta data and the audio files are a little bit out of sync.\n        // Be sure it never returns a negative value.\n        return Math.max(0, Math.round(this.durationSeconds) - this.timeSeconds);\n    }\n\n    public async skipTo(timeSeconds: number): Promise<void> {\n        this.skipToNext = timeSeconds;\n\n        if (this.skipToDeferred) {\n            // Skip to position is already in progress. Return the promise for that.\n            return this.skipToDeferred.promise;\n        }\n\n        this.skipToDeferred = defer();\n\n        while (this.skipToNext !== undefined) {\n            // Skip to position until skipToNext is undefined.\n            // skipToNext can be set if skipTo is called while already skipping.\n            const skipToNext = this.skipToNext;\n            this.skipToNext = undefined;\n            await this.doSkipTo(skipToNext);\n        }\n\n        this.skipToDeferred.resolve();\n        this.skipToDeferred = undefined;\n    }\n\n    private async doSkipTo(timeSeconds: number): Promise<void> {\n        const time = timeSeconds * 1000;\n        const event = this.chunkEvents.findByTime(time);\n\n        if (!event) {\n            logger.warn(\"voice broadcast chunk event to skip to not found\");\n            return;\n        }\n\n        const currentPlayback = this.getCurrentPlayback();\n        const skipToPlayback = await this.tryGetOrLoadPlaybackForEvent(event);\n        const currentPlaybackEvent = this.currentlyPlaying;\n\n        if (!skipToPlayback) {\n            logger.warn(\"voice broadcast chunk to skip to not found\", event);\n            return;\n        }\n\n        this.currentlyPlaying = event;\n\n        if (currentPlayback && currentPlaybackEvent && currentPlayback !== skipToPlayback) {\n            // only stop and unload the playback here without triggering other effects, e.g. play next\n            currentPlayback.off(UPDATE_EVENT, this.onPlaybackStateChange);\n            await currentPlayback.stop();\n            currentPlayback.on(UPDATE_EVENT, this.onPlaybackStateChange);\n            this.unloadPlayback(currentPlaybackEvent);\n        }\n\n        const offsetInChunk = time - this.chunkEvents.getLengthTo(event);\n        await skipToPlayback.skipTo(offsetInChunk / 1000);\n\n        if (this.state === VoiceBroadcastPlaybackState.Playing && !skipToPlayback.isPlaying) {\n            await skipToPlayback.play();\n        }\n\n        this.setPosition(time);\n    }\n\n    public async start(): Promise<void> {\n        if (this.state === VoiceBroadcastPlaybackState.Playing) return;\n\n        const currentRecording = this.recordings.getCurrent();\n\n        if (currentRecording && currentRecording.getState() !== VoiceBroadcastInfoState.Stopped) {\n            const shouldStopRecording = await showConfirmListenBroadcastStopCurrentDialog();\n\n            if (!shouldStopRecording) {\n                // keep recording\n                return;\n            }\n\n            await this.recordings.getCurrent()?.stop();\n        }\n\n        const chunkEvents = this.chunkEvents.getEvents();\n\n        const toPlay =\n            this.getInfoState() === VoiceBroadcastInfoState.Stopped\n                ? chunkEvents[0] // start at the beginning for an ended voice broadcast\n                : chunkEvents[chunkEvents.length - 1]; // start at the current chunk for an ongoing voice broadcast\n\n        if (toPlay) {\n            return this.playEvent(toPlay);\n        }\n\n        this.setState(VoiceBroadcastPlaybackState.Buffering);\n    }\n\n    public stop(): void {\n        // error is a final state\n        if (this.getState() === VoiceBroadcastPlaybackState.Error) return;\n\n        this.setState(VoiceBroadcastPlaybackState.Stopped);\n        this.getCurrentPlayback()?.stop();\n        this.currentlyPlaying = null;\n        this.setPosition(0);\n    }\n\n    public pause(): void {\n        // error is a final state\n        if (this.getState() === VoiceBroadcastPlaybackState.Error) return;\n\n        // stopped voice broadcasts cannot be paused\n        if (this.getState() === VoiceBroadcastPlaybackState.Stopped) return;\n\n        this.setState(VoiceBroadcastPlaybackState.Paused);\n        this.getCurrentPlayback()?.pause();\n    }\n\n    public resume(): void {\n        // error is a final state\n        if (this.getState() === VoiceBroadcastPlaybackState.Error) return;\n\n        if (!this.currentlyPlaying) {\n            // no playback to resume, start from the beginning\n            this.start();\n            return;\n        }\n\n        this.setState(VoiceBroadcastPlaybackState.Playing);\n        this.getCurrentPlayback()?.play();\n    }\n\n    /**\n     * Toggles the playback:\n     * stopped → playing\n     * playing → paused\n     * paused → playing\n     */\n    public async toggle(): Promise<void> {\n        // error is a final state\n        if (this.getState() === VoiceBroadcastPlaybackState.Error) return;\n\n        if (this.state === VoiceBroadcastPlaybackState.Stopped) {\n            await this.start();\n            return;\n        }\n\n        if (this.state === VoiceBroadcastPlaybackState.Paused) {\n            this.resume();\n            return;\n        }\n\n        this.pause();\n    }\n\n    public getState(): VoiceBroadcastPlaybackState {\n        return this.state;\n    }\n\n    private setState(state: VoiceBroadcastPlaybackState): void {\n        if (this.state === state) {\n            return;\n        }\n\n        this.state = state;\n        this.emit(VoiceBroadcastPlaybackEvent.StateChanged, state, this);\n    }\n\n    /**\n     * Set error state. Stop current playback, if any.\n     */\n    private setError(): void {\n        this.setState(VoiceBroadcastPlaybackState.Error);\n        this.getCurrentPlayback()?.stop();\n        this.currentlyPlaying = null;\n        this.setPosition(0);\n    }\n\n    public getInfoState(): VoiceBroadcastInfoState {\n        return this.infoState;\n    }\n\n    private setInfoState(state: VoiceBroadcastInfoState): void {\n        if (this.infoState === state) {\n            return;\n        }\n\n        this.infoState = state;\n        this.emit(VoiceBroadcastPlaybackEvent.InfoStateChanged, state);\n        this.setLiveness(determineVoiceBroadcastLiveness(this.infoState));\n    }\n\n    public get errorMessage(): string {\n        if (this.getState() !== VoiceBroadcastPlaybackState.Error) return \"\";\n        if (this.utdChunkEvents.size) return _t(\"voice_broadcast|failed_decrypt\");\n        return _t(\"voice_broadcast|failed_generic\");\n    }\n\n    public destroy(): void {\n        for (const [, utdEvent] of this.utdChunkEvents) {\n            utdEvent.off(MatrixEventEvent.Decrypted, this.onChunkEventDecrypted);\n        }\n\n        this.utdChunkEvents.clear();\n\n        this.chunkRelationHelper.destroy();\n        this.infoRelationHelper.destroy();\n        this.removeAllListeners();\n\n        this.chunkEvents = new VoiceBroadcastChunkEvents();\n        this.playbacks.forEach((p) => p.destroy());\n        this.playbacks = new Map<string, Playback>();\n    }\n}\n"],"mappings":";;;;;;;;AAQA,IAAAA,OAAA,GAAAC,OAAA;AASA,IAAAC,gBAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AACA,IAAAG,MAAA,GAAAH,OAAA;AAEA,IAAAI,SAAA,GAAAJ,OAAA;AACA,IAAAK,gBAAA,GAAAL,OAAA;AACA,IAAAM,WAAA,GAAAN,OAAA;AACA,IAAAO,iBAAA,GAAAP,OAAA;AAEA,IAAAQ,CAAA,GAAAR,OAAA;AAQA,IAAAS,gBAAA,GAAAT,OAAA;AACA,IAAAU,0BAAA,GAAAV,OAAA;AACA,IAAAW,gCAAA,GAAAX,OAAA;AACA,IAAAY,gBAAA,GAAAZ,OAAA;AArCA;AACA;AACA;AACA;AACA;AACA;AACA;AANA,IAuCYa,2BAA2B,GAAAC,OAAA,CAAAD,2BAAA,0BAA3BA,2BAA2B;EAA3BA,2BAA2B;EAA3BA,2BAA2B;EAA3BA,2BAA2B;EAA3BA,2BAA2B;EAA3BA,2BAA2B;EAAA,OAA3BA,2BAA2B;AAAA;AAAA,IAQ3BE,2BAA2B,GAAAD,OAAA,CAAAC,2BAAA,0BAA3BA,2BAA2B;EAA3BA,2BAA2B;EAA3BA,2BAA2B;EAA3BA,2BAA2B;EAA3BA,2BAA2B;EAAA,OAA3BA,2BAA2B;AAAA;AAuBhC,MAAMC,sBAAsB,SACvBC,yBAAiB,CAE7B;EAyBWC,WAAWA,CACEC,SAAsB,EAC9BC,MAAoB,EACpBC,UAAyC,EACnD;IACE,KAAK,CAAC,CAAC;IAAC,IAAAC,gBAAA,CAAAC,OAAA,iBA7BIV,2BAA2B,CAACW,OAAO;IAAA,IAAAF,gBAAA,CAAAC,OAAA,uBAC7B,IAAIE,oDAAyB,CAAC,CAAC;IACrD;IAAA,IAAAH,gBAAA,CAAAC,OAAA,0BACmD,IAAIG,GAAG,CAAC,CAAC;IAAA,IAAAJ,gBAAA,CAAAC,OAAA,qBACxC,IAAIG,GAAG,CAAmB,CAAC;IAAA,IAAAJ,gBAAA,CAAAC,OAAA,4BACA,IAAI;IACnD;IAAA,IAAAD,gBAAA,CAAAC,OAAA,oBACmB,CAAC;IACpB;IAAA,IAAAD,gBAAA,CAAAC,OAAA,oBACmB,CAAC;IAAA,IAAAD,gBAAA,CAAAC,OAAA,oBACO,IAAII,iCAAgB,CAAW,CAAC;IAAA,IAAAL,gBAAA,CAAAC,OAAA,oBAChB,UAAU;IAErD;IAAA,IAAAD,gBAAA,CAAAC,OAAA;IAAA,IAAAD,gBAAA,CAAAC,OAAA;IAIA;IAAA,IAAAD,gBAAA,CAAAC,OAAA;IAAA,IAAAD,gBAAA,CAAAC,OAAA;IAAA,IAAAD,gBAAA,CAAAC,OAAA;IAAA,IAAAD,gBAAA,CAAAC,OAAA;IAAA,IAAAD,gBAAA,CAAAC,OAAA,yBA0DwB,MAAOK,KAAkB,IAAuB;MACpE,IAAI,CAACA,KAAK,CAACC,KAAK,CAAC,CAAC,IAAI,CAACD,KAAK,CAACE,QAAQ,CAAC,CAAC,EAAE;QACrC;QACA,OAAO,KAAK;MAChB;MAEA,IAAIF,KAAK,CAACG,mBAAmB,CAAC,CAAC,EAAE;QAC7B,IAAI,CAACC,6BAA6B,CAACJ,KAAK,CAAC;QACzC,OAAO,KAAK;MAChB;MAEA,IAAIA,KAAK,CAACK,UAAU,CAAC,CAAC,EAAEC,OAAO,KAAKC,eAAO,CAACC,KAAK,EAAE;QAC/C;QACA,OAAO,KAAK;MAChB;MAEA,IAAI,CAACC,WAAW,CAACC,QAAQ,CAACV,KAAK,CAAC;MAChC,IAAI,CAACW,WAAW,CAAC,IAAI,CAACF,WAAW,CAACG,SAAS,CAAC,CAAC,CAAC;MAE9C,IAAI,IAAI,CAACC,QAAQ,CAAC,CAAC,KAAK5B,2BAA2B,CAAC6B,SAAS,EAAE;QAC3D,MAAM,IAAI,CAACC,eAAe,CAAC,CAAC;MAChC;MAEA,OAAO,IAAI;IACf,CAAC;IAAA,IAAArB,gBAAA,CAAAC,OAAA,yCAEwCK,KAAkB,IAAW;MAClE,MAAMgB,OAAO,GAAGhB,KAAK,CAACC,KAAK,CAAC,CAAC;MAE7B,IAAI,CAACe,OAAO,EAAE;QACV;QACA;QACAC,cAAM,CAACC,IAAI,CAAC,yDAAyD,EAAE;UACnEC,SAAS,EAAE,IAAI,CAAC5B,SAAS,CAACU,KAAK,CAAC;QACpC,CAAC,CAAC;QACF;MACJ;MAEA,IAAI,CAAC,IAAI,CAACmB,cAAc,CAACC,GAAG,CAACL,OAAO,CAAC,EAAE;QACnChB,KAAK,CAACsB,IAAI,CAACC,wBAAgB,CAACC,SAAS,EAAE,IAAI,CAACC,qBAAqB,CAAC;MACtE;MAEA,IAAI,CAACL,cAAc,CAACM,GAAG,CAACV,OAAO,EAAEhB,KAAK,CAAC;MACvC,IAAI,CAAC2B,QAAQ,CAAC,CAAC;IACnB,CAAC;IAAA,IAAAjC,gBAAA,CAAAC,OAAA,iCAE+B,MAAOK,KAAkB,IAAoB;MACzE,MAAMgB,OAAO,GAAGhB,KAAK,CAACC,KAAK,CAAC,CAAC;MAE7B,IAAI,CAACe,OAAO,EAAE;QACV;QACA;QACAC,cAAM,CAACC,IAAI,CAAC,gDAAgD,EAAE;UAAEC,SAAS,EAAE,IAAI,CAAC5B,SAAS,CAACU,KAAK,CAAC;QAAE,CAAC,CAAC;QACpG;MACJ;MAEA,IAAI,CAACmB,cAAc,CAACQ,MAAM,CAACZ,OAAO,CAAC;MACnC,MAAM,IAAI,CAACa,aAAa,CAAC7B,KAAK,CAAC;MAE/B,IAAI,IAAI,CAACoB,cAAc,CAACU,IAAI,KAAK,CAAC,EAAE;QAChC;QACA,IAAI,CAACC,QAAQ,CAAC9C,2BAA2B,CAAC+C,MAAM,CAAC;MACrD;IACJ,CAAC;IAAA,IAAAtC,gBAAA,CAAAC,OAAA,2BAEyB,YAA2B;MACjD,IAAI,IAAI,CAACsC,gBAAgB,EAAE;QACvB,OAAO,IAAI,CAACC,QAAQ,CAAC,CAAC;MAC1B;MAEA,OAAO,MAAM,IAAI,CAACC,KAAK,CAAC,CAAC;IAC7B,CAAC;IAAA,IAAAzC,gBAAA,CAAAC,OAAA,wBAEuBK,KAAkB,IAAW;MACjD,IAAI,IAAI,CAACoC,aAAa,IAAI,IAAI,CAACA,aAAa,CAACC,KAAK,CAAC,CAAC,IAAIrC,KAAK,CAACqC,KAAK,CAAC,CAAC,EAAE;QACnE;QACA;MACJ;MAEA,MAAMC,KAAK,GAAGtC,KAAK,CAACK,UAAU,CAAC,CAAC,EAAEiC,KAAK;MAEvC,IAAI,CAACC,MAAM,CAACC,MAAM,CAACC,yBAAuB,CAAC,CAACC,QAAQ,CAACJ,KAAK,CAAC,EAAE;QACzD;QACA;MACJ;MAEA,IAAI,CAACF,aAAa,GAAGpC,KAAK;MAC1B,IAAI,CAAC2C,YAAY,CAACL,KAAK,CAAC;IAC5B,CAAC;IAAA,IAAA5C,gBAAA,CAAAC,OAAA,6BAE2B,MAAY;MACpC,IAAI,IAAI,CAACkB,QAAQ,CAAC,CAAC,KAAK5B,2BAA2B,CAACW,OAAO,EAAE;QACzD,IAAI,CAACgD,IAAI,CAAC,CAAC;QACX;QACA,IAAI,CAACC,OAAO,CAAC,CAAC;MAClB;IACJ,CAAC;IAAA,IAAAnD,gBAAA,CAAAC,OAAA,oCA2CkC,CAACK,KAAkB,EAAE8C,QAAgB,KAAW;MAC/E,IAAI9C,KAAK,KAAK,IAAI,CAACiC,gBAAgB,EAAE;MAErC,MAAMc,WAAW,GAAG,IAAI,CAACtC,WAAW,CAACuC,WAAW,CAAChD,KAAK,CAAC,GAAG8C,QAAQ,GAAG,IAAI,CAAC,CAAC;;MAE3E;MACA,IAAIC,WAAW,GAAG,IAAI,CAACD,QAAQ,EAAE;MAEjC,IAAI,CAACG,WAAW,CAACF,WAAW,CAAC;IACjC,CAAC;IAAA,IAAArD,gBAAA,CAAAC,OAAA,iCA0B+B,OAAOK,KAAkB,EAAEkD,QAAuB,KAAoB;MAClG,IAAIlD,KAAK,KAAK,IAAI,CAACiC,gBAAgB,EAAE;MACrC,IAAIiB,QAAQ,KAAKC,uBAAa,CAACvD,OAAO,EAAE;MAExC,MAAM,IAAI,CAACsC,QAAQ,CAAC,CAAC;MACrB,IAAI,CAACkB,cAAc,CAACpD,KAAK,CAAC;IAC9B,CAAC;IAAA,KAtOmBT,SAAsB,GAAtBA,SAAsB;IAAA,KAC9BC,MAAoB,GAApBA,MAAoB;IAAA,KACpBC,UAAyC,GAAzCA,UAAyC;IAGjD,IAAI,CAAC4D,YAAY,CAAC,IAAI,CAAC9D,SAAS,CAAC;IACjC,IAAI,CAACA,SAAS,CAAC+D,EAAE,CAAC/B,wBAAgB,CAACgC,eAAe,EAAE,IAAI,CAACC,iBAAiB,CAAC;IAC3E,IAAI,CAACC,oBAAoB,CAAC,CAAC;EAC/B;EAEA,MAAcA,oBAAoBA,CAAA,EAAkB;IAChD,IAAI,CAACC,kBAAkB,GAAG,IAAIC,gCAAe,CACzC,IAAI,CAACpE,SAAS,EACdqE,oBAAY,CAACC,SAAS,EACtBC,6BAA2B,EAC3B,IAAI,CAACtE,MACT,CAAC;IACD,IAAI,CAACkE,kBAAkB,CAACK,UAAU,CAAC,CAAC,CAACC,OAAO,CAAC,IAAI,CAACX,YAAY,CAAC;IAE/D,IAAI,IAAI,CAACY,SAAS,KAAKxB,yBAAuB,CAAC7C,OAAO,EAAE;MACpD;MACA,IAAI,CAAC8D,kBAAkB,CAACJ,EAAE,CAACY,qCAAoB,CAACC,GAAG,EAAE,IAAI,CAACd,YAAY,CAAC;MAEvE,IAAI;QACA,MAAM,IAAI,CAACK,kBAAkB,CAACU,gBAAgB,CAAC,CAAC;MACpD,CAAC,CAAC,OAAOC,GAAG,EAAE;QACVpD,cAAM,CAACC,IAAI,CAAC,8DAA8D,EAAEmD,GAAG,CAAC;QAChF;QACA,IAAI,CAACX,kBAAkB,CAACY,WAAW,CAAC,CAAC;MACzC;IACJ;IAEA,IAAI,CAACC,mBAAmB,GAAG,IAAIZ,gCAAe,CAC1C,IAAI,CAACpE,SAAS,EACdqE,oBAAY,CAACC,SAAS,EACtBW,iBAAS,CAACC,WAAW,EACrB,IAAI,CAACjF,MACT,CAAC;IACD,IAAI,CAAC+E,mBAAmB,CAACjB,EAAE,CAACY,qCAAoB,CAACC,GAAG,EAAE,IAAI,CAACtC,aAAa,CAAC;IAEzE,IAAI;MACA;MACA,MAAM,IAAI,CAAC0C,mBAAmB,CAACH,gBAAgB,CAAC,CAAC;IACrD,CAAC,CAAC,OAAOC,GAAG,EAAE;MACVpD,cAAM,CAACC,IAAI,CAAC,gEAAgE,EAAEmD,GAAG,CAAC;MAClF;MACA,IAAI,CAACE,mBAAmB,CAACD,WAAW,CAAC,CAAC;IAC1C;EACJ;EAoGA,MAAcI,eAAeA,CAACC,UAAuB,EAAiB;IAClE,IAAI;MACA,OAAO,MAAM,IAAI,CAACC,YAAY,CAACD,UAAU,CAAC;IAC9C,CAAC,CAAC,OAAON,GAAQ,EAAE;MACfpD,cAAM,CAACC,IAAI,CAAC,mCAAmC,EAAE;QAC7C2D,OAAO,EAAER,GAAG,CAACQ,OAAO;QACpBC,WAAW,EAAE,IAAI,CAACvF,SAAS,CAACU,KAAK,CAAC,CAAC;QACnC8E,OAAO,EAAEJ,UAAU,CAAC1E,KAAK,CAAC;MAC9B,CAAC,CAAC;MACF,IAAI,CAAC0B,QAAQ,CAAC,CAAC;IACnB;EACJ;EAEA,MAAciD,YAAYA,CAACD,UAAuB,EAAiB;IAC/D,MAAM3D,OAAO,GAAG2D,UAAU,CAAC1E,KAAK,CAAC,CAAC;IAElC,IAAI,CAACe,OAAO,EAAE;MACV,MAAM,IAAIgE,KAAK,CAAC,2CAA2C,CAAC;IAChE;IAEA,MAAMC,MAAM,GAAG,IAAIC,kCAAgB,CAACP,UAAU,CAAC;IAC/C,MAAMQ,IAAI,GAAG,MAAMF,MAAM,CAACG,UAAU,CAACC,KAAK;IAC1C,MAAMC,MAAM,GAAG,MAAMH,IAAI,CAACI,WAAW,CAAC,CAAC;IACvC,MAAMC,QAAQ,GAAGC,gCAAe,CAACC,QAAQ,CAACC,sBAAsB,CAACL,MAAM,CAAC;IACxE,MAAME,QAAQ,CAACI,OAAO,CAAC,CAAC;IACxBJ,QAAQ,CAACK,SAAS,CAACC,wBAAwB,CAACnB,UAAU,CAAC;IACvD,IAAI,CAACoB,SAAS,CAACrE,GAAG,CAACV,OAAO,EAAEwE,QAAQ,CAAC;IACrCA,QAAQ,CAAClC,EAAE,CAAC0C,wBAAY,EAAG1D,KAAK,IAAK,IAAI,CAAC2D,qBAAqB,CAACtB,UAAU,EAAErC,KAAK,CAAC,CAAC;IACnFkD,QAAQ,CAACK,SAAS,CAACK,QAAQ,CAACC,QAAQ,CAAC,CAAC,CAACrD,QAAQ,CAAC,KAAK;MACjD,IAAI,CAACsD,wBAAwB,CAACzB,UAAU,EAAE7B,QAAQ,CAAC;IACvD,CAAC,CAAC;EACN;EAEQM,cAAcA,CAACpD,KAAkB,EAAQ;IAC7C,MAAMwF,QAAQ,GAAG,IAAI,CAACO,SAAS,CAACM,GAAG,CAACrG,KAAK,CAACC,KAAK,CAAC,CAAE,CAAC;IACnD,IAAI,CAACuF,QAAQ,EAAE;IAEfA,QAAQ,CAAC3C,OAAO,CAAC,CAAC;IAClB,IAAI,CAACkD,SAAS,CAACnE,MAAM,CAAC5B,KAAK,CAACC,KAAK,CAAC,CAAE,CAAC;EACzC;EAaQU,WAAWA,CAAC2F,QAAgB,EAAQ;IACxC,IAAI,IAAI,CAACA,QAAQ,KAAKA,QAAQ,EAAE;IAEhC,IAAI,CAACA,QAAQ,GAAGA,QAAQ;IACxB,IAAI,CAACC,gBAAgB,CAAC,CAAC;IACvB,IAAI,CAACL,QAAQ,CAACM,MAAM,CAAC,CAAC,IAAI,CAACC,WAAW,EAAE,IAAI,CAACC,eAAe,CAAC,CAAC;EAClE;EAEQzD,WAAWA,CAACH,QAAgB,EAAQ;IACxC,IAAI,IAAI,CAACA,QAAQ,KAAKA,QAAQ,EAAE;IAEhC,IAAI,CAACA,QAAQ,GAAGA,QAAQ;IACxB,IAAI,CAACyD,gBAAgB,CAAC,CAAC;IACvB,IAAI,CAACL,QAAQ,CAACM,MAAM,CAAC,CAAC,IAAI,CAACC,WAAW,EAAE,IAAI,CAACC,eAAe,CAAC,CAAC;EAClE;EAEQH,gBAAgBA,CAAA,EAAS;IAC7B,IAAI,CAACI,IAAI,CAACxH,2BAA2B,CAACyH,YAAY,EAAE;MAChDN,QAAQ,EAAE,IAAI,CAACI,eAAe;MAC9B5D,QAAQ,EAAE,IAAI,CAAC2D,WAAW;MAC1BI,QAAQ,EAAE,IAAI,CAACC;IACnB,CAAC,CAAC;EACN;EAUA,MAAc5E,QAAQA,CAAA,EAAkB;IACpC,IAAI,CAAC,IAAI,CAACD,gBAAgB,EAAE;IAE5B,MAAM8E,IAAI,GAAG,IAAI,CAACtG,WAAW,CAACuG,OAAO,CAAC,IAAI,CAAC/E,gBAAgB,CAAC;IAE5D,IAAI8E,IAAI,EAAE;MACN,OAAO,IAAI,CAACE,SAAS,CAACF,IAAI,CAAC;IAC/B;IAEA,IACI,IAAI,CAACG,YAAY,CAAC,CAAC,KAAKzE,yBAAuB,CAAC7C,OAAO,IACvD,IAAI,CAACa,WAAW,CAAC0G,mBAAmB,CAAC,IAAI,CAAClF,gBAAgB,CAAC,KAAK,IAAI,CAACmF,iBAAiB,EACxF;MACE,IAAI,CAACxE,IAAI,CAAC,CAAC;IACf,CAAC,MAAM;MACH;MACA,IAAI,CAACb,QAAQ,CAAC9C,2BAA2B,CAAC6B,SAAS,CAAC;IACxD;EACJ;;EAEA;AACJ;AACA;AACA;EACI,IAAYsG,iBAAiBA,CAAA,EAAW;IACpC,OACI,IAAI,CAAChF,aAAa,CAAC/B,UAAU,CAAiC,CAAC,EAAEgH,mBAAmB,IACpF,IAAI,CAAC5G,WAAW,CAAC6G,iBAAiB,CAAC,CAAC;EAE5C;EAEA,MAAcL,SAASA,CAACjH,KAAkB,EAAiB;IACvD,IAAI,CAAC+B,QAAQ,CAAC9C,2BAA2B,CAACsI,OAAO,CAAC;IAClD,IAAI,CAACtF,gBAAgB,GAAGjC,KAAK;IAC7B,MAAMwF,QAAQ,GAAG,MAAM,IAAI,CAACgC,4BAA4B,CAACxH,KAAK,CAAC;IAC/DwF,QAAQ,EAAEiC,IAAI,CAAC,CAAC;EACpB;EAEA,MAAcD,4BAA4BA,CAACxH,KAAkB,EAAiC;IAC1F,IAAI;MACA,OAAO,MAAM,IAAI,CAAC0H,yBAAyB,CAAC1H,KAAK,CAAC;IACtD,CAAC,CAAC,OAAOqE,GAAQ,EAAE;MACfpD,cAAM,CAACC,IAAI,CAAC,mCAAmC,EAAE;QAC7C2D,OAAO,EAAER,GAAG,CAACQ,OAAO;QACpBC,WAAW,EAAE,IAAI,CAACvF,SAAS,CAACU,KAAK,CAAC,CAAC;QACnC8E,OAAO,EAAE/E,KAAK,CAACC,KAAK,CAAC;MACzB,CAAC,CAAC;MACF,IAAI,CAAC0B,QAAQ,CAAC,CAAC;IACnB;EACJ;EAEA,MAAc+F,yBAAyBA,CAAC1H,KAAkB,EAAiC;IACvF,MAAMgB,OAAO,GAAGhB,KAAK,CAACC,KAAK,CAAC,CAAC;IAE7B,IAAI,CAACe,OAAO,EAAE;MACV,MAAM,IAAIgE,KAAK,CAAC,2CAA2C,CAAC;IAChE;IAEA,IAAI,CAAC,IAAI,CAACe,SAAS,CAAC1E,GAAG,CAACL,OAAO,CAAC,EAAE;MAC9B;MACA,MAAM2G,YAAY,GAAG,IAAI,CAAC9G,QAAQ,CAAC,CAAC;MACpC,IAAI,CAACkB,QAAQ,CAAC9C,2BAA2B,CAAC6B,SAAS,CAAC;MACpD,MAAM,IAAI,CAAC8D,YAAY,CAAC5E,KAAK,CAAC;MAC9B,IAAI,CAAC+B,QAAQ,CAAC4F,YAAY,CAAC;IAC/B;IAEA,MAAMnC,QAAQ,GAAG,IAAI,CAACO,SAAS,CAACM,GAAG,CAACrF,OAAO,CAAC;IAE5C,IAAI,CAACwE,QAAQ,EAAE;MACX,MAAM,IAAIR,KAAK,CAAC,qCAAqChF,KAAK,CAACC,KAAK,CAAC,CAAC,EAAE,CAAC;IACzE;;IAEA;IACA,MAAM2H,SAAS,GAAG,IAAI,CAACnH,WAAW,CAACuG,OAAO,CAAChH,KAAK,CAAC;IACjD,IAAI4H,SAAS,EAAE,IAAI,CAAClD,eAAe,CAACkD,SAAS,CAAC;IAE9C,OAAOpC,QAAQ;EACnB;EAEQqC,kBAAkBA,CAAA,EAAyB;IAC/C,IAAI,CAAC,IAAI,CAAC5F,gBAAgB,EAAE;IAC5B,OAAO,IAAI,CAAC8D,SAAS,CAACM,GAAG,CAAC,IAAI,CAACpE,gBAAgB,CAAChC,KAAK,CAAC,CAAE,CAAC;EAC7D;EAEO6H,WAAWA,CAAA,EAA2B;IACzC,OAAO,IAAI,CAACC,QAAQ;EACxB;EAEQC,WAAWA,CAACD,QAAgC,EAAQ;IACxD,IAAI,IAAI,CAACA,QAAQ,KAAKA,QAAQ,EAAE;IAEhC,IAAI,CAACA,QAAQ,GAAGA,QAAQ;IACxB,IAAI,CAACpB,IAAI,CAACxH,2BAA2B,CAAC8I,eAAe,EAAEF,QAAQ,CAAC;EACpE;EAEA,IAAWJ,YAAYA,CAAA,EAAkB;IACrC,OAAOxE,uBAAa,CAACoE,OAAO;EAChC;EAEA,IAAWd,WAAWA,CAAA,EAAW;IAC7B,OAAO,IAAI,CAAC3D,QAAQ,GAAG,IAAI;EAC/B;EAEA,IAAW4D,eAAeA,CAAA,EAAW;IACjC,OAAO,IAAI,CAACJ,QAAQ,GAAG,IAAI;EAC/B;EAEA,IAAWQ,eAAeA,CAAA,EAAW;IACjC;IACA;IACA,OAAOoB,IAAI,CAACC,GAAG,CAAC,CAAC,EAAED,IAAI,CAACE,KAAK,CAAC,IAAI,CAAC1B,eAAe,CAAC,GAAG,IAAI,CAACD,WAAW,CAAC;EAC3E;EAEA,MAAa4B,MAAMA,CAAC5B,WAAmB,EAAiB;IACpD,IAAI,CAAC6B,UAAU,GAAG7B,WAAW;IAE7B,IAAI,IAAI,CAAC8B,cAAc,EAAE;MACrB;MACA,OAAO,IAAI,CAACA,cAAc,CAACC,OAAO;IACtC;IAEA,IAAI,CAACD,cAAc,GAAG,IAAAE,YAAK,EAAC,CAAC;IAE7B,OAAO,IAAI,CAACH,UAAU,KAAKI,SAAS,EAAE;MAClC;MACA;MACA,MAAMJ,UAAU,GAAG,IAAI,CAACA,UAAU;MAClC,IAAI,CAACA,UAAU,GAAGI,SAAS;MAC3B,MAAM,IAAI,CAACC,QAAQ,CAACL,UAAU,CAAC;IACnC;IAEA,IAAI,CAACC,cAAc,CAACK,OAAO,CAAC,CAAC;IAC7B,IAAI,CAACL,cAAc,GAAGG,SAAS;EACnC;EAEA,MAAcC,QAAQA,CAAClC,WAAmB,EAAiB;IACvD,MAAMoC,IAAI,GAAGpC,WAAW,GAAG,IAAI;IAC/B,MAAMzG,KAAK,GAAG,IAAI,CAACS,WAAW,CAACqI,UAAU,CAACD,IAAI,CAAC;IAE/C,IAAI,CAAC7I,KAAK,EAAE;MACRiB,cAAM,CAACC,IAAI,CAAC,kDAAkD,CAAC;MAC/D;IACJ;IAEA,MAAM6H,eAAe,GAAG,IAAI,CAAClB,kBAAkB,CAAC,CAAC;IACjD,MAAMmB,cAAc,GAAG,MAAM,IAAI,CAACxB,4BAA4B,CAACxH,KAAK,CAAC;IACrE,MAAMiJ,oBAAoB,GAAG,IAAI,CAAChH,gBAAgB;IAElD,IAAI,CAAC+G,cAAc,EAAE;MACjB/H,cAAM,CAACC,IAAI,CAAC,4CAA4C,EAAElB,KAAK,CAAC;MAChE;IACJ;IAEA,IAAI,CAACiC,gBAAgB,GAAGjC,KAAK;IAE7B,IAAI+I,eAAe,IAAIE,oBAAoB,IAAIF,eAAe,KAAKC,cAAc,EAAE;MAC/E;MACAD,eAAe,CAACG,GAAG,CAAClD,wBAAY,EAAE,IAAI,CAACC,qBAAqB,CAAC;MAC7D,MAAM8C,eAAe,CAACnG,IAAI,CAAC,CAAC;MAC5BmG,eAAe,CAACzF,EAAE,CAAC0C,wBAAY,EAAE,IAAI,CAACC,qBAAqB,CAAC;MAC5D,IAAI,CAAC7C,cAAc,CAAC6F,oBAAoB,CAAC;IAC7C;IAEA,MAAME,aAAa,GAAGN,IAAI,GAAG,IAAI,CAACpI,WAAW,CAACuC,WAAW,CAAChD,KAAK,CAAC;IAChE,MAAMgJ,cAAc,CAACX,MAAM,CAACc,aAAa,GAAG,IAAI,CAAC;IAEjD,IAAI,IAAI,CAAC7G,KAAK,KAAKrD,2BAA2B,CAACsI,OAAO,IAAI,CAACyB,cAAc,CAACI,SAAS,EAAE;MACjF,MAAMJ,cAAc,CAACvB,IAAI,CAAC,CAAC;IAC/B;IAEA,IAAI,CAACxE,WAAW,CAAC4F,IAAI,CAAC;EAC1B;EAEA,MAAa1G,KAAKA,CAAA,EAAkB;IAChC,IAAI,IAAI,CAACG,KAAK,KAAKrD,2BAA2B,CAACsI,OAAO,EAAE;IAExD,MAAM8B,gBAAgB,GAAG,IAAI,CAAC5J,UAAU,CAACsE,UAAU,CAAC,CAAC;IAErD,IAAIsF,gBAAgB,IAAIA,gBAAgB,CAACxI,QAAQ,CAAC,CAAC,KAAK4B,yBAAuB,CAAC7C,OAAO,EAAE;MACrF,MAAM0J,mBAAmB,GAAG,MAAM,IAAAC,6CAA2C,EAAC,CAAC;MAE/E,IAAI,CAACD,mBAAmB,EAAE;QACtB;QACA;MACJ;MAEA,MAAM,IAAI,CAAC7J,UAAU,CAACsE,UAAU,CAAC,CAAC,EAAEnB,IAAI,CAAC,CAAC;IAC9C;IAEA,MAAMnC,WAAW,GAAG,IAAI,CAACA,WAAW,CAAC+I,SAAS,CAAC,CAAC;IAEhD,MAAMC,MAAM,GACR,IAAI,CAACvC,YAAY,CAAC,CAAC,KAAKzE,yBAAuB,CAAC7C,OAAO,GACjDa,WAAW,CAAC,CAAC,CAAC,CAAC;IAAA,EACfA,WAAW,CAACA,WAAW,CAACiJ,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;;IAE/C,IAAID,MAAM,EAAE;MACR,OAAO,IAAI,CAACxC,SAAS,CAACwC,MAAM,CAAC;IACjC;IAEA,IAAI,CAAC1H,QAAQ,CAAC9C,2BAA2B,CAAC6B,SAAS,CAAC;EACxD;EAEO8B,IAAIA,CAAA,EAAS;IAChB;IACA,IAAI,IAAI,CAAC/B,QAAQ,CAAC,CAAC,KAAK5B,2BAA2B,CAAC+F,KAAK,EAAE;IAE3D,IAAI,CAACjD,QAAQ,CAAC9C,2BAA2B,CAACW,OAAO,CAAC;IAClD,IAAI,CAACiI,kBAAkB,CAAC,CAAC,EAAEjF,IAAI,CAAC,CAAC;IACjC,IAAI,CAACX,gBAAgB,GAAG,IAAI;IAC5B,IAAI,CAACgB,WAAW,CAAC,CAAC,CAAC;EACvB;EAEO0G,KAAKA,CAAA,EAAS;IACjB;IACA,IAAI,IAAI,CAAC9I,QAAQ,CAAC,CAAC,KAAK5B,2BAA2B,CAAC+F,KAAK,EAAE;;IAE3D;IACA,IAAI,IAAI,CAACnE,QAAQ,CAAC,CAAC,KAAK5B,2BAA2B,CAACW,OAAO,EAAE;IAE7D,IAAI,CAACmC,QAAQ,CAAC9C,2BAA2B,CAAC+C,MAAM,CAAC;IACjD,IAAI,CAAC6F,kBAAkB,CAAC,CAAC,EAAE8B,KAAK,CAAC,CAAC;EACtC;EAEOC,MAAMA,CAAA,EAAS;IAClB;IACA,IAAI,IAAI,CAAC/I,QAAQ,CAAC,CAAC,KAAK5B,2BAA2B,CAAC+F,KAAK,EAAE;IAE3D,IAAI,CAAC,IAAI,CAAC/C,gBAAgB,EAAE;MACxB;MACA,IAAI,CAACE,KAAK,CAAC,CAAC;MACZ;IACJ;IAEA,IAAI,CAACJ,QAAQ,CAAC9C,2BAA2B,CAACsI,OAAO,CAAC;IAClD,IAAI,CAACM,kBAAkB,CAAC,CAAC,EAAEJ,IAAI,CAAC,CAAC;EACrC;;EAEA;AACJ;AACA;AACA;AACA;AACA;EACI,MAAaoC,MAAMA,CAAA,EAAkB;IACjC;IACA,IAAI,IAAI,CAAChJ,QAAQ,CAAC,CAAC,KAAK5B,2BAA2B,CAAC+F,KAAK,EAAE;IAE3D,IAAI,IAAI,CAAC1C,KAAK,KAAKrD,2BAA2B,CAACW,OAAO,EAAE;MACpD,MAAM,IAAI,CAACuC,KAAK,CAAC,CAAC;MAClB;IACJ;IAEA,IAAI,IAAI,CAACG,KAAK,KAAKrD,2BAA2B,CAAC+C,MAAM,EAAE;MACnD,IAAI,CAAC4H,MAAM,CAAC,CAAC;MACb;IACJ;IAEA,IAAI,CAACD,KAAK,CAAC,CAAC;EAChB;EAEO9I,QAAQA,CAAA,EAAgC;IAC3C,OAAO,IAAI,CAACyB,KAAK;EACrB;EAEQP,QAAQA,CAACO,KAAkC,EAAQ;IACvD,IAAI,IAAI,CAACA,KAAK,KAAKA,KAAK,EAAE;MACtB;IACJ;IAEA,IAAI,CAACA,KAAK,GAAGA,KAAK;IAClB,IAAI,CAACqE,IAAI,CAACxH,2BAA2B,CAAC2K,YAAY,EAAExH,KAAK,EAAE,IAAI,CAAC;EACpE;;EAEA;AACJ;AACA;EACYX,QAAQA,CAAA,EAAS;IACrB,IAAI,CAACI,QAAQ,CAAC9C,2BAA2B,CAAC+F,KAAK,CAAC;IAChD,IAAI,CAAC6C,kBAAkB,CAAC,CAAC,EAAEjF,IAAI,CAAC,CAAC;IACjC,IAAI,CAACX,gBAAgB,GAAG,IAAI;IAC5B,IAAI,CAACgB,WAAW,CAAC,CAAC,CAAC;EACvB;EAEOiE,YAAYA,CAAA,EAA4B;IAC3C,OAAO,IAAI,CAACjD,SAAS;EACzB;EAEQtB,YAAYA,CAACL,KAA8B,EAAQ;IACvD,IAAI,IAAI,CAAC2B,SAAS,KAAK3B,KAAK,EAAE;MAC1B;IACJ;IAEA,IAAI,CAAC2B,SAAS,GAAG3B,KAAK;IACtB,IAAI,CAACqE,IAAI,CAACxH,2BAA2B,CAAC4K,gBAAgB,EAAEzH,KAAK,CAAC;IAC9D,IAAI,CAAC0F,WAAW,CAAC,IAAAgC,gEAA+B,EAAC,IAAI,CAAC/F,SAAS,CAAC,CAAC;EACrE;EAEA,IAAWgG,YAAYA,CAAA,EAAW;IAC9B,IAAI,IAAI,CAACpJ,QAAQ,CAAC,CAAC,KAAK5B,2BAA2B,CAAC+F,KAAK,EAAE,OAAO,EAAE;IACpE,IAAI,IAAI,CAAC5D,cAAc,CAACU,IAAI,EAAE,OAAO,IAAAoI,mBAAE,EAAC,gCAAgC,CAAC;IACzE,OAAO,IAAAA,mBAAE,EAAC,gCAAgC,CAAC;EAC/C;EAEOrH,OAAOA,CAAA,EAAS;IACnB,KAAK,MAAM,GAAGsH,QAAQ,CAAC,IAAI,IAAI,CAAC/I,cAAc,EAAE;MAC5C+I,QAAQ,CAACjB,GAAG,CAAC3H,wBAAgB,CAACC,SAAS,EAAE,IAAI,CAACC,qBAAqB,CAAC;IACxE;IAEA,IAAI,CAACL,cAAc,CAACgJ,KAAK,CAAC,CAAC;IAE3B,IAAI,CAAC7F,mBAAmB,CAAC1B,OAAO,CAAC,CAAC;IAClC,IAAI,CAACa,kBAAkB,CAACb,OAAO,CAAC,CAAC;IACjC,IAAI,CAACwH,kBAAkB,CAAC,CAAC;IAEzB,IAAI,CAAC5J,WAAW,GAAG,IAAIZ,oDAAyB,CAAC,CAAC;IAClD,IAAI,CAACkG,SAAS,CAAC/B,OAAO,CAAEsG,CAAC,IAAKA,CAAC,CAACzH,OAAO,CAAC,CAAC,CAAC;IAC1C,IAAI,CAACkD,SAAS,GAAG,IAAIjG,GAAG,CAAmB,CAAC;EAChD;AACJ;AAACZ,OAAA,CAAAE,sBAAA,GAAAA,sBAAA","ignoreList":[]}