rx-player 4.4.1 → 4.5.0-dev.2026012301

package/dist/es2017/manifest/classes/representation_index/types.d.ts

@@ -1,441 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import type { IEMSG } from "../../../parsers/containers/isobmff";
-import type { ILocalIndexSegment, ILocalManifestInitSegmentLoader, ILocalManifestSegmentLoader } from "../../../parsers/manifest/local";
-import type { IPlayerError } from "../../../public_types";
-import type { ISegmentInformation } from "../../../transports";
-/**
- * Supplementary information specific to Smooth Initialization segments.
- * Contains every information needed to generate an initialization segment.
- */
-export interface ISmoothInitSegmentPrivateInfos {
-    /**
-     * Timescale the segments are in, in the Manifest.
-     * Needed because Smooth segment are created in JS based on timing information
-     * as found in the Manifest.
-     */
-    timescale: number;
-    codecPrivateData?: string | undefined;
-    bitsPerSample?: number | undefined;
-    channels?: number | undefined;
-    packetSize?: number | undefined;
-    samplingRate?: number | undefined;
-    protection?: {
-        keyId: Uint8Array;
-    } | undefined;
-    height?: number | undefined;
-    width?: number | undefined;
-}
-/**
- * Supplementary information specific to Smooth media segments (that is, every
- * segments but the initialization segment).
- */
-export interface ISmoothMediaSegmentPrivateInfos {
-    /**
-     * Start time of the segment as announced in the Manifest, in the same
-     * timescale than the one indicated through `ISmoothInitSegmentPrivateInfos`.
-     */
-    time: number;
-    /**
-     * Duration of the segment as announced in the Manifest, in the same timescale
-     * than the one indicated through `ISmoothInitSegmentPrivateInfos`.
-     */
-    duration: number;
-}
-/** Supplementary information needed for segments in the "metaplaylist" transport. */
-export interface IMetaPlaylistPrivateInfos {
-    /** The original transport protocol (e.g. "dash", "smooth" etc.) */
-    transportType: string;
-    contentStart: number;
-    contentEnd?: number | undefined;
-    /** The segment originally created by this transport's RepresentationIndex. */
-    originalSegment: ISegment;
-    isLive: boolean;
-    manifestPublishTime?: number | undefined;
-    periodEnd?: number | undefined;
-    periodStart: number;
-}
-/**
- * Supplementary information needed for initialization segments of the "local"
- * transport.
- */
-export interface ILocalManifestInitSegmentPrivateInfos {
-    /** Callback used to load that segment. */
-    load: ILocalManifestInitSegmentLoader;
-}
-/** Supplementary information needed for media segments of the "local" transport. */
-export interface ILocalManifestSegmentPrivateInfos {
-    /** Callback used to load that segment. */
-    load: ILocalManifestSegmentLoader;
-    /**
-     * Exact same segment than the one given in a local manifest.
-     * Stored (with at best the same reference than in it) to facilitate the job
-     * of retrieving the wanted segment (this task will generally be done by the
-     * content downloader tool) when the RxPlayer asks for it.
-     */
-    segment: ILocalIndexSegment;
-}
-/**
- * Supplementary information that can be added to any segment depending on the
- * tranport logic used.
- * Called "private" as it won't be read or exploited by any code in the core
- * logic of the player. That information is only here to be retrieved and
- * exploited by the corresponding transport logic when loading or parsing the
- * corresponding segment.
- */
-export interface IPrivateInfos {
-    /** Smooth-specific information allowing to generate an initialization segment. */
-    smoothInitSegment?: ISmoothInitSegmentPrivateInfos;
-    /** Smooth-specific information linked to all Smooth media segments. */
-    smoothMediaSegment?: ISmoothMediaSegmentPrivateInfos;
-    /** Information that should be present on all MetaPlaylist segments. */
-    metaplaylistInfos?: IMetaPlaylistPrivateInfos;
-    /**
-     * Local Manifest-specific information allowing to request the
-     * initialization segment.
-     */
-    localManifestInitSegment?: ILocalManifestInitSegmentPrivateInfos;
-    /** Local Manifest-specific information allowing to request any media segment. */
-    localManifestSegment?: ILocalManifestSegmentPrivateInfos;
-    /**
-     * Function allowing to know if a given emsg's event name has been
-     * explicitely authorized.
-     */
-    isEMSGWhitelisted?: (evt: IEMSG) => boolean;
-}
-/** Represent a single Segment from a Representation. */
-export interface ISegment {
-    /** ID of the Segment. Should be unique for this Representation. */
-    id: string;
-    /**
-     * If true, this segment is an initialization segment with no decodable data.
-     *
-     * Those types of segment contain no decodable data and are only there for
-     * initialization purposes, such as giving initial infos to the decoder on
-     * subsequent media segments that will be pushed.
-     *
-     * Note that if `isInit` is false, it only means that the segment contains
-     * decodable media, it can also contain important initialization information.
-     *
-     * Also, a segment which would contain both all initialization data and the
-     * decodable data would have `isInit` set to `false` as it is not purely an
-     * initialization segment.
-     *
-     * Segments which are not purely an initialization segments are called "media
-     * segments" in the code.
-     */
-    isInit: boolean;
-    /**
-     * Store supplementary information on a segment that can be later exploited by
-     * the transport logic.
-     */
-    privateInfos: IPrivateInfos;
-    /**
-     * Estimated time, in seconds, at which the concerned segment should be
-     * offseted when decoded.
-     */
-    timestampOffset?: number | undefined;
-    /**
-     * Estimated start time for the segment, in seconds.
-     * Note that some rounding errors and some differences between what the
-     * Manifest says and what the content really is might make that time not
-     * exact.
-     *
-     * `0` for initialization segments.
-     */
-    time: number;
-    /**
-     * Estimated end time for the segment, in seconds.
-     * Note that some rounding errors and some differences between what the
-     * Manifest says and what the content really is might make that time not
-     * exact.
-     *
-     * `0` for initialization segments.
-     */
-    end: number;
-    /**
-     * Estimated duration for the segment, in seconds.
-     *
-     * Note that this may not reflect the exact segment duration:
-     *
-     *   1. In some very specific cases, segments might be generated and served
-     *      progressively. In this case, the full duration of a segment might not
-     *      be yet known and thus this property only reflect the currently known
-     *      `duration` of the segment, which may be inferior to its final duration.
-     *
-     *      You can know if we're in that case when the `complete` property of
-     *      this same segment is set to `false`.
-     *
-     *   2. some rounding errors and some differences between what the
-     *      Manifest says and what the content really is might make that time not
-     *      exact.
-     *
-     * `0` for initialization segments.
-     */
-    duration: number;
-    /**
-     * Always set to 1 for API compatibility with v3.X.X.
-     * This was intended for conversion of the `time` and `duration` properties
-     * into seconds.
-     *
-     * As both are always in seconds now, this property became unneeded.
-     */
-    timescale: 1;
-    /**
-     * If `false`, this segment's `duration` property may not be the duration of
-     * the full segment as it could still be in the process of being generated
-     * on the server-side (when this `ISegment` had been constructed).
-     *
-     * Note that if the `duration` is sure to be the final one, `complete`
-     * should be set to `true` even if the segment is still being
-     * generated.
-     */
-    complete: boolean;
-    /**
-     * Optional relative or absolute URL to load the resource.
-     *
-     * If the URL is absolute (it contains the scheme at the beginning), it is the
-     * complete URL on which the resource should be requested.
-     *
-     * If the URL is relative (it does not contain a scheme at the beginning), it
-     * should be relative to the chosen CDN that should be recuperated through
-     * another mean
-     *
-     * If `null`, it means either:
-     *
-     *   - that there is no way to reach the resource through a URL.
-     *
-     *   - that there may be an URL, but is already communicated through another
-     *     mean, like the currently chosen CDN.
-     *
-     * An empty string is equivalent to indicating that the chosen CDN's URL
-     * should be directly requested instead.
-     * In that way, it is equivalent to setting it to `null`.
-     */
-    url: string | null;
-    /**
-     * Optional byte range to retrieve the Segment from its URL(s).
-     * TODO this should probably moved to `privateInfos` as this is
-     * transport-specific metadata only useful for performing requests, but it is
-     * sadly documented in the API, so moving it is actuall a v3.X.X breaking
-     * change.
-     */
-    range?: [number, number] | undefined;
-    /**
-     * If set, the corresponding byte-range in the downloaded segment will
-     * contain an index describing other Segments
-     * TODO this should probably moved to `privateInfos` as this is
-     * transport-specific metadata only useful for performing requests, but it is
-     * sadly documented in the API, so moving it is actuall a v3.X.X breaking
-     * change.
-     */
-    indexRange?: [number, number] | undefined;
-    /**
-     * Optional number of the Segment.
-     * TODO this should probably moved to `privateInfos` as this is
-     * transport-specific metadata only useful for performing requests, but it is
-     * sadly documented in the API, so moving it is actuall a v3.X.X breaking
-     * change.
-     */
-    number?: number | undefined;
-}
-/** Interface that should be implemented by any Representation's `index` value. */
-export interface IRepresentationIndex {
-    /**
-     * Returns Segment object for the initialization segment, allowing to do the
-     * Init Segment request.
-     *
-     * `null` if there's no initialization segment.
-     * @returns {Object}
-     */
-    getInitSegment(): ISegment | null;
-    /**
-     * Returns an array of Segments needed for the amount of time given.
-     * @param {number} up - The first wanted position, in seconds.
-     * @param {number} duration - The amount of time in seconds you want from the
-     * starting position given in `up`.
-     * @returns {Array.<Object>} - The list of segments corresponding to your
-     * wanted range.
-     */
-    getSegments(up: number, duration: number): ISegment[];
-    /**
-     * Returns `true` if, from the given situation, the manifest has to be
-     * refreshed.
-     * @param {number} up - Beginning time in seconds of the range that is
-     * currently wanted.
-     * @param {number} to - Ending time in seconds of the range that is
-     * currently wanted.
-     * @returns {Boolean}
-     */
-    shouldRefresh(up: number, to: number): boolean;
-    /**
-     * Returns the starting time, in seconds, of the earliest segment currently
-     * available in this index.
-     * Returns `null` if nothing is in the index
-     * Returns `undefined` if we cannot know this value.
-     * @returns {Number|null}
-     */
-    getFirstAvailablePosition(): number | null | undefined;
-    /**
-     * Returns the ending time, in seconds, of the last playable position
-     * currently available in this index.
-     * Returns `null` if nothing is in the index
-     * Returns `undefined` if we cannot know this value.
-     *
-     * The last playable position is generally equivalent to the end of the last
-     * segment associated to this index, excepted when it goes over the end limit
-     * of the corresponding `Period`, in which case it will be equal to this end
-     * instead.
-     * @returns {Number|null|undefined}
-     */
-    getLastAvailablePosition(): number | null | undefined;
-    /**
-     * Returns the ending time, in seconds, of the Representation once it is
-     * "finished" (@see isStillAwaitingFutureSegments).
-     * Should thus be equivalent to `getLastAvailablePosition` once finished.
-     *
-     * Returns `null` if nothing is in the index
-     * Returns `undefined` if we cannot know this value.
-     *
-     * @returns {number|undefined}
-     */
-    getEnd(): number | null | undefined;
-    /**
-     * Returns `true` if a Segment returned by this index is still considered
-     * available.
-     * Returns `false` if it is not available anymore.
-     * Returns `undefined` if we cannot know whether it is still available or not.
-     * @param {Object} segment
-     * @returns {Boolean|undefined}
-     */
-    isSegmentStillAvailable(segment: ISegment): boolean | undefined;
-    /**
-     * Returns true if the `error` given following the request of `segment` can
-     * indicate that the index became "de-synchronized" with the server.
-     *
-     * Reasons for de-synchronizations includes for example Manifest parsing
-     * optimizations where a newer version will not be totally parsed. In those
-     * conditions, we could be left with doing a segment request for a segment
-     * that does not really exists.
-     *
-     * Note: This API assumes that the user first checked that the segment is
-     * still available through `isSegmentStillAvailable`.
-     * @param {Error} error
-     * @param {Object} segment
-     * @returns {Boolean}
-     */
-    canBeOutOfSyncError(error: IPlayerError, segment: ISegment): boolean;
-    /**
-     * Checks if the given time - in seconds - is in a discontinuity.
-     * That is a "hole" in the stream with no segment defined.
-     * If that's the case, return the next available position where a segment
-     * should be available.
-     * If that's not the case, return `null`.
-     * @param {number} time - The time to check if it's in a discontinuity, in
-     * seconds.
-     * @returns {number | null} - If `null`, no discontinuity is encountered at
-     * `time`. If this is a number instead, there is one and that number is the
-     * position for which a segment is available in seconds.
-     */
-    checkDiscontinuity(time: number): number | null;
-    /**
-     * Returns `false` if the last segments in this index have already been
-     * generated so that we can freely go to the next period.
-     * Returns `true` if the index is still waiting on future segments to be
-     * generated.
-     * @returns {boolean}
-     */
-    isStillAwaitingFutureSegments(): boolean;
-    /**
-     * Returns `true` if this index has all the data it needs to give the list
-     * of available segments.
-     * Returns `false` if you first should load its initialization segment (or
-     * the initialization segment's associated index file) to get the list of
-     * available segments.
-     *
-     * Most index don't rely on the initialization segment to give an index and
-     * as such, this method should return `true` directly.
-     *
-     * However in some index, the segment list might only be known after the
-     * initialization has been loaded and parsed. In those case, it should return
-     * `false` until the corresponding segment list is known, at which point you
-     * can call the `initialize` method with that list so the `isInitialized` can
-     * return `true`.
-     * @returns {boolean}
-     */
-    isInitialized(): boolean;
-    awaitSegmentBetween(start: number, end: number): boolean | undefined;
-    /**
-     * Some `RepresentationIndex` do not have the list of media segments known in
-     * advance.
-     * Instead, those are only known once the initialization segment is loaded and
-     * parsed.
-     *
-     * Such `RepresentationIndex` whose list of media segments is still unknown
-     * are called "uninitialized". You can know if a `RepresentationIndex` is
-     * uninitialized by checking if its `isInitialized` method returns `false`.
-     *
-     * To initialize those `RepresentationIndex` and thus be able to obtain the
-     * list of its linked media segments through its corresponding methods, you
-     * have to initialize it with the list of segments once it is known
-     * (presumably, after parsing the initialization segment) by giving them to
-     * this `initialize` method.
-     * @param {Array.<Object>} segmentList
-     */
-    initialize(segmentList: ISegmentInformation[]): void;
-    /**
-     * Returns an approximate for the duration of that `RepresentationIndex`s
-     * segments, in seconds in the context of its Manifest (i.e. as the Manifest
-     * anounces them, actual segment duration may be different due to
-     * approximations), with the exception of the last one (that usually is
-     * shorter).
-     * @returns {number}
-     */
-    getTargetSegmentDuration(): {
-        /** Approximate duration of any segments but the last one in seconds. */
-        duration: number;
-        /**
-         * If `true`, the given duration should be relatively precize for all
-         * segments but the last one.
-         *
-         * If `false`, `duration` indicates only a general idea of what can be
-         * expected.
-         */
-        isPrecize: boolean;
-    } | undefined;
-    /**
-     * Add segments to a RepresentationIndex that were predicted after parsing the
-     * segment linked to `currentSegment`.
-     * @param {Array.<Object>} nextSegments - The segment information parsed.
-     * @param {Object} segment - Information on the segment which contained that
-     * new segment information.
-     */
-    addPredictedSegments(nextSegments: ISegmentInformation[], currentSegment: ISegment): void;
-    /**
-     * Replace the index with another one, such as after a Manifest update.
-     * @param {Object} newIndex
-     */
-    _replace(newIndex: IRepresentationIndex): void;
-    /**
-     * Update the current index with a new, partial, version.
-     * Unlike `replace`, this method do not completely overwrite the information
-     * about this index's segments, it should mainly add new information about new
-     * announced segments.
-     * @param {Object} newIndex
-     */
-    _update(newIndex: IRepresentationIndex): void;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/es2017/manifest/classes/representation_index/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/manifest/classes/representation_index/types.ts"],"names":[],"mappings":"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"}

package/dist/es2017/manifest/classes/representation_index/types.js

@@ -1,16 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-export {};

package/dist/es2017/manifest/classes/types.d.ts

@@ -1,30 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/** Enumerate the different ways a Manifest update can be done. */
-export declare enum MANIFEST_UPDATE_TYPE {
-    /**
-     * Manifest is updated entirely thanks to a re-downloaded version of
-     * the original manifest document.
-     */
-    Full = 0,
-    /**
-     * Manifest is updated partially thanks to a shortened version
-     * of the manifest document. The latter's URL might be different
-     * from the original one.
-     */
-    Partial = 1
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/es2017/manifest/classes/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/manifest/classes/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,kEAAkE;AAClE,oBAAY,oBAAoB;IAC9B;;;OAGG;IACH,IAAI,IAAA;IACJ;;;;OAIG;IACH,OAAO,IAAA;CACR"}

package/dist/es2017/manifest/classes/types.js

@@ -1,30 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/** Enumerate the different ways a Manifest update can be done. */
-export var MANIFEST_UPDATE_TYPE;
-(function (MANIFEST_UPDATE_TYPE) {
-    /**
-     * Manifest is updated entirely thanks to a re-downloaded version of
-     * the original manifest document.
-     */
-    MANIFEST_UPDATE_TYPE[MANIFEST_UPDATE_TYPE["Full"] = 0] = "Full";
-    /**
-     * Manifest is updated partially thanks to a shortened version
-     * of the manifest document. The latter's URL might be different
-     * from the original one.
-     */
-    MANIFEST_UPDATE_TYPE[MANIFEST_UPDATE_TYPE["Partial"] = 1] = "Partial";
-})(MANIFEST_UPDATE_TYPE || (MANIFEST_UPDATE_TYPE = {}));

package/dist/es2017/manifest/classes/update_period_in_place.d.ts

@@ -1,63 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import type { IAdaptationMetadata, IRepresentationMetadata } from "../../manifest";
-import type { ITrackType } from "../../public_types";
-import type { IThumbnailTrackMetadata } from "../types";
-import type Period from "./period";
-import { MANIFEST_UPDATE_TYPE } from "./types";
-/**
- * Update oldPeriod attributes with the one from newPeriod (e.g. when updating
- * the Manifest).
- * @param {Object} oldPeriod
- * @param {Object} newPeriod
- * @param {number} updateType
- * @returns {Object}
- */
-export default function updatePeriodInPlace(oldPeriod: Period, newPeriod: Period, updateType: MANIFEST_UPDATE_TYPE): IUpdatedPeriodResult;
-/**
- * Object describing the updates performed by `updatePeriodInPlace` on a single
- * Period.
- */
-export interface IUpdatedPeriodResult {
-    /** Information on Adaptations that have been updated. */
-    updatedAdaptations: Array<{
-        trackType: ITrackType;
-        /** The concerned Adaptation. */
-        adaptation: string;
-        /** Representations that have been updated. */
-        updatedRepresentations: IRepresentationMetadata[];
-        /** Representations that have been removed from the Adaptation. */
-        removedRepresentations: string[];
-        /** Representations that have been added to the Adaptation. */
-        addedRepresentations: IRepresentationMetadata[];
-    }>;
-    /** Adaptation that have been removed from the Period. */
-    removedAdaptations: Array<{
-        id: string;
-        trackType: ITrackType;
-    }>;
-    /** Adaptation that have been added to the Period. */
-    addedAdaptations: IAdaptationMetadata[];
-    /** Information on Thumbnail Tracks that have been updated. */
-    updatedThumbnailTracks: IThumbnailTrackMetadata[];
-    /** Thumbnail tracks that have been removed from the Period. */
-    removedThumbnailTracks: Array<{
-        id: string;
-    }>;
-    /** Thumbnail tracks that have been added to the Period. */
-    addedThumbnailTracks: IThumbnailTrackMetadata[];
-}
-//# sourceMappingURL=update_period_in_place.d.ts.map

package/dist/es2017/manifest/classes/update_period_in_place.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"update_period_in_place.d.ts","sourceRoot":"","sources":["../../../../src/manifest/classes/update_period_in_place.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACnF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AACxD,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,CACzC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,oBAAoB,GAC/B,oBAAoB,CAgLtB;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,yDAAyD;IACzD,kBAAkB,EAAE,KAAK,CAAC;QACxB,SAAS,EAAE,UAAU,CAAC;QACtB,gCAAgC;QAChC,UAAU,EAAE,MAAM,CAAC;QACnB,8CAA8C;QAC9C,sBAAsB,EAAE,uBAAuB,EAAE,CAAC;QAClD,kEAAkE;QAClE,sBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,8DAA8D;QAC9D,oBAAoB,EAAE,uBAAuB,EAAE,CAAC;KACjD,CAAC,CAAC;IACH,yDAAyD;IACzD,kBAAkB,EAAE,KAAK,CAAC;QACxB,EAAE,EAAE,MAAM,CAAC;QACX,SAAS,EAAE,UAAU,CAAC;KACvB,CAAC,CAAC;IACH,qDAAqD;IACrD,gBAAgB,EAAE,mBAAmB,EAAE,CAAC;IAExC,8DAA8D;IAC9D,sBAAsB,EAAE,uBAAuB,EAAE,CAAC;IAClD,+DAA+D;IAC/D,sBAAsB,EAAE,KAAK,CAAC;QAC5B,EAAE,EAAE,MAAM,CAAC;KACZ,CAAC,CAAC;IACH,2DAA2D;IAC3D,oBAAoB,EAAE,uBAAuB,EAAE,CAAC;CACjD"}