rx-player 3.25.2 → 3.26.3-dev.2022021400

package/dist/_esm5.processed/manifest/period.js

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { isKnownError, MediaError, } from "../errors";
+import { MediaError, } from "../errors";
 import arrayFind from "../utils/array_find";
 import objectValues from "../utils/object_values";
 import Adaptation from "./adaptation";
@@ -30,7 +30,7 @@ var Period = /** @class */ (function () {
      */
     function Period(args, representationFilter) {
         var _this = this;
-        this.parsingErrors = [];
+        this.contentWarnings = [];
         this.id = args.id;
         this.adaptations = Object.keys(args.adaptations)
             .reduce(function (acc, type) {
@@ -40,24 +40,15 @@ var Period = /** @class */ (function () {
             }
             var filteredAdaptations = adaptationsForType
                 .map(function (adaptation) {
-                var _a;
-                var newAdaptation = null;
-                try {
-                    newAdaptation = new Adaptation(adaptation, { representationFilter: representationFilter });
+                var newAdaptation = new Adaptation(adaptation, { representationFilter: representationFilter });
+                if (newAdaptation.representations.length > 0 && !newAdaptation.isSupported) {
+                    var error = new MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR", "An Adaptation contains only incompatible codecs.");
+                    _this.contentWarnings.push(error);
                 }
-                catch (err) {
-                    if (isKnownError(err) &&
-                        err.code === "MANIFEST_UNSUPPORTED_ADAPTATION_TYPE") {
-                        _this.parsingErrors.push(err);
-                        return null;
-                    }
-                    throw err;
-                }
-                (_a = _this.parsingErrors).push.apply(_a, newAdaptation.parsingErrors);
                 return newAdaptation;
             })
                 .filter(function (adaptation) {
-                return adaptation !== null && adaptation.representations.length > 0;
+                return adaptation.representations.length > 0;
             });
             if (filteredAdaptations.every(function (adaptation) { return !adaptation.isSupported; }) &&
                 adaptationsForType.length > 0 &&

package/dist/_esm5.processed/manifest/representation.d.ts

@@ -23,7 +23,7 @@ import { IAdaptationType, IHDRInformation } from "./types";
  */
 declare class Representation {
     /** ID uniquely identifying the Representation in the Adaptation. */
-    readonly id: string | number;
+    readonly id: string;
     /**
      * Interface allowing to get information about segments available for this
      * Representation.
@@ -40,7 +40,7 @@ declare class Representation {
      * A string describing the codec used for this Representation.
      * undefined if we do not know.
      */
-    codec?: string;
+    codec: string | undefined;
     /**
      * A string describing the mime-type for this Representation.
      * Examples: audio/mp4, video/webm, application/mp4, text/plain
@@ -72,7 +72,7 @@ declare class Representation {
      *     Representation
      *   - if `undefined` there is no certainty on this matter
      */
-    decipherable?: boolean;
+    decipherable?: boolean | undefined;
     /** `true` if the Representation is in a supported codec, false otherwise. */
     isSupported: boolean;
     /**

package/dist/_esm5.processed/manifest/representation.js

@@ -59,7 +59,7 @@ var Representation = /** @class */ (function () {
      */
     Representation.prototype.getMimeTypeString = function () {
         var _a, _b;
-        return ((_a = this.mimeType) !== null && _a !== void 0 ? _a : "") + ";codecs=\"" + ((_b = this.codec) !== null && _b !== void 0 ? _b : "") + "\"";
+        return "".concat((_a = this.mimeType) !== null && _a !== void 0 ? _a : "", ";codecs=\"").concat((_b = this.codec) !== null && _b !== void 0 ? _b : "", "\"");
     };
     /**
      * Returns encryption initialization data linked to the given DRM's system ID.
@@ -92,9 +92,7 @@ var Representation = /** @class */ (function () {
                 if (initData.values[j].systemId.toLowerCase() === drmSystemId.toLowerCase()) {
                     if (!createdObjForType) {
                         var keyIds = (_a = this.contentProtections) === null || _a === void 0 ? void 0 : _a.keyIds.map(function (val) { return val.keyId; });
-                        filtered.push({ type: initData.type,
-                            keyIds: keyIds,
-                            values: [initData.values[j]] });
+                        filtered.push({ type: initData.type, keyIds: keyIds, values: [initData.values[j]] });
                         createdObjForType = true;
                     }
                     else {
@@ -139,9 +137,7 @@ var Representation = /** @class */ (function () {
         }
         var keyIds = (_a = this.contentProtections) === null || _a === void 0 ? void 0 : _a.keyIds.map(function (val) { return val.keyId; });
         return this.contentProtections.initData.map(function (x) {
-            return { type: x.type,
-                keyIds: keyIds,
-                values: x.values };
+            return { type: x.type, keyIds: keyIds, values: x.values };
         });
     };
     /**

package/dist/_esm5.processed/manifest/representation_index/static.js

@@ -45,6 +45,7 @@ var StaticRepresentationIndex = /** @class */ (function () {
                 time: 0,
                 end: Number.MAX_VALUE,
                 duration: Number.MAX_VALUE,
+                complete: true,
                 timescale: 1 }];
     };
     /**

package/dist/_esm5.processed/manifest/representation_index/types.d.ts

@@ -28,14 +28,14 @@ export interface ISmoothInitSegmentPrivateInfos {
      * as found in the Manifest.
      */
     timescale: number;
-    codecPrivateData?: string;
-    bitsPerSample?: number;
-    channels?: number;
-    packetSize?: number;
-    samplingRate?: number;
+    codecPrivateData?: string | undefined;
+    bitsPerSample?: number | undefined;
+    channels?: number | undefined;
+    packetSize?: number | undefined;
+    samplingRate?: number | undefined;
     protection?: {
         keyId: Uint8Array;
-    };
+    } | undefined;
 }
 /**
  * Supplementary information specific to Smooth media segments (that is, every
@@ -69,7 +69,7 @@ export interface IMetaPlaylistPrivateInfos {
     /** The segment originally created by this transport's RepresentationIndex. */
     originalSegment: ISegment;
     contentStart: number;
-    contentEnd?: number;
+    contentEnd?: number | undefined;
 }
 /**
  * Supplementary information needed for initialization segments of the "local"
@@ -99,12 +99,12 @@ export interface ILocalManifestSegmentPrivateInfos {
  * exploited by the corresponding transport logic.
  */
 export interface IPrivateInfos {
-    smoothInitSegment?: ISmoothInitSegmentPrivateInfos;
-    smoothMediaSegment?: ISmoothSegmentPrivateInfos;
-    metaplaylistInfos?: IMetaPlaylistPrivateInfos;
-    localManifestInitSegment?: ILocalManifestInitSegmentPrivateInfos;
-    localManifestSegment?: ILocalManifestSegmentPrivateInfos;
-    isEMSGWhitelisted?: (evt: IEMSG) => boolean;
+    smoothInitSegment?: ISmoothInitSegmentPrivateInfos | undefined;
+    smoothMediaSegment?: ISmoothSegmentPrivateInfos | undefined;
+    metaplaylistInfos?: IMetaPlaylistPrivateInfos | undefined;
+    localManifestInitSegment?: ILocalManifestInitSegmentPrivateInfos | undefined;
+    localManifestSegment?: ILocalManifestSegmentPrivateInfos | undefined;
+    isEMSGWhitelisted?: ((evt: IEMSG) => boolean) | undefined;
 }
 /** Represent a single Segment from a Representation. */
 export interface ISegment {
@@ -135,24 +135,24 @@ export interface ISegment {
      * contain an index describing other Segments
      * TODO put in privateInfos?
      */
-    indexRange?: [number, number];
+    indexRange?: [number, number] | undefined;
     /**
      * Optional number of the Segment
      * TODO put in privateInfos?
      */
-    number?: number;
+    number?: number | undefined;
     /**
      * Allows to store supplementary information on a segment that can be later
      * exploited by the transport logic.
      */
-    privateInfos?: IPrivateInfos;
+    privateInfos?: IPrivateInfos | undefined;
     /** Optional byte range to retrieve the Segment from its URL(s) */
-    range?: [number, number];
+    range?: [number, number] | undefined;
     /**
      * Estimated time, in seconds, at which the concerned segment should be
      * offseted when decoded.
      */
-    timestampOffset?: number;
+    timestampOffset?: number | undefined;
     /**
      * Estimated start time for the segment, in seconds.
      * Note that some rounding errors and some differences between what the
@@ -173,9 +173,20 @@ export interface ISegment {
     end: number;
     /**
      * Estimated duration 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.
+     *
+     * 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.
      */
@@ -188,6 +199,16 @@ export interface ISegment {
      * 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;
 }
 /** Interface that should be implemented by any Representation's `index` value. */
 export interface IRepresentationIndex {

package/dist/_esm5.processed/manifest/types.d.ts

@@ -36,7 +36,7 @@ export interface IHDRInformation {
      * It is used to ask to the user agent if the color depth is supported by the
      * output device.
      */
-    colorDepth?: number;
+    colorDepth?: number | undefined;
     /**
      * It is the HDR eotf. It is the transfer function having the video signal as
      * input and converting it into the linear light output of the display. The
@@ -44,12 +44,104 @@ export interface IHDRInformation {
      *
      * It may be used here to ask the MediaSource if it supported.
      */
-    eotf?: string;
+    eotf?: string | undefined;
     /**
      * It is the video color space used for encoding. An HDR content may not have
      * a wide color gamut.
      *
      * It may be used to ask about output device color space support.
      */
-    colorSpace?: string;
+    colorSpace?: string | undefined;
 }
+/** Manifest, as documented in the API documentation. */
+export interface IExposedManifest {
+    periods: IExposedPeriod[];
+    /**
+     * @deprecated
+     */
+    adaptations: {
+        audio?: IExposedAdaptation[];
+        video?: IExposedAdaptation[];
+        text?: IExposedAdaptation[];
+        image?: IExposedAdaptation[];
+    };
+    isLive: boolean;
+    transport: string;
+}
+/** Period, as documented in the API documentation. */
+export interface IExposedPeriod {
+    id: string;
+    start: number;
+    end?: number | undefined;
+    adaptations: {
+        audio?: IExposedAdaptation[];
+        video?: IExposedAdaptation[];
+        text?: IExposedAdaptation[];
+        image?: IExposedAdaptation[];
+    };
+}
+/** Adaptation (represents a track), as documented in the API documentation. */
+export interface IExposedAdaptation {
+    /** String identifying the Adaptation, unique per Period. */
+    id: string;
+    type: "video" | "audio" | "text" | "image";
+    language?: string | undefined;
+    normalizedLanguage?: string | undefined;
+    isAudioDescription?: boolean | undefined;
+    isClosedCaption?: boolean | undefined;
+    isTrickModeTrack?: boolean | undefined;
+    representations: IExposedRepresentation[];
+    getAvailableBitrates(): number[];
+}
+/** Representation (represents a quality), as documented in the API documentation. */
+export interface IExposedRepresentation {
+    /** String identifying the Representation, unique per Adaptation. */
+    id: string;
+    bitrate: number;
+    /** Codec used by the segment in that Representation. */
+    codec?: string | undefined;
+    /**
+     * Whether we are able to decrypt this Representation / unable to decrypt it or
+     * if we don't know yet:
+     *   - if `true`, it means that we know we were able to decrypt this
+     *     Representation in the current content.
+     *   - if `false`, it means that we know we were unable to decrypt this
+     *     Representation
+     *   - if `undefined` there is no certainty on this matter
+     */
+    decipherable?: boolean | undefined;
+    /**
+     * This property makes the most sense for video Representations.
+     * It defines the height of the video, in pixels.
+     */
+    height?: number | undefined;
+    /**
+     * This property makes the most sense for video Representations.
+     * It defines the height of the video, in pixels.
+     */
+    width?: number | undefined;
+    /**
+     * The represesentation frame rate for this Representation. It defines either
+     * the number of frames per second as an integer (24), or as a ratio
+     * (24000 / 1000).
+     */
+    frameRate?: string | undefined;
+    /** If the track is HDR, gives the HDR characteristics of the content */
+    hdrInfo?: IHDRInformation;
+    index: IExposedRepresentationIndex;
+}
+interface IExposedRepresentationIndex {
+    getSegments(up: number, duration: number): IExposedSegment[];
+}
+/** Segment, as documented in the API documentation. */
+export interface IExposedSegment {
+    id: string;
+    timescale: number;
+    duration?: number | undefined;
+    time: number;
+    isInit?: boolean | undefined;
+    range?: number[] | null | undefined;
+    indexRange?: number[] | null | undefined;
+    number?: number | undefined;
+}
+export {};

package/dist/_esm5.processed/manifest/update_period_in_place.js

@@ -44,7 +44,7 @@ export default function updatePeriodInPlace(oldPeriod, newPeriod, updateType) {
                 var oldRepresentation = oldRepresentations[k];
                 var newRepresentation = arrayFind(newRepresentations, function (representation) { return representation.id === oldRepresentation.id; });
                 if (newRepresentation === undefined) {
-                    log.warn("Manifest: Representation \"" + oldRepresentations[k].id + "\" " +
+                    log.warn("Manifest: Representation \"".concat(oldRepresentations[k].id, "\" ") +
                         "not found when merging.");
                 }
                 else {

package/dist/_esm5.processed/manifest/update_periods.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 { MediaError } from "../errors";
 import log from "../log";
@@ -44,7 +48,7 @@ export function replacePeriods(oldPeriods, newPeriods) {
             var periodsToInclude = newPeriods.slice(firstUnhandledPeriodIdx, i);
             var nbrOfPeriodsToRemove = j - firstUnhandledPeriodIdx;
             oldPeriods.splice.apply(oldPeriods, __spreadArray([firstUnhandledPeriodIdx,
-                nbrOfPeriodsToRemove], periodsToInclude));
+                nbrOfPeriodsToRemove], periodsToInclude, false));
             firstUnhandledPeriodIdx = i + 1;
         }
     }
@@ -68,7 +72,7 @@ export function replacePeriods(oldPeriods, newPeriods) {
  */
 export function updatePeriods(oldPeriods, newPeriods) {
     if (oldPeriods.length === 0) {
-        oldPeriods.splice.apply(oldPeriods, __spreadArray([0, 0], newPeriods));
+        oldPeriods.splice.apply(oldPeriods, __spreadArray([0, 0], newPeriods, false));
         return;
     }
     if (newPeriods.length === 0) {
@@ -103,7 +107,7 @@ export function updatePeriods(oldPeriods, newPeriods) {
         }
         if (indexOfNewPeriod < 0) {
             oldPeriods.splice.apply(oldPeriods, __spreadArray([prevIndexOfNewPeriod,
-                oldPeriods.length - prevIndexOfNewPeriod], newPeriods.slice(i, newPeriods.length)));
+                oldPeriods.length - prevIndexOfNewPeriod], newPeriods.slice(i, newPeriods.length), false));
             return;
         }
         if (indexOfNewPeriod > prevIndexOfNewPeriod) {

package/dist/_esm5.processed/manifest/{are_same_content.d.ts → utils.d.ts}

@@ -17,11 +17,8 @@ import Adaptation from "./adaptation";
 import Period from "./period";
 import Representation from "./representation";
 import { ISegment } from "./representation_index";
-/**
- * All information needed for a given chunk to know if it has the same content
- * than another chunk.
- */
-interface IBufferedChunkInfos {
+/** All information needed to identify a given segment. */
+export interface IBufferedChunkInfos {
     adaptation: Adaptation;
     period: Period;
     representation: Representation;
@@ -33,5 +30,10 @@ interface IBufferedChunkInfos {
  * @param {Object} content2
  * @returns {boolean}
  */
-export default function areSameContent(content1: IBufferedChunkInfos, content2: IBufferedChunkInfos): boolean;
-export {};
+export declare function areSameContent(content1: IBufferedChunkInfos, content2: IBufferedChunkInfos): boolean;
+/**
+ * Get string describing a given ISegment, useful for log functions.
+ * @param {Object} content
+ * @returns {string|null|undefined}
+ */
+export declare function getLoggableSegmentId(content: IBufferedChunkInfos | null | undefined): string;

package/dist/_esm5.processed/manifest/utils.js

@@ -0,0 +1,44 @@
+/**
+ * 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 isNullOrUndefined from "../utils/is_null_or_undefined";
+/**
+ * Check if two contents are the same
+ * @param {Object} content1
+ * @param {Object} content2
+ * @returns {boolean}
+ */
+export function areSameContent(content1, content2) {
+    return (content1.segment.id === content2.segment.id &&
+        content1.representation.id === content2.representation.id &&
+        content1.adaptation.id === content2.adaptation.id &&
+        content1.period.id === content2.period.id);
+}
+/**
+ * Get string describing a given ISegment, useful for log functions.
+ * @param {Object} content
+ * @returns {string|null|undefined}
+ */
+export function getLoggableSegmentId(content) {
+    if (isNullOrUndefined(content)) {
+        return "";
+    }
+    var period = content.period, adaptation = content.adaptation, representation = content.representation, segment = content.segment;
+    return "".concat(adaptation.type, " P: ").concat(period.id, " A: ").concat(adaptation.id, " ") +
+        "R: ".concat(representation.id, " S: ") +
+        (segment.isInit ? "init" :
+            segment.complete ? "".concat(segment.time, "-").concat(segment.duration) :
+                "".concat(segment.time));
+}

package/dist/_esm5.processed/minimal.js

@@ -37,8 +37,8 @@ var __extends = (this && this.__extends) || (function () {
 import Player from "./core/api";
 import { addFeatures, } from "./features";
 import logger from "./log";
-if (false) {
-    logger.setLevel("NONE");
+if (0 /* CURRENT_ENV */ === 1 /* DEV */) {
+    logger.setLevel("NONE" /* CURRENT_LEVEL */);
 }
 /**
  * Minimal Player for which you can features at will:

package/dist/_esm5.processed/parsers/containers/isobmff/get_box.d.ts

@@ -16,17 +16,26 @@
 /**
  * Returns the content of a box based on its name.
  * `null` if not found.
- * @param {Uint8Array} buf - the isobmff structure
- * @param {Number} boxName - the 4-letter 'name' of the box as a 4 bit integer
+ * @param {Uint8Array} buf - the isobmff data
+ * @param {Number} boxName - the 4-letter 'name' of the box as a 4 byte integer
  * generated from encoding the corresponding ASCII in big endian.
  * @returns {UInt8Array|null}
  */
 declare function getBoxContent(buf: Uint8Array, boxName: number): Uint8Array | null;
+/**
+ * Reads the whole ISOBMFF and returns the content of all boxes with the given
+ * name, in order.
+ * @param {Uint8Array} buf - the isobmff data
+ * @param {Number} boxName - the 4-letter 'name' of the box as a 4 byte integer
+ * generated from encoding the corresponding ASCII in big endian.
+ * @returns {Array.<Uint8Array>}
+ */
+declare function getBoxesContent(buf: Uint8Array, boxName: number): Uint8Array[];
 /**
  * Returns an ISOBMFF box - size and name included - based on its name.
  * `null` if not found.
- * @param {Uint8Array} buf - the isobmff structure
- * @param {Number} boxName - the 4-letter 'name' of the box as a 4 bit integer
+ * @param {Uint8Array} buf - the isobmff data
+ * @param {Number} boxName - the 4-letter 'name' of the box as a 4 byte integer
  * generated from encoding the corresponding ASCII in big endian.
  * @returns {UInt8Array|null}
  */
@@ -43,8 +52,8 @@ declare function getBox(buf: Uint8Array, boxName: number): Uint8Array | null;
  *      size and the name of the box.
  *   3. The first byte after the end of the box, might be equal to `buf`'s
  *      length if we're considering the last box.
- * @param {Uint8Array} buf - the isobmff structure
- * @param {Number} boxName - the 4-letter 'name' of the box as a 4 bit integer
+ * @param {Uint8Array} buf - the isobmff data
+ * @param {Number} boxName - the 4-letter 'name' of the box as a 4 byte integer
  * generated from encoding the corresponding ASCII in big endian.
  * @returns {Array.<number>|null}
  */
@@ -77,8 +86,8 @@ declare function getUuidContent(buf: Uint8Array, id1: number, id2: number, id3:
  *      length if we're considering the last box.
  *
  * `null` if no box is found.
- * @param {Uint8Array} buf - the isobmff structure
- * @param {Number} boxName - the 4-letter 'name' of the box as a 4 bit integer
+ * @param {Uint8Array} buf - the isobmff data
+ * @param {Number} boxName - the 4-letter 'name' of the box as a 4 byte integer
  * generated from encoding the corresponding ASCII in big endian.
  */
 declare function getNextBoxOffsets(buf: Uint8Array): [
@@ -86,4 +95,4 @@ declare function getNextBoxOffsets(buf: Uint8Array): [
     number,
     number
 ] | null;
-export { getBox, getBoxContent, getBoxOffsets, getNextBoxOffsets, getUuidContent, };
+export { getBox, getBoxContent, getBoxesContent, getBoxOffsets, getNextBoxOffsets, getUuidContent, };

package/dist/_esm5.processed/parsers/containers/isobmff/get_box.js

@@ -14,12 +14,13 @@
  * limitations under the License.
  */
 import log from "../../../log";
+import assert from "../../../utils/assert";
 import { be4toi, be8toi, } from "../../../utils/byte_parsing";
 /**
  * Returns the content of a box based on its name.
  * `null` if not found.
- * @param {Uint8Array} buf - the isobmff structure
- * @param {Number} boxName - the 4-letter 'name' of the box as a 4 bit integer
+ * @param {Uint8Array} buf - the isobmff data
+ * @param {Number} boxName - the 4-letter 'name' of the box as a 4 byte integer
  * generated from encoding the corresponding ASCII in big endian.
  * @returns {UInt8Array|null}
  */
@@ -28,11 +29,33 @@ function getBoxContent(buf, boxName) {
     return offsets !== null ? buf.subarray(offsets[1], offsets[2]) :
         null;
 }
+/**
+ * Reads the whole ISOBMFF and returns the content of all boxes with the given
+ * name, in order.
+ * @param {Uint8Array} buf - the isobmff data
+ * @param {Number} boxName - the 4-letter 'name' of the box as a 4 byte integer
+ * generated from encoding the corresponding ASCII in big endian.
+ * @returns {Array.<Uint8Array>}
+ */
+function getBoxesContent(buf, boxName) {
+    var ret = [];
+    var currentBuf = buf;
+    while (true) {
+        var offsets = getBoxOffsets(currentBuf, boxName);
+        if (offsets === null) {
+            return ret;
+        }
+        // Guard against a (very highly improbable) infinite loop
+        assert(offsets[2] !== 0 && currentBuf.length !== 0);
+        ret.push(currentBuf.subarray(offsets[1], offsets[2]));
+        currentBuf = currentBuf.subarray(offsets[2]);
+    }
+}
 /**
  * Returns an ISOBMFF box - size and name included - based on its name.
  * `null` if not found.
- * @param {Uint8Array} buf - the isobmff structure
- * @param {Number} boxName - the 4-letter 'name' of the box as a 4 bit integer
+ * @param {Uint8Array} buf - the isobmff data
+ * @param {Number} boxName - the 4-letter 'name' of the box as a 4 byte integer
  * generated from encoding the corresponding ASCII in big endian.
  * @returns {UInt8Array|null}
  */
@@ -53,8 +76,8 @@ function getBox(buf, boxName) {
  *      size and the name of the box.
  *   3. The first byte after the end of the box, might be equal to `buf`'s
  *      length if we're considering the last box.
- * @param {Uint8Array} buf - the isobmff structure
- * @param {Number} boxName - the 4-letter 'name' of the box as a 4 bit integer
+ * @param {Uint8Array} buf - the isobmff data
+ * @param {Number} boxName - the 4-letter 'name' of the box as a 4 byte integer
  * generated from encoding the corresponding ASCII in big endian.
  * @returns {Array.<number>|null}
  */
@@ -148,8 +171,8 @@ function getUuidContent(buf, id1, id2, id3, id4) {
  *      length if we're considering the last box.
  *
  * `null` if no box is found.
- * @param {Uint8Array} buf - the isobmff structure
- * @param {Number} boxName - the 4-letter 'name' of the box as a 4 bit integer
+ * @param {Uint8Array} buf - the isobmff data
+ * @param {Number} boxName - the 4-letter 'name' of the box as a 4 byte integer
  * generated from encoding the corresponding ASCII in big endian.
  */
 function getNextBoxOffsets(buf) {
@@ -182,4 +205,4 @@ function getNextBoxOffsets(buf) {
     }
     return [0, lastOffset, boxSize];
 }
-export { getBox, getBoxContent, getBoxOffsets, getNextBoxOffsets, getUuidContent, };
+export { getBox, getBoxContent, getBoxesContent, getBoxOffsets, getNextBoxOffsets, getUuidContent, };