@microsoft/live-share-media 2.0.0-internal.6 → 2.0.0-internal.8

package/src/LiveMediaSessionCoordinator.ts

@@ -40,7 +40,7 @@ import {
     TrackMetadataNotSetError,
     ActionBlockedError,
 } from "./internals/errors.js";
-
+import { PriorityTimeInterval } from "./internals/PriorityTimeInterval.js";
 import { LiveMediaSessionCoordinatorSuspension } from "./LiveMediaSessionCoordinatorSuspension.js";
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { IEvent } from "@fluidframework/core-interfaces";
@@ -97,8 +97,27 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter<ILiveMediaSes
     private readonly _liveRuntime: LiveShareRuntime;
     private readonly _logger: LiveTelemetryLogger;
     private readonly _getPlayerState: () => IMediaPlayerState;
-    private _positionUpdateInterval = new TimeInterval(2000);
-    private _maxPlaybackDrift = new TimeInterval(1000);
+    private _positionUpdateInterval = new PriorityTimeInterval(
+        2000,
+        // Scale by function
+        () => {
+            const audience = this._liveRuntime.audience;
+            if (!audience) return 1;
+            // As the audience size gets bigger, we relax the update interval, since more variance is expected
+            const count = audience.getMembers().size;
+            return 1 + count / 5;
+        }
+    );
+    private _maxPlaybackDrift = new PriorityTimeInterval(
+        1500, // Scale by function
+        () => {
+            const audience = this._liveRuntime.audience;
+            if (!audience) return 1;
+            // As the audience size gets bigger, we relax the playback drift, since more variance is expected
+            const count = audience.getMembers().size;
+            return 1 + count / 25;
+        }
+    );
     private _lastWaitPoint?: CoordinationWaitPoint;
     private initializeState: LiveDataObjectInitializeState =
         LiveDataObjectInitializeState.needed;
@@ -222,13 +241,29 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter<ILiveMediaSes
     }
 
     /**
-     * Max amount of playback drift allowed in seconds.
+     * Controls whether or not to scale {@link maxPlaybackDrift} by the number of users in the session.
      *
      * @remarks
-     * Should the local clients playback position lag by more than the specified value, the
-     * coordinator will trigger a `catchup` action.
+     * As more clients join a session, it is more likely that some users will fall behind the presenter.
+     * It is also less likely that users will notice drift as more clients are added.
+     * It is usually helpful to be more lenient as more clients are added so everyone can watch all the content.
+     * Default value is true.
+     */
+    public get shouldScaleMaxPlaybackDrift(): boolean {
+        return this._maxPlaybackDrift.shouldPrioritize;
+    }
+
+    public set shouldScaleMaxPlaybackDrift(value: boolean) {
+        this._maxPlaybackDrift.shouldPrioritize = value;
+    }
+
+    /**
+     * Max amount of playback drift allowed in seconds.
+     * This will scale automatically according to the number of participants in the session when {@link shouldScaleMaxPlaybackDrift} is true.
      *
-     * Defaults to a value of `1` second.
+     * @remarks
+     * Should the local clients playback position lag by more than the specified value, the coordinator will trigger a `catchup` action.
+     * Default value is `1.5` seconds.
      */
     public get maxPlaybackDrift(): number {
         return this._maxPlaybackDrift.seconds;
@@ -239,11 +274,30 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter<ILiveMediaSes
     }
 
     /**
-     * Frequency with which position updates are broadcast to the rest of the group in
-     * seconds.
+     * Controls whether or not to compute {@link positionUpdateInterval} based on whether user has initiated a playback command.
+     * Default value is true.
      *
      * @remarks
-     * Defaults to a value of `2` seconds.
+     * When true, users that are simply watching but not controlling playback will report their positions less frequently.
+     * When a user has sent a transport command, they will begin sending position updates more frequently.
+     * Most Live Share apps have a concept of a primary presenter, and don't allow anyone to pause/play for the group.
+     * By ensuring only one/few users broadcast updates frequently, the server load is reduced considerably.
+     */
+    public get shouldScalePositionUpdateInterval(): boolean {
+        return this._positionUpdateInterval.shouldPrioritize;
+    }
+
+    public set shouldScalePositionUpdateInterval(value: boolean) {
+        this._positionUpdateInterval.shouldPrioritize = value;
+    }
+
+    /**
+     * Frequency with which position updates are broadcast to the rest of the group in seconds.
+     * When {@link shouldScalePositionUpdateInterval} is set to `true`, the value set is the minimum value.
+     * The value returned is the actual value used to send updates by the local user, which may be larger than the value set.
+     *
+     * @remarks
+     * Defaults to a minimum value of `2` seconds.
      */
     public get positionUpdateInterval(): number {
         return this._positionUpdateInterval.seconds;
@@ -293,6 +347,10 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter<ILiveMediaSes
             track: this._groupState.playbackTrack.current,
             position: position,
         });
+        if (this.canSendPositionUpdates) {
+            // User has taken initiative to send event, give priority for sending position updates
+            this._positionUpdateInterval.hasPriority = true;
+        }
     }
 
     /**
@@ -335,6 +393,10 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter<ILiveMediaSes
             track: this._groupState.playbackTrack.current,
             position: position,
         });
+        if (this.canSendPositionUpdates) {
+            // User has taken initiative to send event, give priority for sending position updates
+            this._positionUpdateInterval.hasPriority = true;
+        }
     }
 
     /**
@@ -375,12 +437,24 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter<ILiveMediaSes
                 track: this._groupState.playbackTrack.current,
                 position: time,
             });
+            if (this.canSendPositionUpdates) {
+                // User has taken initiative to send event, give priority for sending position updates
+                this._positionUpdateInterval.hasPriority = true;
+            }
         } catch (err) {
             await this._groupState!.syncLocalMediaSession();
             throw err;
         }
     }
 
+    /**
+     * Sets the playback rate for everyone in the session.
+     *
+     * @param playbackRate the playback rate to set.
+     *
+     * @throws
+     * Throws an exception if the session/coordinator hasn't been initialized or {@link canSetPlaybackRate} is false.
+     */
     public async setPlaybackRate(playbackRate: number): Promise<void> {
         LiveDataObjectNotInitializedError.assert(
             "LiveMediaSessionCoordinator:setPlaybackRate",
@@ -400,6 +474,10 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter<ILiveMediaSes
             { playbackRate }
         );
         await this._rateChangeEvent!.sendEvent({ playbackRate });
+        if (this.canSendPositionUpdates) {
+            // User has taken initiative to send event, give priority for sending position updates
+            this._positionUpdateInterval.hasPriority = true;
+        }
     }
 
     /**
@@ -436,6 +514,10 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter<ILiveMediaSes
             metadata: metadata,
             waitPoints: waitPoints || [],
         });
+        if (this.canSendPositionUpdates) {
+            // User has taken initiative to send event, give priority for sending position updates
+            this._positionUpdateInterval.hasPriority = true;
+        }
     }
 
     /**
@@ -470,6 +552,10 @@ export class LiveMediaSessionCoordinator extends TypedEventEmitter<ILiveMediaSes
         await this._setTrackDataEvent!.sendEvent({
             data: data,
         });
+        if (this.canSendPositionUpdates) {
+            // User has taken initiative to send event, give priority for sending position updates
+            this._positionUpdateInterval.hasPriority = true;
+        }
     }
 
     /**

package/src/internals/GroupCoordinatorState.ts

@@ -53,6 +53,7 @@ import {
 } from "./GroupPlaybackRate.js";
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { IGenericTypedEvents } from "./interfaces.js";
+import { PriorityTimeInterval } from "./PriorityTimeInterval.js";
 
 /**
  * @hidden
@@ -145,7 +146,7 @@ export class GroupCoordinatorState extends TypedEventEmitter<IGenericTypedEvents
         runtime: IRuntimeSignaler,
         liveRuntime: LiveShareRuntime,
         maxPlaybackDrift: TimeInterval,
-        positionUpdateInterval: TimeInterval,
+        positionUpdateInterval: PriorityTimeInterval,
         getMediaPlayerState: () => IMediaPlayerState
     ) {
         super();

package/src/internals/GroupPlaybackPosition.ts

@@ -3,7 +3,6 @@
  * Licensed under the Microsoft Live Share SDK License.
  */
 
-import { TimeInterval } from "@microsoft/live-share";
 import {
     IRuntimeSignaler,
     LiveShareRuntime,
@@ -15,6 +14,7 @@ import {
     ExtendedMediaSessionPlaybackState,
 } from "../MediaSessionExtensions.js";
 import { GroupPlaybackRate } from "./GroupPlaybackRate.js";
+import { PriorityTimeInterval } from "./PriorityTimeInterval.js";
 
 /**
  * Per client position
@@ -37,7 +37,7 @@ export class GroupPlaybackPosition {
     private _playbackRate: GroupPlaybackRate;
     private _runtime: IRuntimeSignaler;
     private _liveRuntime: LiveShareRuntime;
-    private _updateInterval: TimeInterval;
+    private _updateInterval: PriorityTimeInterval;
     private _positions: Map<string, ICurrentPlaybackPosition>;
 
     constructor(
@@ -45,7 +45,7 @@ export class GroupPlaybackPosition {
         playbackRate: GroupPlaybackRate,
         runtime: IRuntimeSignaler,
         liveRuntime: LiveShareRuntime,
-        updateInterval: TimeInterval
+        updateInterval: PriorityTimeInterval
     ) {
         this._transportState = transportState;
         this._playbackRate = playbackRate;
@@ -171,7 +171,7 @@ export class GroupPlaybackPosition {
         ) => void
     ): void {
         const now = this._liveRuntime.getTimestamp();
-        const ignoreBefore = now - this._updateInterval.milliseconds * 2;
+        const ignoreBefore = now - this._updateInterval.maxMilliseconds * 2;
         const shouldProject = !this._transportState.track.metadata?.liveStream;
         this._positions.forEach((position, _) => {
             // Ignore any old updates

package/src/internals/PriorityTimeInterval.ts

@@ -0,0 +1,76 @@
+import { TimeInterval } from "@microsoft/live-share";
+
+function getScaledPriorityTimeMs(
+    minMilliseconds: number,
+    hasPriority: boolean,
+    shouldPrioritize: boolean,
+    scaleBy: number
+): number {
+    if (!shouldPrioritize) return minMilliseconds;
+    if (hasPriority) return minMilliseconds;
+    return minMilliseconds * scaleBy;
+}
+
+/**
+ * @hidden
+ * Time interval that can scale based on a scaling function.
+ */
+export class PriorityTimeInterval extends TimeInterval {
+    /**
+     * If true, local user has priority and will have the lowest possible millesecond value.
+     */
+    public hasPriority: boolean;
+    /**
+     * If true, milliseconds will be scaled when {@link hasPriority} is false.
+     */
+    public shouldPrioritize: boolean;
+    /**
+     * Function to get the scale ratio.
+     */
+    private getScaleBy: () => number;
+    /**
+     * Time interval that can scale based on a scaling function.
+     *
+     * @param defaultMilliseconds the default minimum milliseconds
+     * @param getScaleByFn a function to scale the milliseconds by when {@link hasPriority} is false and {@link shouldPrioritize} is true.
+     * @param defaultHasPriority the default {@link hasPriority} value
+     * @param defaultShouldPrioritize the default {@link shouldPrioritize} value
+     */
+    constructor(
+        defaultMilliseconds: number,
+        getScaleByFn: () => number,
+        defaultHasPriority: boolean = false,
+        defaultShouldPrioritize: boolean = true
+    ) {
+        super(defaultMilliseconds);
+        this.hasPriority = defaultHasPriority;
+        this.shouldPrioritize = defaultShouldPrioritize;
+        this.getScaleBy = getScaleByFn;
+    }
+
+    public get milliseconds(): number {
+        return getScaledPriorityTimeMs(
+            this._milliseconds,
+            this.hasPriority,
+            this.shouldPrioritize,
+            this.getScaleBy()
+        );
+    }
+
+    public set milliseconds(value: number) {
+        this._milliseconds = value;
+    }
+
+    public get minMilliseconds(): number {
+        return this._milliseconds;
+    }
+
+    public get maxMilliseconds(): number {
+        return getScaledPriorityTimeMs(
+            this._milliseconds,
+            false,
+            this.shouldPrioritize,
+            this.getScaleBy()
+        );
+    }
+}

package/.mocharc.cjs

@@ -1,12 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the Microsoft Live Share SDK License.
- */
-
-"use strict";
-
-const packageDir = `${__dirname}/../..`;
-
-const getFluidTestMochaConfig = require("@fluidframework/mocha-test-setup/mocharc-common.js");
-const config = getFluidTestMochaConfig(packageDir);
-module.exports = config;

package/.nycrc.json

@@ -1,11 +0,0 @@
-{
-    "cache": false,
-    "extension": [".ts"],
-    "check-coverage": true,
-    "include": ["src/**"],
-    "exclude": ["src/pps/**"],
-    "statements": 90,
-    "branches": 90,
-    "functions": 95,
-    "lines": 90
-}

package/bin/test/IMediaPlayer.d.ts

@@ -1,21 +0,0 @@
-/**
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the Microsoft Live Share SDK License.
- */
-export interface IMediaPlayer {
-    readonly currentSrc: string;
-    currentTime: number;
-    readonly duration: number;
-    readonly ended: boolean;
-    muted: boolean;
-    readonly paused: boolean;
-    playbackRate: number;
-    src: string;
-    volume: number;
-    load(): void;
-    pause(): void;
-    play(): Promise<void>;
-    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
-    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
-}
-//# sourceMappingURL=IMediaPlayer.d.ts.map

package/bin/test/IMediaPlayer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IMediaPlayer.d.ts","sourceRoot":"","sources":["../../src/IMediaPlayer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,YAAY;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,IAAI,IAAI,CAAC;IACb,KAAK,IAAI,IAAI,CAAC;IACd,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,gBAAgB,CACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,kCAAkC,EAC5C,OAAO,CAAC,EAAE,OAAO,GAAG,uBAAuB,GAC5C,IAAI,CAAC;IACR,mBAAmB,CACf,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,kCAAkC,EAC5C,OAAO,CAAC,EAAE,OAAO,GAAG,oBAAoB,GACzC,IAAI,CAAC;CACX"}

package/bin/test/IMediaPlayer.js

@@ -1,7 +0,0 @@
-"use strict";
-/**
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the Microsoft Live Share SDK License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=IMediaPlayer.js.map

package/bin/test/IMediaPlayer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"IMediaPlayer.js","sourceRoot":"","sources":["../../src/IMediaPlayer.ts"],"names":[],"mappings":";AAAA;;;GAGG"}

package/bin/test/LiveMediaSession.d.ts

@@ -1,97 +0,0 @@
-/**
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the Microsoft Live Share SDK License.
- */
-import { DataObjectFactory } from "@fluidframework/aqueduct/internal";
-import { LiveTelemetryLogger, UserMeetingRole } from "@microsoft/live-share";
-import { LiveDataObject } from "@microsoft/live-share/internal";
-import { MediaPlayerSynchronizer } from "./MediaPlayerSynchronizer.js";
-import { ExtendedMediaSessionAction, ExtendedMediaSessionActionHandler } from "./MediaSessionExtensions.js";
-import { LiveMediaSessionCoordinator, IMediaPlayerState } from "./LiveMediaSessionCoordinator.js";
-import { MediaSessionActionThrottler } from "./MediaSessionActionThrottler.js";
-import { IMediaPlayer } from "./IMediaPlayer.js";
-import { SharedObjectKind } from "fluid-framework";
-/**
- * Live fluid object that synchronizes media playback across multiple clients.
- */
-export declare class LiveMediaSessionClass extends LiveDataObject {
-    private _actionThrottler;
-    private _logger?;
-    private _requestPlayerStateHandler?;
-    private _coordinator?;
-    private readonly _actionHandlers;
-    private _synchronizing?;
-    private _updateTimer;
-    private _lastUpdateTime;
-    /**
-     * The objects fluid type name.
-     */
-    static readonly TypeName = "@microsoft/fluid-media:SharedMediaSession";
-    /**
-     * The objects fluid type factory.
-     */
-    static readonly factory: DataObjectFactory<LiveMediaSessionClass, import("@fluidframework/aqueduct/internal").DataObjectTypes>;
-    /**
-     * Extension point that lets applications replace the default logic for throttling the sessions
-     * local sync behavior.
-     *
-     * @remarks
-     * The `LiveMediaCoordinator` is fairly aggressive at wanting to keep the local media player
-     * in sync with the rest of the group. This aggressiveness can result in the coordinator sending
-     * new sync actions before the local player has finished responding to the previous sync action.
-     * The `ActionThrottler` gives apps fine grain control over how aggressive they want sync to be.
-     *
-     * By default, a `RepeatedAction` throttler is used which prevents the same sync action from
-     * being sent within an adjustable time period.
-     */
-    get actionThrottler(): MediaSessionActionThrottler;
-    set actionThrottler(value: MediaSessionActionThrottler);
-    /**
-     * The group coordinator for the session.
-     */
-    get coordinator(): LiveMediaSessionCoordinator;
-    /**
-     * Returns the logger used by the session and coordinator.
-     *
-     * @remarks
-     * This is used by the `MediaPlayerSynchronizer` to log events.
-     */
-    get logger(): LiveTelemetryLogger;
-    /**
-     * Initialize the object to begin sending/receiving group playback updates through this DDS.
-     *
-     * @param allowedRoles Optional. List of roles allowed to group transport operations like play/pause/seek/setTrack.
-     *
-     * @returns a void promise that resolves once complete.
-     *
-     * @throws error when `.initialize()` has already been called for this class instance.
-     */
-    initialize(allowedRoles?: UserMeetingRole[]): Promise<void>;
-    /**
-     * Registers an action handler with the session.
-     * @param action Name of the action to register a handler for.
-     * @param handler Function called when the action is triggered.
-     */
-    setActionHandler(action: ExtendedMediaSessionAction, handler: ExtendedMediaSessionActionHandler | MediaSessionActionHandler | null): void;
-    /**
-     * Registers a handler that will be queried anytime the group coordinate needs to know the
-     * local players transport state and position.
-     */
-    setRequestPlayerStateHandler(handler: () => IMediaPlayerState): void;
-    /**
-     * Begins synchronizing the playback of a media element.
-     * @param player Something that "looks like" and HTML Media Element.
-     * @returns A new synchronizer instance. Call `synchronizer.end()` to stop synchronizing the elements playback.
-     */
-    synchronize(player: IMediaPlayer): MediaPlayerSynchronizer;
-    protected hasInitialized(): Promise<void>;
-    private checkWaitPointHit;
-    private getCurrentPlayerState;
-    private dispatchAction;
-}
-/**
- * Live fluid object that synchronizes media playback across multiple clients.
- */
-export type LiveMediaSession = LiveMediaSessionClass;
-export declare const LiveMediaSession: typeof LiveMediaSessionClass & SharedObjectKind<LiveMediaSessionClass>;
-//# sourceMappingURL=LiveMediaSession.d.ts.map

package/bin/test/LiveMediaSession.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LiveMediaSession.d.ts","sourceRoot":"","sources":["../../src/LiveMediaSession.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACH,iBAAiB,EAEpB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAGH,mBAAmB,EACnB,eAAe,EAClB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAEH,cAAc,EACjB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAEvE,OAAO,EAEH,0BAA0B,EAE1B,iCAAiC,EACpC,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACH,2BAA2B,EAC3B,iBAAiB,EACpB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAC;AAE/E,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAGnD;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,cAAc;IACrD,OAAO,CAAC,gBAAgB,CACU;IAClC,OAAO,CAAC,OAAO,CAAC,CAAsB;IACtC,OAAO,CAAC,0BAA0B,CAAC,CAA0B;IAC7D,OAAO,CAAC,YAAY,CAAC,CAA8B;IACnD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAGlB;IACd,OAAO,CAAC,cAAc,CAAC,CAA0B;IAGjD,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,eAAe,CAAa;IAEpC;;OAEG;IACH,gBAAuB,QAAQ,+CAA+C;IAE9E;;OAEG;IACH,gBAAuB,OAAO,wGAK5B;IAEF;;;;;;;;;;;;OAYG;IACH,IAAW,eAAe,IAAI,2BAA2B,CAExD;IAED,IAAW,eAAe,CAAC,KAAK,EAAE,2BAA2B,EAE5D;IAED;;OAEG;IACH,IAAW,WAAW,IAAI,2BAA2B,CAEpD;IAED;;;;;OAKG;IACH,IAAW,MAAM,IAAI,mBAAmB,CAEvC;IAED;;;;;;;;OAQG;IACU,UAAU,CAAC,YAAY,CAAC,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAqBxE;;;;OAIG;IACI,gBAAgB,CACnB,MAAM,EAAE,0BAA0B,EAClC,OAAO,EACD,iCAAiC,GACjC,yBAAyB,GACzB,IAAI,GACX,IAAI;IAUP;;;OAGG;IACI,4BAA4B,CAAC,OAAO,EAAE,MAAM,iBAAiB;IAIpE;;;;OAIG;IACI,WAAW,CAAC,MAAM,EAAE,YAAY,GAAG,uBAAuB;cAoCjD,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAwF/C,OAAO,CAAC,iBAAiB;IAgCzB,OAAO,CAAC,qBAAqB;IAU7B,OAAO,CAAC,cAAc;CAQzB;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,qBAAqB,CAAC;AAGrD,eAAO,MAAM,gBAAgB,wEAGzB,CAAC"}