rx-player 3.25.2 → 3.26.3-dev.2022021400

package/dist/_esm5.processed/parsers/manifest/dash/wasm-parser/ts/generators/EventStream.js

@@ -33,6 +33,11 @@ export function generateEventStreamChildrenParser(childrenObj, linearMemory, par
                 parsersStack.pushParsers(nodeId, noop, attrParser);
                 break;
             }
+            default:
+                // Allows to make sure we're not mistakenly closing a re-opened
+                // tag.
+                parsersStack.pushParsers(nodeId, noop, noop);
+                break;
         }
     };
 }
@@ -57,6 +62,23 @@ export function generateEventStreamAttrParser(esAttrs, linearMemory) {
             case 27 /* TimeScale */:
                 esAttrs.timescale = dataView.getFloat64(ptr, true);
                 break;
+            case 70 /* Namespace */:
+                var xmlNs = { key: "", value: "" };
+                var offset = ptr;
+                var keySize = dataView.getUint32(offset);
+                offset += 4;
+                xmlNs.key = parseString(textDecoder, linearMemory.buffer, offset, keySize);
+                offset += keySize;
+                var valSize = dataView.getUint32(offset);
+                offset += 4;
+                xmlNs.value = parseString(textDecoder, linearMemory.buffer, offset, valSize);
+                if (esAttrs.namespaces === undefined) {
+                    esAttrs.namespaces = [xmlNs];
+                }
+                else {
+                    esAttrs.namespaces.push(xmlNs);
+                }
+                break;
         }
     };
 }

package/dist/_esm5.processed/parsers/manifest/dash/wasm-parser/ts/generators/MPD.js

@@ -56,6 +56,11 @@ export function generateMPDChildrenParser(mpdChildren, linearMemory, parsersStac
                 parsersStack.pushParsers(nodeId, childrenParser, attributeParser);
                 break;
             }
+            default:
+                // Allows to make sure we're not mistakenly closing a re-opened
+                // tag.
+                parsersStack.pushParsers(nodeId, noop, noop);
+                break;
         }
     };
 }
@@ -117,6 +122,24 @@ export function generateMPDAttrParser(mpdChildren, mpdAttrs, linearMemory) {
                 var location_1 = parseString(textDecoder, linearMemory.buffer, ptr, len);
                 mpdChildren.locations.push(location_1);
                 break;
+            case 70 /* Namespace */:
+                var xmlNs = { key: "", value: "" };
+                dataView = new DataView(linearMemory.buffer);
+                var offset = ptr;
+                var keySize = dataView.getUint32(offset);
+                offset += 4;
+                xmlNs.key = parseString(textDecoder, linearMemory.buffer, offset, keySize);
+                offset += keySize;
+                var valSize = dataView.getUint32(offset);
+                offset += 4;
+                xmlNs.value = parseString(textDecoder, linearMemory.buffer, offset, valSize);
+                if (mpdAttrs.namespaces === undefined) {
+                    mpdAttrs.namespaces = [xmlNs];
+                }
+                else {
+                    mpdAttrs.namespaces.push(xmlNs);
+                }
+                break;
         }
     };
 }

package/dist/_esm5.processed/parsers/manifest/dash/wasm-parser/ts/generators/Period.js

@@ -63,6 +63,11 @@ export function generatePeriodChildrenParser(periodChildren, linearMemory, parse
                 generateSegmentTemplateAttrParser(stObj, linearMemory));
                 break;
             }
+            default:
+                // Allows to make sure we're not mistakenly closing a re-opened
+                // tag.
+                parsersStack.pushParsers(nodeId, noop, noop);
+                break;
         }
     };
 }
@@ -94,6 +99,32 @@ export function generatePeriodAttrParser(periodAttrs, linearMemory) {
             case 47 /* XLinkActuate */:
                 periodAttrs.xlinkActuate = parseString(textDecoder, linearMemory.buffer, ptr, len);
                 break;
+            case 43 /* AvailabilityTimeOffset */:
+                periodAttrs.availabilityTimeOffset =
+                    new DataView(linearMemory.buffer).getFloat64(ptr, true);
+                break;
+            case 22 /* AvailabilityTimeComplete */:
+                periodAttrs.availabilityTimeComplete =
+                    new DataView(linearMemory.buffer).getUint8(0) === 0;
+                break;
+            case 70 /* Namespace */:
+                var xmlNs = { key: "", value: "" };
+                var dataView = new DataView(linearMemory.buffer);
+                var offset = ptr;
+                var keySize = dataView.getUint32(offset);
+                offset += 4;
+                xmlNs.key = parseString(textDecoder, linearMemory.buffer, offset, keySize);
+                offset += keySize;
+                var valSize = dataView.getUint32(offset);
+                offset += 4;
+                xmlNs.value = parseString(textDecoder, linearMemory.buffer, offset, valSize);
+                if (periodAttrs.namespaces === undefined) {
+                    periodAttrs.namespaces = [xmlNs];
+                }
+                else {
+                    periodAttrs.namespaces.push(xmlNs);
+                }
+                break;
         }
     };
 }

package/dist/_esm5.processed/parsers/manifest/dash/wasm-parser/ts/generators/Representation.js

@@ -16,6 +16,7 @@
 import noop from "../../../../../../utils/noop";
 import { parseString } from "../utils";
 import { generateBaseUrlAttrParser } from "./BaseURL";
+import { generateContentProtectionAttrParser } from "./ContentProtection";
 import { generateSchemeAttrParser } from "./Scheme";
 import { generateSegmentBaseAttrParser } from "./SegmentBase";
 import { generateSegmentListChildrenParser } from "./SegmentList";
@@ -36,6 +37,17 @@ export function generateRepresentationChildrenParser(childrenObj, linearMemory,
                 parsersStack.pushParsers(nodeId, noop, generateBaseUrlAttrParser(baseUrl, linearMemory));
                 break;
             }
+            case 10 /* ContentProtection */: {
+                var contentProtection = { children: { cencPssh: [] },
+                    attributes: {} };
+                if (childrenObj.contentProtections === undefined) {
+                    childrenObj.contentProtections = [];
+                }
+                childrenObj.contentProtections.push(contentProtection);
+                var contentProtAttrParser = generateContentProtectionAttrParser(contentProtection, linearMemory);
+                parsersStack.pushParsers(nodeId, noop, contentProtAttrParser);
+                break;
+            }
             case 19 /* InbandEventStream */: {
                 var inbandEvent = {};
                 if (childrenObj.inbandEventStreams === undefined) {
@@ -68,6 +80,11 @@ export function generateRepresentationChildrenParser(childrenObj, linearMemory,
                 generateSegmentTemplateAttrParser(stObj, linearMemory));
                 break;
             }
+            default:
+                // Allows to make sure we're not mistakenly closing a re-opened
+                // tag.
+                parsersStack.pushParsers(nodeId, noop, noop);
+                break;
         }
     };
 }
@@ -130,6 +147,12 @@ export function generateRepresentationAttrParser(representationAttrs, linearMemo
                 representationAttrs.segmentProfiles =
                     parseString(textDecoder, linearMemory.buffer, ptr, len);
                 break;
+            case 43 /* AvailabilityTimeOffset */:
+                representationAttrs.availabilityTimeOffset = dataView.getFloat64(ptr, true);
+                break;
+            case 22 /* AvailabilityTimeComplete */:
+                representationAttrs.availabilityTimeComplete = dataView.getUint8(0) === 0;
+                break;
         }
     };
 }

package/dist/_esm5.processed/parsers/manifest/dash/wasm-parser/ts/generators/SegmentList.js

@@ -35,6 +35,11 @@ export function generateSegmentListChildrenParser(segListChildren, linearMemory,
                 parsersStack.pushParsers(nodeId, noop, attrParser);
                 break;
             }
+            default:
+                // Allows to make sure we're not mistakenly closing a re-opened
+                // tag.
+                parsersStack.pushParsers(nodeId, noop, noop);
+                break;
         }
     };
 }

package/dist/_esm5.processed/parsers/manifest/dash/wasm-parser/ts/generators/XLink.js

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import noop from "../../../../../../utils/noop";
 import { generatePeriodAttrParser, generatePeriodChildrenParser, } from "./Period";
 /**
  * Generate a "children parser" when an XLink has been loaded.
@@ -36,6 +37,11 @@ export function generateXLinkChildrenParser(xlinkObj, linearMemory, parsersStack
                 parsersStack.pushParsers(nodeId, childrenParser, attributeParser);
                 break;
             }
+            default:
+                // Allows to make sure we're not mistakenly closing a re-opened
+                // tag.
+                parsersStack.pushParsers(nodeId, noop, noop);
+                break;
         }
     };
 }

package/dist/_esm5.processed/parsers/manifest/dash/wasm-parser/ts/generators/root.js

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import noop from "../../../../../../utils/noop";
 import { generateMPDAttrParser, generateMPDChildrenParser, } from "./MPD";
 /**
  * @param {Object} rootObj
@@ -34,6 +35,11 @@ export function generateRootChildrenParser(rootObj, linearMemory, parsersStack,
                 var attributeParser = generateMPDAttrParser(rootObj.mpd.children, rootObj.mpd.attributes, linearMemory);
                 parsersStack.pushParsers(nodeId, childrenParser, attributeParser);
                 break;
+            default:
+                // Allows to make sure we're not mistakenly closing a re-opened
+                // tag.
+                parsersStack.pushParsers(nodeId, noop, noop);
+                break;
         }
     };
 }

package/dist/_esm5.processed/parsers/manifest/dash/wasm-parser/ts/parsers_stack.js

@@ -34,8 +34,7 @@ var ParsersStack = /** @class */ (function () {
         this._currentNodeId = nodeId;
         this.childrenParser = childrenParser;
         this.attributeParser = attrParser;
-        this._stack.push({ nodeId: nodeId,
-            attribute: attrParser,
+        this._stack.push({ nodeId: nodeId, attribute: attrParser,
             children: childrenParser });
     };
     ParsersStack.prototype.popIfCurrent = function (idToPop) {
@@ -47,7 +46,6 @@ var ParsersStack = /** @class */ (function () {
         this._currentNodeId = nodeId;
         this.attributeParser = attribute;
         this.childrenParser = children;
-        return;
     };
     ParsersStack.prototype.reset = function () {
         this.childrenParser = noop;

package/dist/_esm5.processed/parsers/manifest/dash/wasm-parser/ts/types.d.ts

@@ -133,5 +133,6 @@ export declare const enum AttributeName {
     Location = 66,
     InitializationMedia = 67,
     MediaPresentationDuration = 68,
-    EventStreamEltRange = 69
+    EventStreamEltRange = 69,
+    Namespace = 70
 }

package/dist/_esm5.processed/parsers/manifest/local/parse_local_manifest.js

@@ -24,14 +24,13 @@ export default function parseLocalManifest(localManifest) {
         throw new Error("Invalid local manifest given. It misses the `type` property.");
     }
     if (localManifest.version !== "0.2") {
-        throw new Error("The current Local Manifest version (" + localManifest.version + ")" +
+        throw new Error("The current Local Manifest version (".concat(localManifest.version, ")") +
             " is not compatible with the current version of the RxPlayer");
     }
     var periodIdGenerator = idGenerator();
     var minimumPosition = localManifest.minimumPosition, maximumPosition = localManifest.maximumPosition, isFinished = localManifest.isFinished;
     var parsedPeriods = localManifest.periods
-        .map(function (period) { return parsePeriod(period, { periodIdGenerator: periodIdGenerator,
-        isFinished: isFinished }); });
+        .map(function (period) { return parsePeriod(period, { periodIdGenerator: periodIdGenerator, isFinished: isFinished }); });
     return { availabilityStartTime: 0,
         expired: localManifest.expired,
         transportType: "local",
@@ -67,8 +66,7 @@ function parsePeriod(period, ctxt) {
                 adaps = [];
                 acc[type] = adaps;
             }
-            adaps.push(parseAdaptation(ada, { adaptationIdGenerator: adaptationIdGenerator,
-                isFinished: isFinished }));
+            adaps.push(parseAdaptation(ada, { adaptationIdGenerator: adaptationIdGenerator, isFinished: isFinished }));
             return acc;
         }, {}),
     };
@@ -88,8 +86,7 @@ function parseAdaptation(adaptation, ctxt) {
         closedCaption: adaptation.closedCaption,
         language: adaptation.language,
         representations: adaptation.representations.map(function (representation) {
-            return parseRepresentation(representation, { representationIdGenerator: representationIdGenerator,
-                isFinished: isFinished });
+            return parseRepresentation(representation, { representationIdGenerator: representationIdGenerator, isFinished: isFinished });
         }),
     };
 }
@@ -103,14 +100,12 @@ function parseRepresentation(representation, ctxt) {
     var contentProtections = representation.contentProtections === undefined ?
         undefined :
         formatContentProtections(representation.contentProtections);
-    return { id: id,
-        bitrate: representation.bitrate,
+    return { id: id, bitrate: representation.bitrate,
         height: representation.height,
         width: representation.width,
         codecs: representation.codecs,
         mimeType: representation.mimeType,
-        index: new LocalRepresentationIndex(representation.index, id, isFinished),
-        contentProtections: contentProtections };
+        index: new LocalRepresentationIndex(representation.index, id, isFinished), contentProtections: contentProtections };
 }
 /**
  * Translate Local Manifest's `contentProtections` attribute to the one defined

package/dist/_esm5.processed/parsers/manifest/local/representation_index.js

@@ -13,10 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
 };
 import log from "../../../log";
 var LocalRepresentationIndex = /** @class */ (function () {
@@ -30,13 +34,14 @@ var LocalRepresentationIndex = /** @class */ (function () {
      */
     LocalRepresentationIndex.prototype.getInitSegment = function () {
         return {
-            id: this._representationId + "_init",
+            id: "".concat(this._representationId, "_init"),
             isInit: true,
             time: 0,
             end: 0,
             duration: 0,
             timescale: 1,
             mediaURLs: null,
+            complete: true,
             privateInfos: {
                 localManifestInitSegment: { load: this._index.loadInitSegment }
             },
@@ -66,7 +71,7 @@ var LocalRepresentationIndex = /** @class */ (function () {
         return wantedSegments
             .map(function (wantedSegment) {
             return {
-                id: _this._representationId + "_" + wantedSegment.time,
+                id: "".concat(_this._representationId, "_").concat(wantedSegment.time),
                 isInit: false,
                 time: wantedSegment.time,
                 end: wantedSegment.time + wantedSegment.duration,
@@ -74,6 +79,7 @@ var LocalRepresentationIndex = /** @class */ (function () {
                 timescale: 1,
                 timestampOffset: wantedSegment.timestampOffset,
                 mediaURLs: null,
+                complete: true,
                 privateInfos: {
                     localManifestSegment: { load: _this._index.loadSegment,
                         segment: wantedSegment },
@@ -155,7 +161,7 @@ var LocalRepresentationIndex = /** @class */ (function () {
         }
         var insertNewIndexAtPosition = function (pos) {
             var _a;
-            (_a = _this._index.segments).splice.apply(_a, __spreadArray([pos, oldIndexLength - pos], newSegments));
+            (_a = _this._index.segments).splice.apply(_a, __spreadArray([pos, oldIndexLength - pos], newSegments, false));
             _this._index.loadSegment = newIndex._index.loadSegment;
             _this._index.loadInitSegment = newIndex._index.loadInitSegment;
         };

package/dist/_esm5.processed/parsers/manifest/metaplaylist/metaplaylist_parser.d.ts

@@ -56,9 +56,9 @@ export interface IMetaPlaylist {
  * @returns {Object}
  */
 export default function parseMetaPlaylist(data: unknown, parserOptions: {
-    url?: string;
+    url?: string | undefined;
     serverSyncInfos?: {
         serverTimestamp: number;
         clientTime: number;
-    };
+    } | undefined;
 }): IParserResponse<IParsedManifest>;

package/dist/_esm5.processed/parsers/manifest/metaplaylist/metaplaylist_parser.js

@@ -227,21 +227,12 @@ function createManifest(mplData, manifests, parserOptions) {
         mplData.pollInterval === undefined &&
             (manifests.length <= 0 ||
                 manifests[manifests.length - 1].isLastPeriodKnown);
-    var manifest = { availabilityStartTime: 0,
-        clockOffset: clockOffset,
-        suggestedPresentationDelay: 10,
-        periods: periods,
-        transportType: "metaplaylist",
-        isLive: isDynamic,
-        isDynamic: isDynamic,
-        isLastPeriodKnown: isLastPeriodKnown,
-        uris: url == null ? [] :
+    var manifest = { availabilityStartTime: 0, clockOffset: clockOffset, suggestedPresentationDelay: 10, periods: periods, transportType: "metaplaylist",
+        isLive: isDynamic, isDynamic: isDynamic, isLastPeriodKnown: isLastPeriodKnown, uris: url == null ? [] :
             [url],
-        timeBounds: { minimumTime: minimumTime,
-            timeshiftDepth: null,
+        timeBounds: { minimumTime: minimumTime, timeshiftDepth: null,
             maximumTimeData: { isLinear: false,
-                value: maximumTime,
-                time: time } },
+                value: maximumTime, time: time } },
         lifetime: mplData.pollInterval };
     return manifest;
 }

package/dist/_esm5.processed/parsers/manifest/smooth/create_parser.d.ts

@@ -16,19 +16,19 @@
 import { IParsedManifest } from "../types";
 import { IKeySystem } from "./parse_protection_node";
 export interface IHSSParserConfiguration {
-    aggressiveMode?: boolean;
-    suggestedPresentationDelay?: number;
-    referenceDateTime?: number;
-    minRepresentationBitrate?: number;
-    keySystems?: (hex?: Uint8Array) => IKeySystem[];
+    aggressiveMode?: boolean | undefined;
+    suggestedPresentationDelay?: number | undefined;
+    referenceDateTime?: number | undefined;
+    minRepresentationBitrate?: number | undefined;
+    keySystems?: ((hex: Uint8Array | undefined) => IKeySystem[]) | undefined;
     serverSyncInfos?: {
         serverTimestamp: number;
         clientTime: number;
-    };
+    } | undefined;
 }
 /**
  * @param {Object|undefined} parserOptions
  * @returns {Function}
  */
-declare function createSmoothStreamingParser(parserOptions?: IHSSParserConfiguration): (manifest: Document, url?: string, manifestReceivedTime?: number) => IParsedManifest;
+declare function createSmoothStreamingParser(parserOptions?: IHSSParserConfiguration): (manifest: Document, url?: string | undefined, manifestReceivedTime?: number | undefined) => IParsedManifest;
 export default createSmoothStreamingParser;

package/dist/_esm5.processed/parsers/manifest/smooth/create_parser.js

@@ -165,9 +165,7 @@ function createSmoothStreamingParser(parserOptions) {
                 var bitrate = bitrateAttr === undefined ? 0 :
                     isNaN(parseInt(bitrateAttr, 10)) ? 0 :
                         parseInt(bitrateAttr, 10);
-                return { bitrate: bitrate,
-                    customAttributes: customAttributes,
-                    mimeType: fourCC !== undefined ? MIME_TYPES[fourCC] :
+                return { bitrate: bitrate, customAttributes: customAttributes, mimeType: fourCC !== undefined ? MIME_TYPES[fourCC] :
                         fourCC,
                     codecPrivateData: takeFirstSet(codecPrivateData, "") };
             }
@@ -203,7 +201,7 @@ function createSmoothStreamingParser(parserOptions) {
         var baseURLAttr = root.getAttribute("Url");
         var baseURL = baseURLAttr === null ? "" :
             baseURLAttr;
-        if (false) {
+        if (0 /* CURRENT_ENV */ === 1 /* DEV */) {
             assert(baseURL !== "");
         }
         var _a = reduceChildren(root, function (res, _name, node) {
@@ -259,8 +257,7 @@ function createSmoothStreamingParser(parserOptions) {
                 protections.forEach(function (protection) {
                     var keyId = protection.keyId;
                     protection.keySystems.forEach(function (keySystem) {
-                        keyIDs.push({ keyId: keyId,
-                            systemId: keySystem.systemId });
+                        keyIDs.push({ keyId: keyId, systemId: keySystem.systemId });
                     });
                 });
             }
@@ -277,15 +274,8 @@ function createSmoothStreamingParser(parserOptions) {
             var aggressiveMode = parserOptions.aggressiveMode == null ?
                 DEFAULT_AGGRESSIVE_MODE :
                 parserOptions.aggressiveMode;
-            var reprIndex = new RepresentationIndex(repIndex, { aggressiveMode: aggressiveMode,
-                isLive: isLive,
-                manifestReceivedTime: manifestReceivedTime,
-                segmentPrivateInfos: segmentPrivateInfos,
-                timeShiftBufferDepth: timeShiftBufferDepth });
-            var representation = objectAssign({}, qualityLevel, { index: reprIndex,
-                mimeType: mimeType,
-                codecs: codecs,
-                id: id });
+            var reprIndex = new RepresentationIndex(repIndex, { aggressiveMode: aggressiveMode, isLive: isLive, manifestReceivedTime: manifestReceivedTime, segmentPrivateInfos: segmentPrivateInfos, timeShiftBufferDepth: timeShiftBufferDepth });
+            var representation = objectAssign({}, qualityLevel, { index: reprIndex, mimeType: mimeType, codecs: codecs, id: id });
             if (keyIDs.length > 0 || firstProtection !== undefined) {
                 var initDataValues = firstProtection === undefined ?
                     [] :
@@ -310,9 +300,7 @@ function createSmoothStreamingParser(parserOptions) {
             return null;
         }
         var parsedAdaptation = { id: adaptationID,
-            type: adaptationType,
-            representations: representations,
-            language: language == null ?
+            type: adaptationType, representations: representations, language: language == null ?
                 undefined :
                 language };
         if (adaptationType === "text" && subType === "DESC") {
@@ -364,13 +352,7 @@ function createSmoothStreamingParser(parserOptions) {
         }
         var adaptations = adaptationNodes
             .reduce(function (acc, node) {
-            var adaptation = parseAdaptation({ root: node,
-                rootURL: rootURL,
-                timescale: timescale,
-                protections: protections,
-                isLive: isLive,
-                timeShiftBufferDepth: timeShiftBufferDepth,
-                manifestReceivedTime: manifestReceivedTime });
+            var adaptation = parseAdaptation({ root: node, rootURL: rootURL, timescale: timescale, protections: protections, isLive: isLive, timeShiftBufferDepth: timeShiftBufferDepth, manifestReceivedTime: manifestReceivedTime });
             if (adaptation === null) {
                 return acc;
             }
@@ -469,11 +451,8 @@ function createSmoothStreamingParser(parserOptions) {
             isLive: isLive,
             isDynamic: isLive,
             isLastPeriodKnown: true,
-            timeBounds: { absoluteMinimumTime: minimumTime,
-                timeshiftDepth: timeshiftDepth,
-                maximumTimeData: maximumTimeData },
-            periods: [{ adaptations: adaptations,
-                    duration: periodEnd !== undefined ?
+            timeBounds: { absoluteMinimumTime: minimumTime, timeshiftDepth: timeshiftDepth, maximumTimeData: maximumTimeData },
+            periods: [{ adaptations: adaptations, duration: periodEnd !== undefined ?
                         periodEnd - periodStart : duration,
                     end: periodEnd,
                     id: "gen-smooth-period-0",

package/dist/_esm5.processed/parsers/manifest/smooth/get_codecs.js

@@ -33,7 +33,7 @@ export function getAudioCodecs(codecPrivateData, fourCC) {
         // Return default audio codec
         return "mp4a.40.2";
     }
-    return "mp4a.40." + mpProfile;
+    return "mp4a.40.".concat(mpProfile);
 }
 /**
  * @param {string} codecPrivateData

package/dist/_esm5.processed/parsers/manifest/smooth/representation_index.d.ts

@@ -91,14 +91,14 @@ export interface ISmoothRepresentationIndexContextInformation {
 }
 /** Information allowing to generate a Smooth initialization segment. */
 interface ISmoothInitSegmentPrivateInfos {
-    bitsPerSample?: number;
-    channels?: number;
-    codecPrivateData?: string;
-    packetSize?: number;
-    samplingRate?: number;
+    bitsPerSample?: number | undefined;
+    channels?: number | undefined;
+    codecPrivateData?: string | undefined;
+    packetSize?: number | undefined;
+    samplingRate?: number | undefined;
     protection?: {
         keyId: Uint8Array;
-    };
+    } | undefined;
 }
 /**
  * RepresentationIndex implementation for Smooth Manifests.
@@ -131,12 +131,12 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
      * Useful to know if a segment present in the timeline has actually been
      * generated on the server-side
      */
-    private _scaledLiveGap?;
+    private _scaledLiveGap;
     /**
      * Defines the end of the latest available segment when this index was known to
      * be valid, in the index's timescale.
      */
-    private _initialScaledLastPosition?;
+    private _initialScaledLastPosition;
     /**
      * Defines the earliest time when this index was known to be valid (that is, when
      * all segments declared in it are available). This means either:

package/dist/_esm5.processed/parsers/manifest/smooth/representation_index.js

@@ -121,7 +121,8 @@ var SmoothRepresentationIndex = /** @class */ (function () {
             time: 0,
             end: 0,
             duration: 0,
-            timescale: 1 };
+            timescale: 1,
+            complete: true };
     };
     /**
      * Generate a list of Segments for a particular period of time.
@@ -162,11 +163,9 @@ var SmoothRepresentationIndex = /** @class */ (function () {
                     time: time / timescale,
                     end: (time + duration) / timescale,
                     duration: duration / timescale,
-                    timescale: 1,
-                    number: number,
-                    mediaURLs: [replaceSegmentSmoothTokens(media, time)],
-                    privateInfos: { smoothMediaSegment: { time: time,
-                            duration: duration } } };
+                    timescale: 1, number: number, mediaURLs: [replaceSegmentSmoothTokens(media, time)],
+                    complete: true,
+                    privateInfos: { smoothMediaSegment: { time: time, duration: duration } } };
                 segments.push(segment);
                 // update segment number and segment time for the next segment
                 segmentNumberInCurrentRange++;