@gcorevideo/player 2.18.3 → 2.19.0

package/lib/plugins/thumbnails/Thumbnails.js

@@ -0,0 +1,414 @@
+import { UICorePlugin, Events, template, $ } from '@clappr/core';
+import { reportError, trace } from '@gcorevideo/utils';
+import parseSRT from 'parse-srt';
+import { CLAPPR_VERSION } from '../build.js';
+import pluginHtml from '../../../assets/thumbnails/scrub-thumbnails.ejs';
+import '../../../assets/thumbnails/style.scss';
+import { getPageX } from '../utils.js';
+const T = 'plugins.thumbnails';
+export class Thumbnails extends UICorePlugin {
+    _$spotlight = null;
+    _$backdrop = null;
+    $container = null;
+    $img = null;
+    _$carousel = null;
+    $textThumbnail = null;
+    _$backdropCarouselImgs = [];
+    spriteSheetHeight = 0;
+    _hoverPosition = 0;
+    _show = false;
+    _thumbsLoaded = false;
+    _oldContainer = null;
+    _thumbs = [];
+    get name() {
+        return 'thumbnails';
+    }
+    get supportedVersion() {
+        return { min: CLAPPR_VERSION };
+    }
+    get attributes() {
+        return {
+            'class': this.name
+        };
+    }
+    get template() {
+        return template(pluginHtml);
+    }
+    /*
+     * Helper to build the "thumbs" property for a sprite sheet.
+     *
+     * spriteSheetUrl- The url to the sprite sheet image
+     * numThumbs- The number of thumbnails on the sprite sheet
+     * thumbWidth- The width of each thumbnail.
+     * thumbHeight- The height of each thumbnail.
+     * numColumns- The number of columns in the sprite sheet.
+     * timeInterval- The interval (in seconds) between the thumbnails.
+     * startTime- The time (in seconds) that the first thumbnail represents. (defaults to 0)
+     */
+    // buildSpriteConfig(vtt, spriteSheetUrl, numThumbs, thumbWidth, thumbHeight, numColumns, timeInterval, startTime) {
+    buildSpriteConfig(vtt, spriteSheetUrl) {
+        const thumbs = [];
+        // let coor: string[] = [];
+        for (const vt of vtt) {
+            const el = vt.text;
+            // if (el && el.search(/\d*,\d*,\d*,\d*/g) > -1) {
+            //   el = el.match(/\d*,\d*,\d*,\d*/g)[0];
+            //   coor = el.split(',');
+            // }
+            if (el) {
+                const m = el.match(/xywh=\d*,\d*,\d*,\d*/g);
+                if (m) {
+                    const coor = m[0].split(',');
+                    const w = parseInt(coor[2], 10);
+                    const h = parseInt(coor[3], 10);
+                    if (w > 0 && h > 0) {
+                        thumbs.push({
+                            url: spriteSheetUrl,
+                            time: vt.start,
+                            w,
+                            h,
+                            x: parseInt(coor[0], 10) || 0,
+                            y: parseInt(coor[1], 10) || 0,
+                        });
+                    }
+                }
+            }
+        }
+        return thumbs;
+    }
+    // TODO check if seek enabled
+    bindEvents() {
+        this.listenToOnce(this.core, Events.CORE_READY, this._onCoreReady);
+        this.listenTo(this.core.mediaControl, Events.MEDIACONTROL_MOUSEMOVE_SEEKBAR, this._onMouseMove);
+        this.listenTo(this.core.mediaControl, Events.MEDIACONTROL_MOUSELEAVE_SEEKBAR, this._onMouseLeave);
+        this.listenTo(this.core.mediaControl, Events.MEDIACONTROL_RENDERED, this._init);
+        this.listenTo(this.core.mediaControl, Events.MEDIACONTROL_CONTAINERCHANGED, this._onMediaControlContainerChanged);
+    }
+    _bindContainerEvents() {
+        if (this._oldContainer) {
+            this.stopListening(this._oldContainer, Events.CONTAINER_TIMEUPDATE, this._renderPlugin);
+        }
+        this._oldContainer = this.core.mediaControl.container;
+        this.listenTo(this.core.mediaControl.container, Events.CONTAINER_TIMEUPDATE, this._renderPlugin);
+    }
+    _onCoreReady() {
+        try {
+            if (!this.options.thumbnails || !this.options.thumbnails.sprite || !this.options.thumbnails.vtt) {
+                this.destroy();
+                return;
+            }
+        }
+        catch (error) {
+            reportError(error);
+            return;
+        }
+        // TODO options
+        const spriteSheet = this.options.thumbnails.sprite;
+        this._thumbs = this.buildSpriteConfig(parseSRT(this.options.thumbnails.vtt), spriteSheet);
+        if (!this._thumbs.length) {
+            this.destroy();
+            return;
+        }
+        this.loadSpriteSheet(spriteSheet).then(() => {
+            this._thumbsLoaded = true;
+            this.core.options.thumbnails.spotlightHeight = this._thumbs[0].h;
+            this._init();
+        });
+    }
+    async loadSpriteSheet(spriteSheetUrl) {
+        return new Promise((resolve, reject) => {
+            const img = new Image();
+            img.onload = () => {
+                this.spriteSheetHeight = img.height;
+                resolve();
+            };
+            img.onerror = reject;
+            img.src = spriteSheetUrl;
+        });
+    }
+    _onMediaControlContainerChanged() {
+        this._bindContainerEvents();
+    }
+    _init() {
+        if (!this._thumbsLoaded) {
+            // _init() will be called when the thumbs are loaded,
+            // and whenever the media control rendered event is fired as just before this the dom elements get wiped in IE (https://github.com/tjenkinson/clappr-thumbnails-plugin/issues/5)
+            return;
+        }
+        // Init the backdropCarousel as array to keep reference of thumbnail images
+        this._$backdropCarouselImgs = [];
+        // create/recreate the dom elements for the plugin
+        this._createElements();
+        this._loadBackdrop();
+        this._renderPlugin();
+    }
+    _getOptions() {
+        if (!('thumbnails' in this.core.options)) {
+            throw '\'thumbnail property missing from options object.';
+        }
+        return this.core.options.thumbnails;
+    }
+    _appendElToMediaControl() {
+        // insert after the background
+        this.core.mediaControl.$el.find('.seek-time').css('bottom', 56);
+        this.core.mediaControl.$el.first().after(this.el);
+    }
+    _onMouseMove(e) {
+        // trace(`${T} _onMouseMove`, {
+        //   e: (e as any).name,
+        //   t: typeof e,
+        //   t2: typeof arguments[1],
+        // });
+        this._calculateHoverPosition(e);
+        this._show = true;
+        this._renderPlugin();
+    }
+    _onMouseLeave() {
+        this._show = false;
+        this._renderPlugin();
+    }
+    _calculateHoverPosition(e) {
+        const offset = getPageX(e) - this.core.mediaControl.$seekBarContainer.offset().left;
+        // proportion into the seek bar that the mouse is hovered over 0-1
+        this._hoverPosition = Math.min(1, Math.max(offset / this.core.mediaControl.$seekBarContainer.width(), 0));
+    }
+    // private _buildThumbsFromOptions() {
+    //   const thumbs = this._thumbs;
+    //   const promises = thumbs.map((thumb) => {
+    //     return this._addThumbFromSrc(thumb);
+    //   });
+    //   return Promise.all(promises);
+    // }
+    // private _addThumbFromSrc(thumbSrc) {
+    //   return new Promise((resolve, reject) => {
+    //     const img = new Image();
+    //     img.onload = () => {
+    //       resolve(img);
+    //     };
+    //     img.onerror = reject;
+    //     img.src = thumbSrc.url;
+    //   }).then((img) => {
+    //     const startTime = thumbSrc.time;
+    //     // determine the thumb index
+    //     let index = null;
+    //     this._thumbs.some((thumb, i) => {
+    //       if (startTime < thumb.time) {
+    //         index = i;
+    //         return true;
+    //       }
+    //       return false;
+    //     });
+    //     if (index === null) {
+    //       index = this._thumbs.length;
+    //     }
+    //     const next = index < this._thumbs.length ? this._thumbs[index] : null;
+    //     const prev = index > 0 ? this._thumbs[index - 1] : null;
+    //     if (prev) {
+    //       // update the duration of the previous thumbnail
+    //       prev.duration = startTime - prev.time;
+    //     }
+    //     // the duration this thumb lasts for
+    //     // if it is the last thumb then duration will be null
+    //     const duration = next ? next.time - thumbSrc.time : null;
+    //     const imageW = img.width;
+    //     const imageH = img.height;
+    //     const thumb = {
+    //       imageW: imageW, // actual width of image
+    //       imageH: imageH, // actual height of image
+    //       x: thumbSrc.x || 0, // x coord in image of sprite
+    //       y: thumbSrc.y || 0, // y coord in image of sprite
+    //       w: thumbSrc.w || imageW, // width of sprite
+    //       h: thumbSrc.h || imageH, // height of sprite
+    //       url: thumbSrc.url,
+    //       time: startTime, // time this thumb represents
+    //       duration: duration, // how long (from time) this thumb represents
+    //       src: thumbSrc
+    //     };
+    //     this._thumbs.splice(index, 0, thumb);
+    //     return thumb;
+    //   });
+    // }
+    // builds a dom element which represents the thumbnail
+    // scaled to the provided height
+    _buildImg(thumb, height) {
+        const scaleFactor = height / thumb.h;
+        if (!this.$img) {
+            this.$img = $('<img />').addClass('thumbnail-img').attr('src', thumb.url);
+        }
+        // the container will contain the image positioned so that the correct sprite
+        // is visible
+        if (!this.$container) {
+            this.$container = $('<div />').addClass('thumbnail-container');
+        }
+        this.$container.css('width', thumb.w * scaleFactor);
+        this.$container.css('height', height);
+        this.$img.css({
+            height: this.spriteSheetHeight * scaleFactor,
+            left: -1 * thumb.x * scaleFactor,
+            top: -1 * thumb.y * scaleFactor
+        });
+        if (this.$container.find(this.$img).length === 0) {
+            this.$container.append(this.$img);
+        }
+        return this.$container;
+    }
+    _loadBackdrop() {
+        if (!this._getOptions().backdropHeight) {
+            // disabled
+            return;
+        }
+        // append each of the thumbnails to the backdrop carousel
+        const $carousel = this._$carousel;
+        for (const thumb of this._thumbs) {
+            const $img = this._buildImg(thumb, this._getOptions().backdropHeight);
+            // Keep reference to thumbnail
+            this._$backdropCarouselImgs.push($img);
+            // Add thumbnail to DOM
+            $carousel.append($img);
+        }
+    }
+    setText(time) {
+        if (this.core.getPlugin('clips')) {
+            const txt = this.core.getPlugin('clips').getText(time);
+            this.$textThumbnail.text(txt);
+        }
+    }
+    // calculate how far along the carousel should currently be slid
+    // depending on where the user is hovering on the progress bar
+    _updateCarousel() {
+        trace(`${T} _updateCarousel`, {
+            backdropHeight: this._getOptions().backdropHeight,
+        });
+        if (!this._getOptions().backdropHeight) {
+            // disabled
+            return;
+        }
+        const hoverPosition = this._hoverPosition;
+        const videoDuration = this.core.mediaControl.container.getDuration();
+        const startTimeOffset = this.core.mediaControl.container.getStartTimeOffset();
+        // the time into the video at the current hover position
+        const hoverTime = startTimeOffset + (videoDuration * hoverPosition);
+        const backdropWidth = this._$backdrop.width();
+        const $carousel = this._$carousel;
+        const carouselWidth = $carousel.width();
+        // slide the carousel so that the image on the carousel that is above where the person
+        // is hovering maps to that position in time.
+        // Thumbnails may not be distributed at even times along the video
+        const thumbs = this._thumbs;
+        // assuming that each thumbnail has the same width
+        const thumbWidth = carouselWidth / thumbs.length;
+        // determine which thumbnail applies to the current time
+        const thumbIndex = this._getThumbIndexForTime(hoverTime);
+        const thumb = thumbs[thumbIndex];
+        let thumbDuration = thumb.duration;
+        if (!thumbDuration) {
+            // the last thumbnail duration will be null as it can't be determined
+            // e.g the duration of the video may increase over time (live stream)
+            // so calculate the duration now so this last thumbnail lasts till the end
+            thumbDuration = Math.max(videoDuration + startTimeOffset - thumb.time, 0);
+        }
+        // determine how far accross that thumbnail we are
+        const timeIntoThumb = hoverTime - thumb.time;
+        const positionInThumb = timeIntoThumb / thumbDuration;
+        const xCoordInThumb = thumbWidth * positionInThumb;
+        // now calculate the position along carousel that we want to be above the hover position
+        const xCoordInCarousel = (thumbIndex * thumbWidth) + xCoordInThumb;
+        // and finally the position of the carousel when the hover position is taken in to consideration
+        const carouselXCoord = xCoordInCarousel - (hoverPosition * backdropWidth);
+        $carousel.css('left', -carouselXCoord);
+        const maxOpacity = this._getOptions().backdropMaxOpacity || 0.6;
+        const minOpacity = this._getOptions().backdropMinOpacity || 0.08;
+        // now update the transparencies so that they fade in around the active one
+        for (let i = 0; i < thumbs.length; i++) {
+            const thumbXCoord = thumbWidth * i;
+            let distance = thumbXCoord - xCoordInCarousel;
+            if (distance < 0) {
+                // adjust so that distance is always a measure away from
+                // each side of the active thumbnail
+                // at every point on the active thumbnail the distance should
+                // be 0
+                distance = Math.min(0, distance + thumbWidth);
+            }
+            // fade over the width of 2 thumbnails
+            const opacity = Math.max(maxOpacity - (Math.abs(distance) / (2 * thumbWidth)), minOpacity);
+            this._$backdropCarouselImgs[i].css('opacity', opacity);
+        }
+    }
+    _updateSpotlightThumb() {
+        trace(`${T} _updateSpotlightThumb`, {
+            spotlightHeight: this._getOptions().spotlightHeight,
+        });
+        if (!this._getOptions().spotlightHeight) {
+            // disabled
+            return;
+        }
+        const hoverPosition = this._hoverPosition;
+        const videoDuration = this.core.mediaControl.container.getDuration();
+        // the time into the video at the current hover position
+        const startTimeOffset = this.core.mediaControl.container.getStartTimeOffset();
+        const hoverTime = startTimeOffset + (videoDuration * hoverPosition);
+        this.setText(hoverTime);
+        // determine which thumbnail applies to the current time
+        const thumbIndex = this._getThumbIndexForTime(hoverTime);
+        const thumb = this._thumbs[thumbIndex];
+        // update thumbnail
+        const $spotlight = this._$spotlight;
+        $spotlight.empty();
+        $spotlight.append(this._buildImg(thumb, this._getOptions().spotlightHeight));
+        const elWidth = this.$el.width();
+        const thumbWidth = $spotlight.width();
+        const thumbHeight = $spotlight.height();
+        let spotlightXPos = (elWidth * hoverPosition) - (thumbWidth / 2);
+        // adjust so the entire thumbnail is always visible
+        spotlightXPos = Math.max(Math.min(spotlightXPos, elWidth - thumbWidth), 0);
+        $spotlight.css('left', spotlightXPos);
+        this.$textThumbnail.css('left', spotlightXPos);
+        this.$textThumbnail.css('width', thumbWidth);
+        this.$textThumbnail.css('bottom', thumbHeight + 1);
+    }
+    // returns the thumbnail which represents a time in the video
+    // or null if there is no thumbnail that can represent the time
+    _getThumbIndexForTime(time) {
+        const thumbs = this._thumbs;
+        for (let i = thumbs.length - 1; i >= 0; i--) {
+            const thumb = thumbs[i];
+            if (thumb.time <= time) {
+                return i;
+            }
+        }
+        // stretch the first thumbnail back to the start
+        return 0;
+    }
+    _renderPlugin() {
+        trace(`${T} _renderPlugin`, {
+            show: this._show,
+            thumbsLoaded: this._thumbsLoaded,
+            thumbs: this._thumbs.length,
+        });
+        if (!this._thumbsLoaded) {
+            return;
+        }
+        if (this._show && this._thumbs.length > 0) {
+            this.$el.removeClass('hidden');
+            this._updateCarousel();
+            this._updateSpotlightThumb();
+        }
+        else {
+            this.$el.addClass('hidden');
+        }
+    }
+    _createElements() {
+        trace(`${T} _createElements`);
+        this.$el.html(this.template({
+            'backdropHeight': this._getOptions().backdropHeight,
+            'spotlightHeight': this._getOptions().spotlightHeight
+        }));
+        // cache dom references
+        this._$spotlight = this.$el.find('.spotlight');
+        this._$backdrop = this.$el.find('.backdrop');
+        this._$carousel = this._$backdrop.find('.carousel');
+        this.$textThumbnail = this.$el.find('.thumbnails-text');
+        this.$el.addClass('hidden');
+        this._appendElToMediaControl();
+    }
+}

package/lib/plugins/types.d.ts

@@ -0,0 +1,8 @@
+import { $ } from "@clappr/core";
+export type ZeptoResult = ReturnType<typeof $>;
+export type TimePosition = {
+    current: number;
+    total: number;
+};
+export type TimerId = ReturnType<typeof setTimeout>;
+//# sourceMappingURL=types.d.ts.map

package/lib/plugins/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/plugins/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,cAAc,CAAC;AAEjC,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC;AAE/C,MAAM,MAAM,YAAY,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9D,MAAM,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/lib/plugins/types.js

@@ -0,0 +1 @@
+export {};

package/lib/plugins/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function getLocation(href: string): HTMLAnchorElement;
+export declare function strtimeToMiliseconds(str: string): number;
+export declare function isFullscreen(el: HTMLElement): boolean;
+export declare function getPageX(event: MouseEvent | TouchEvent): number;
+//# sourceMappingURL=utils.d.ts.map

package/lib/plugins/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/plugins/utils.ts"],"names":[],"mappings":"AAGA,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,qBAMvC;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAyBxD;AAGD,wBAAgB,YAAY,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CASrD;AAkBD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,GAAG,MAAM,CAU/D"}

package/lib/plugins/utils.js

@@ -0,0 +1,68 @@
+import { Browser } from '@clappr/core';
+import { reportError } from '@gcorevideo/utils';
+export function getLocation(href) {
+    const l = document.createElement('a');
+    l.href = href;
+    return l;
+}
+export function strtimeToMiliseconds(str) {
+    if (!str) {
+        return 0;
+    }
+    const arr = str.split(/:/);
+    let h = 0, m = 0, s = 0;
+    if (arr.length >= 3) {
+        h = parseInt(arr[arr.length - 3]) * 60 * 60;
+    }
+    else {
+        h = 0;
+    }
+    if (arr.length >= 2) {
+        m = parseInt(arr[arr.length - 2]) * 60;
+    }
+    else {
+        m = 0;
+    }
+    if (arr.length >= 1) {
+        s = parseInt(arr[arr.length - 1]);
+    }
+    else {
+        s = 0;
+    }
+    return (h + m + s);
+}
+// TODO refactor
+export function isFullscreen(el) {
+    const video = el.nodeName === "video" ? el : el.querySelector('video');
+    if (!video) {
+        return false;
+    }
+    if (Browser.isiOS) {
+        return FullscreenIOS.isFullscreen(video);
+    }
+    return !!(document.fullscreenElement);
+}
+const FullscreenIOS = {
+    isFullscreen: function (el) {
+        try {
+            // @ts-ignore
+            if (el.webkitDisplayingFullscreen !== undefined) {
+                // @ts-ignore
+                return !!(el.webkitDisplayingFullscreen);
+            }
+        }
+        catch (e) {
+            reportError(e);
+        }
+        return false;
+    }
+};
+export function getPageX(event) {
+    if (event.pageX) {
+        return event.pageX;
+    }
+    if (event.changedTouches) {
+        return event.changedTouches[event.changedTouches.length - 1].pageX;
+    }
+    return 0;
+}

package/lib/plugins/vast-ads/VastAds.d.ts

@@ -0,0 +1,72 @@
+import { Core, Playback, UICorePlugin } from '@clappr/core';
+import '../../../assets/vast-ads/style.scss';
+export declare class VastAds extends UICorePlugin {
+    private _clickToPausePlugin;
+    private _cloneContainerEvents;
+    private _clonePlaybackEvents;
+    private countMiddleRoll;
+    private countRepeatableRoll;
+    private _container;
+    private container;
+    private _contentElement;
+    private _currentPosition;
+    private currentState;
+    private _imaIsloaded;
+    private _imaLoadResult;
+    private intervalTimer;
+    private _playback;
+    private _pluginIsReady;
+    private _posterBigPlayStyle;
+    private _posterPlugin;
+    private _prevVolumeValue;
+    private vast;
+    private _volume;
+    private startTimeRepeatableRoll;
+    private startTimeRepeatableRollGap;
+    private _scteManager;
+    private $skipAd;
+    private $muteIcon;
+    private $areaClick;
+    private _$adContainer;
+    private _adContainer;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    static get version(): string;
+    get mediaControl(): any;
+    get attributes(): {
+        class: string;
+        'data-vast-ads': string;
+    };
+    constructor(core: Core);
+    bindEvents(): void;
+    private onPlaybackEnded;
+    private onPlaybackPlay;
+    private onPlaybackPrerollRequest;
+    private onPlaybackTimeUpdate;
+    private rebindNextAd;
+    private initializeRollManager;
+    private changeVolume;
+    private findCloserAdvertisement;
+    private _validateData;
+    private playerResize;
+    private _stopPauserollListeners;
+    private _pauserollListeners;
+    unBindEvents(): void;
+    private containerChanged;
+    private _pluginError;
+    private _onCoreReady;
+    set playback(value: Playback);
+    get playback(): Playback | null;
+    private _onContainerVolume;
+    _onVolumeChanged(e: number): void;
+    _stopListening(): void;
+    _startListening(): void;
+    _initPlugin(): void;
+    private adsPlaying;
+    private destroyRoll;
+    private _playVideoContent;
+    render(): this;
+}
+//# sourceMappingURL=VastAds.d.ts.map

package/lib/plugins/vast-ads/VastAds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VastAds.d.ts","sourceRoot":"","sources":["../../../src/plugins/vast-ads/VastAds.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,IAAI,EAIJ,QAAQ,EAER,YAAY,EAEb,MAAM,cAAc,CAAA;AAYrB,OAAO,qCAAqC,CAAA;AAQ5C,qBAAa,OAAQ,SAAQ,YAAY;IACvC,OAAO,CAAC,mBAAmB,CAAiC;IAE5D,OAAO,CAAC,qBAAqB,CAAwC;IAErE,OAAO,CAAC,oBAAoB,CAAwC;IAEpE,OAAO,CAAC,eAAe,CAAI;IAE3B,OAAO,CAAC,mBAAmB,CAAI;IAE/B,OAAO,CAAC,UAAU,CAAyB;IAE3C,OAAO,CAAC,SAAS,CAAyB;IAE1C,OAAO,CAAC,eAAe,CAA2B;IAElD,OAAO,CAAC,gBAAgB,CAAI;IAE5B,OAAO,CAAC,YAAY,CAAY;IAEhC,OAAO,CAAC,YAAY,CAAQ;IAE5B,OAAO,CAAC,cAAc,CAAQ;IAE9B,OAAO,CAAC,aAAa,CAAuB;IAE5C,OAAO,CAAC,SAAS,CAAwB;IAEzC,OAAO,CAAC,cAAc,CAAQ;IAE9B,OAAO,CAAC,mBAAmB,CAA2B;IAEtD,OAAO,CAAC,aAAa,CAAiC;IAEtD,OAAO,CAAC,gBAAgB,CAAI;IAE5B,OAAO,CAAC,IAAI,CAA2B;IAEvC,OAAO,CAAC,OAAO,CAAK;IAEpB,OAAO,CAAC,uBAAuB,CAAI;IAEnC,OAAO,CAAC,0BAA0B,CAAI;IAEtC,OAAO,CAAC,YAAY,CAAoB;IAExC,OAAO,CAAC,OAAO,CAA2B;IAE1C,OAAO,CAAC,SAAS,CAA2B;IAE5C,OAAO,CAAC,UAAU,CAA2B;IAE7C,OAAO,CAAC,aAAa,CAA2B;IAEhD,OAAO,CAAC,YAAY,CAA2B;IAE/C,IAAI,IAAI,WAEP;IAED,IAAI,gBAAgB;;MAEnB;IAED,MAAM,KAAK,OAAO,WAEjB;IAED,IAAI,YAAY,QAEf;IAED,IAAa,UAAU;;;MAKtB;gBAEW,IAAI,EAAE,IAAI;IAqEb,UAAU;IA8FnB,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,wBAAwB;IAWhC,OAAO,CAAC,oBAAoB;IAkE5B,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,qBAAqB;IAwD7B,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,uBAAuB;IAuC/B,OAAO,CAAC,aAAa;IAsBrB,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,uBAAuB;IAO/B,OAAO,CAAC,mBAAmB;IAiD3B,YAAY;IASZ,OAAO,CAAC,gBAAgB;IA0BxB,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,YAAY;IA6BpB,IAAI,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAG3B;IAED,IAAI,QAAQ,IAAI,QAAQ,GAAG,IAAI,CAE9B;IAED,OAAO,CAAC,kBAAkB;IAU1B,gBAAgB,CAAC,CAAC,EAAE,MAAM;IAQ1B,cAAc;IAsBd,eAAe;IAkBf,WAAW;IAiBX,OAAO,CAAC,UAAU;IA+ClB,OAAO,CAAC,WAAW;IASnB,OAAO,CAAC,iBAAiB;IAiHhB,MAAM;CAwBhB"}