rx-player 4.0.0-dev.2023092900 → 4.0.0-dev.2023102700

package/dist/_esm5.processed/transports/metaplaylist/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,9 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * /!\ This file is feature-switchable.
  * It always should be imported through the `features` object.
  */
-import MetaPlaylistPipelines from "./pipelines";
-export default MetaPlaylistPipelines;
+const pipelines_1 = require("./pipelines");
+exports.default = pipelines_1.default;

package/dist/_esm5.processed/transports/metaplaylist/manifest_loader.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,8 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import request from "../../utils/request";
-import callCustomManifestLoader from "../utils/call_custom_manifest_loader";
+Object.defineProperty(exports, "__esModule", { value: true });
+const request_1 = require("../../utils/request");
+const call_custom_manifest_loader_1 = require("../utils/call_custom_manifest_loader");
 /**
  * Manifest loader triggered if there was no custom-defined one in the API.
  * @param {string} url
@@ -25,17 +27,19 @@ function regularManifestLoader(url, loaderOptions, cancelSignal) {
     if (url === undefined) {
         throw new Error("Cannot perform HTTP(s) request. URL not known");
     }
-    return request({ url: url, responseType: "text",
-        timeout: loaderOptions.timeout, cancelSignal: cancelSignal });
+    return (0, request_1.default)({ url,
+        responseType: "text",
+        timeout: loaderOptions.timeout,
+        cancelSignal });
 }
 /**
  * Generate a manifest loader for the application
  * @param {Function} [customManifestLoader]
  * @returns {Function}
  */
-export default function generateManifestLoader(_a) {
-    var customManifestLoader = _a.customManifestLoader;
+function generateManifestLoader({ customManifestLoader }) {
     return typeof customManifestLoader !== "function" ?
         regularManifestLoader :
-        callCustomManifestLoader(customManifestLoader, regularManifestLoader);
+        (0, call_custom_manifest_loader_1.default)(customManifestLoader, regularManifestLoader);
 }
+exports.default = generateManifestLoader;

package/dist/_esm5.processed/transports/metaplaylist/pipelines.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,24 +14,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-import config from "../../config";
-import features from "../../features";
-import Manifest from "../../manifest";
-import parseMetaPlaylist from "../../parsers/manifest/metaplaylist";
-import isNullOrUndefined from "../../utils/is_null_or_undefined";
-import objectAssign from "../../utils/object_assign";
-import generateManifestLoader from "./manifest_loader";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../config");
+const features_1 = require("../../features");
+const manifest_1 = require("../../manifest");
+const metaplaylist_1 = require("../../parsers/manifest/metaplaylist");
+const is_null_or_undefined_1 = require("../../utils/is_null_or_undefined");
+const object_assign_1 = require("../../utils/object_assign");
+const manifest_loader_1 = require("./manifest_loader");
 /**
  * Get base - real - content from an offseted metaplaylist content.
  * @param {Object} mplContext
@@ -38,17 +29,21 @@ import generateManifestLoader from "./manifest_loader";
  */
 function getOriginalContext(mplContext) {
     var _a;
-    var segment = mplContext.segment;
+    const { segment } = mplContext;
     if (((_a = segment.privateInfos) === null || _a === void 0 ? void 0 : _a.metaplaylistInfos) === undefined) {
         throw new Error("MetaPlaylist: missing private infos");
     }
-    var _b = segment.privateInfos.metaplaylistInfos, isLive = _b.isLive, periodStart = _b.periodStart, periodEnd = _b.periodEnd, manifestPublishTime = _b.manifestPublishTime;
-    var originalSegment = segment.privateInfos.metaplaylistInfos.originalSegment;
+    const { isLive, periodStart, periodEnd, manifestPublishTime } = segment.privateInfos.metaplaylistInfos;
+    const { originalSegment } = segment.privateInfos.metaplaylistInfos;
     return { segment: originalSegment,
         type: mplContext.type,
         language: mplContext.language,
         mimeType: mplContext.mimeType,
-        codecs: mplContext.codecs, isLive: isLive, periodStart: periodStart, periodEnd: periodEnd, manifestPublishTime: manifestPublishTime };
+        codecs: mplContext.codecs,
+        isLive,
+        periodStart,
+        periodEnd,
+        manifestPublishTime };
 }
 /**
  * @param {Object} transports
@@ -57,15 +52,15 @@ function getOriginalContext(mplContext) {
  * @returns {Object}
  */
 function getTransportPipelines(transports, transportName, options) {
-    var initialTransport = transports[transportName];
+    const initialTransport = transports[transportName];
     if (initialTransport !== undefined) {
         return initialTransport;
     }
-    var feature = features.transports[transportName];
+    const feature = features_1.default.transports[transportName];
     if (feature === undefined) {
-        throw new Error("MetaPlaylist: Unknown transport ".concat(transportName, "."));
+        throw new Error(`MetaPlaylist: Unknown transport ${transportName}.`);
     }
-    var transport = feature(options);
+    const transport = feature(options);
     transports[transportName] = transport;
     return transport;
 }
@@ -74,53 +69,52 @@ function getTransportPipelines(transports, transportName, options) {
  * @returns {Object}
  */
 function getMetaPlaylistPrivateInfos(segment) {
-    var privateInfos = segment.privateInfos;
+    const { privateInfos } = segment;
     if ((privateInfos === null || privateInfos === void 0 ? void 0 : privateInfos.metaplaylistInfos) === undefined) {
         throw new Error("MetaPlaylist: Undefined transport for content for metaplaylist.");
     }
     return privateInfos.metaplaylistInfos;
 }
-export default function (options) {
-    var transports = {};
-    var manifestLoader = generateManifestLoader({
+function default_1(options) {
+    const transports = {};
+    const manifestLoader = (0, manifest_loader_1.default)({
         customManifestLoader: options.manifestLoader,
     });
     // remove some options that we might not want to apply to the
     // other streaming protocols used here
-    var otherTransportOptions = objectAssign({}, options, { manifestLoader: undefined });
-    var manifestPipeline = {
+    const otherTransportOptions = (0, object_assign_1.default)({}, options, { manifestLoader: undefined });
+    const manifestPipeline = {
         loadManifest: manifestLoader,
-        parseManifest: function (manifestData, parserOptions, onWarnings, cancelSignal, scheduleRequest) {
+        parseManifest(manifestData, parserOptions, onWarnings, cancelSignal, scheduleRequest) {
             var _a;
-            var url = (_a = manifestData.url) !== null && _a !== void 0 ? _a : parserOptions.originalUrl;
-            var responseData = manifestData.responseData;
-            var mplParserOptions = { url: url, serverSyncInfos: options.serverSyncInfos };
-            var parsed = parseMetaPlaylist(responseData, mplParserOptions);
+            const url = (_a = manifestData.url) !== null && _a !== void 0 ? _a : parserOptions.originalUrl;
+            const { responseData } = manifestData;
+            const mplParserOptions = { url,
+                serverSyncInfos: options.serverSyncInfos };
+            const parsed = (0, metaplaylist_1.default)(responseData, mplParserOptions);
             return handleParsedResult(parsed);
             function handleParsedResult(parsedResult) {
                 if (parsedResult.type === "done") {
-                    var warnings = [];
-                    var manifest = new Manifest(parsedResult.value, options, warnings);
-                    return Promise.resolve({ manifest: manifest, warnings: warnings });
+                    const warnings = [];
+                    const manifest = new manifest_1.default(parsedResult.value, options, warnings);
+                    return Promise.resolve({ manifest, warnings });
                 }
-                var parsedValue = parsedResult.value;
-                var loaderProms = parsedValue.ressources.map(function (resource) {
-                    var transport = getTransportPipelines(transports, resource.transportType, otherTransportOptions);
+                const parsedValue = parsedResult.value;
+                const loaderProms = parsedValue.ressources.map((resource) => {
+                    const transport = getTransportPipelines(transports, resource.transportType, otherTransportOptions);
                     return scheduleRequest(loadSubManifest)
-                        .then(function (data) {
-                        return transport.manifest.parseManifest(data, __assign(__assign({}, parserOptions), { originalUrl: resource.url }), onWarnings, cancelSignal, scheduleRequest);
-                    });
+                        .then((data) => transport.manifest.parseManifest(data, Object.assign(Object.assign({}, parserOptions), { originalUrl: resource.url }), onWarnings, cancelSignal, scheduleRequest));
                     function loadSubManifest() {
                         /*
                          * Whether a ManifestLoader's timeout should be relied on here
                          * is ambiguous.
                          */
-                        var manOpts = { timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT };
+                        const manOpts = { timeout: config_1.default.getCurrent().DEFAULT_REQUEST_TIMEOUT };
                         return transport.manifest.loadManifest(resource.url, manOpts, cancelSignal);
                     }
                 });
-                return Promise.all(loaderProms).then(function (parsedReqs) {
-                    var loadedRessources = parsedReqs.map(function (e) { return e.manifest; });
+                return Promise.all(loaderProms).then(parsedReqs => {
+                    const loadedRessources = parsedReqs.map(e => e.manifest);
                     return handleParsedResult(parsedResult.value.continue(loadedRessources));
                 });
             }
@@ -131,7 +125,7 @@ export default function (options) {
      * @returns {Object}
      */
     function getTransportPipelinesFromSegment(segment) {
-        var transportType = getMetaPlaylistPrivateInfos(segment).transportType;
+        const { transportType } = getMetaPlaylistPrivateInfos(segment);
         return getTransportPipelines(transports, transportType, otherTransportOptions);
     }
     /**
@@ -141,23 +135,23 @@ export default function (options) {
      * @returns {Object}
      */
     function offsetTimeInfos(contentOffset, contentEnd, segmentResponse) {
-        var offsetedSegmentOffset = segmentResponse.chunkOffset + contentOffset;
-        if (isNullOrUndefined(segmentResponse.chunkData)) {
+        const offsetedSegmentOffset = segmentResponse.chunkOffset + contentOffset;
+        if ((0, is_null_or_undefined_1.default)(segmentResponse.chunkData)) {
             return { chunkInfos: segmentResponse.chunkInfos,
                 chunkOffset: offsetedSegmentOffset,
                 appendWindow: [undefined, undefined] };
         }
         // clone chunkInfos
-        var chunkInfos = segmentResponse.chunkInfos, appendWindow = segmentResponse.appendWindow;
-        var offsetedChunkInfos = chunkInfos === null ? null :
-            objectAssign({}, chunkInfos);
+        const { chunkInfos, appendWindow } = segmentResponse;
+        const offsetedChunkInfos = chunkInfos === null ? null :
+            (0, object_assign_1.default)({}, chunkInfos);
         if (offsetedChunkInfos !== null) {
             offsetedChunkInfos.time += contentOffset;
         }
-        var offsetedWindowStart = appendWindow[0] !== undefined ?
+        const offsetedWindowStart = appendWindow[0] !== undefined ?
             Math.max(appendWindow[0] + contentOffset, contentOffset) :
             contentOffset;
-        var offsetedWindowEnd;
+        let offsetedWindowEnd;
         if (appendWindow[1] !== undefined) {
             offsetedWindowEnd = contentEnd !== undefined ?
                 Math.min(appendWindow[1] + contentOffset, contentEnd) :
@@ -170,64 +164,64 @@ export default function (options) {
             chunkOffset: offsetedSegmentOffset,
             appendWindow: [offsetedWindowStart, offsetedWindowEnd] };
     }
-    var audioPipeline = {
-        loadSegment: function (wantedCdn, context, loaderOptions, cancelToken, callbacks) {
-            var segment = context.segment;
-            var audio = getTransportPipelinesFromSegment(segment).audio;
-            var ogContext = getOriginalContext(context);
+    const audioPipeline = {
+        loadSegment(wantedCdn, context, loaderOptions, cancelToken, callbacks) {
+            const { segment } = context;
+            const { audio } = getTransportPipelinesFromSegment(segment);
+            const ogContext = getOriginalContext(context);
             return audio.loadSegment(wantedCdn, ogContext, loaderOptions, cancelToken, callbacks);
         },
-        parseSegment: function (loadedSegment, context, initTimescale) {
-            var segment = context.segment;
-            var _a = getMetaPlaylistPrivateInfos(segment), contentStart = _a.contentStart, contentEnd = _a.contentEnd;
-            var audio = getTransportPipelinesFromSegment(segment).audio;
-            var ogContext = getOriginalContext(context);
-            var parsed = audio.parseSegment(loadedSegment, ogContext, initTimescale);
+        parseSegment(loadedSegment, context, initTimescale) {
+            const { segment } = context;
+            const { contentStart, contentEnd } = getMetaPlaylistPrivateInfos(segment);
+            const { audio } = getTransportPipelinesFromSegment(segment);
+            const ogContext = getOriginalContext(context);
+            const parsed = audio.parseSegment(loadedSegment, ogContext, initTimescale);
             if (parsed.segmentType === "init") {
                 return parsed;
             }
-            var timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
-            return objectAssign({}, parsed, timeInfos);
+            const timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
+            return (0, object_assign_1.default)({}, parsed, timeInfos);
         },
     };
-    var videoPipeline = {
-        loadSegment: function (wantedCdn, context, loaderOptions, cancelToken, callbacks) {
-            var segment = context.segment;
-            var video = getTransportPipelinesFromSegment(segment).video;
-            var ogContext = getOriginalContext(context);
+    const videoPipeline = {
+        loadSegment(wantedCdn, context, loaderOptions, cancelToken, callbacks) {
+            const { segment } = context;
+            const { video } = getTransportPipelinesFromSegment(segment);
+            const ogContext = getOriginalContext(context);
             return video.loadSegment(wantedCdn, ogContext, loaderOptions, cancelToken, callbacks);
         },
-        parseSegment: function (loadedSegment, context, initTimescale) {
-            var segment = context.segment;
-            var _a = getMetaPlaylistPrivateInfos(segment), contentStart = _a.contentStart, contentEnd = _a.contentEnd;
-            var video = getTransportPipelinesFromSegment(segment).video;
-            var ogContext = getOriginalContext(context);
-            var parsed = video.parseSegment(loadedSegment, ogContext, initTimescale);
+        parseSegment(loadedSegment, context, initTimescale) {
+            const { segment } = context;
+            const { contentStart, contentEnd } = getMetaPlaylistPrivateInfos(segment);
+            const { video } = getTransportPipelinesFromSegment(segment);
+            const ogContext = getOriginalContext(context);
+            const parsed = video.parseSegment(loadedSegment, ogContext, initTimescale);
             if (parsed.segmentType === "init") {
                 return parsed;
             }
-            var timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
-            return objectAssign({}, parsed, timeInfos);
+            const timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
+            return (0, object_assign_1.default)({}, parsed, timeInfos);
         },
     };
-    var textTrackPipeline = {
-        loadSegment: function (wantedCdn, context, loaderOptions, cancelToken, callbacks) {
-            var segment = context.segment;
-            var text = getTransportPipelinesFromSegment(segment).text;
-            var ogContext = getOriginalContext(context);
+    const textTrackPipeline = {
+        loadSegment(wantedCdn, context, loaderOptions, cancelToken, callbacks) {
+            const { segment } = context;
+            const { text } = getTransportPipelinesFromSegment(segment);
+            const ogContext = getOriginalContext(context);
             return text.loadSegment(wantedCdn, ogContext, loaderOptions, cancelToken, callbacks);
         },
-        parseSegment: function (loadedSegment, context, initTimescale) {
-            var segment = context.segment;
-            var _a = getMetaPlaylistPrivateInfos(segment), contentStart = _a.contentStart, contentEnd = _a.contentEnd;
-            var text = getTransportPipelinesFromSegment(segment).text;
-            var ogContext = getOriginalContext(context);
-            var parsed = text.parseSegment(loadedSegment, ogContext, initTimescale);
+        parseSegment(loadedSegment, context, initTimescale) {
+            const { segment } = context;
+            const { contentStart, contentEnd } = getMetaPlaylistPrivateInfos(segment);
+            const { text } = getTransportPipelinesFromSegment(segment);
+            const ogContext = getOriginalContext(context);
+            const parsed = text.parseSegment(loadedSegment, ogContext, initTimescale);
             if (parsed.segmentType === "init") {
                 return parsed;
             }
-            var timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
-            return objectAssign({}, parsed, timeInfos);
+            const timeInfos = offsetTimeInfos(contentStart, contentEnd, parsed);
+            return (0, object_assign_1.default)({}, parsed, timeInfos);
         },
     };
     return { manifest: manifestPipeline,
@@ -235,3 +229,4 @@ export default function (options) {
         video: videoPipeline,
         text: textTrackPipeline };
 }
+exports.default = default_1;

package/dist/_esm5.processed/transports/smooth/extract_timings_infos.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,9 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import log from "../../log";
-import { getDurationFromTrun, getTRAF, } from "../../parsers/containers/isobmff";
-import { parseTfrf, parseTfxd, } from "./isobmff";
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = require("../../log");
+const isobmff_1 = require("../../parsers/containers/isobmff");
+const isobmff_2 = require("./isobmff");
 /**
  * Try to obtain time information from the given data.
  * @param {Uint8Array} data
@@ -24,24 +26,24 @@ import { parseTfrf, parseTfxd, } from "./isobmff";
  * @param {boolean} isLive
  * @returns {Object}
  */
-export default function extractTimingsInfos(data, isChunked, initTimescale, segment, isLive) {
+function extractTimingsInfos(data, isChunked, initTimescale, segment, isLive) {
     var _a;
-    var nextSegments = [];
-    var chunkInfos;
-    var tfxdSegment;
-    var tfrfSegments;
+    const nextSegments = [];
+    let chunkInfos;
+    let tfxdSegment;
+    let tfrfSegments;
     if (isLive) {
-        var traf = getTRAF(data);
+        const traf = (0, isobmff_1.getTRAF)(data);
         if (traf !== null) {
-            tfrfSegments = parseTfrf(traf);
-            tfxdSegment = parseTfxd(traf);
+            tfrfSegments = (0, isobmff_2.parseTfrf)(traf);
+            tfxdSegment = (0, isobmff_2.parseTfxd)(traf);
         }
         else {
-            log.warn("smooth: could not find traf atom");
+            log_1.default.warn("smooth: could not find traf atom");
         }
     }
     if (tfrfSegments !== undefined) {
-        for (var i = 0; i < tfrfSegments.length; i++) {
+        for (let i = 0; i < tfrfSegments.length; i++) {
             nextSegments.push({ time: tfrfSegments[i].time,
                 duration: tfrfSegments[i].duration,
                 timescale: initTimescale });
@@ -50,19 +52,22 @@ export default function extractTimingsInfos(data, isChunked, initTimescale, segm
     if (tfxdSegment !== undefined) {
         chunkInfos = { time: tfxdSegment.time / initTimescale,
             duration: tfxdSegment.duration / initTimescale };
-        return { nextSegments: nextSegments, chunkInfos: chunkInfos, scaledSegmentTime: tfxdSegment.time };
+        return { nextSegments,
+            chunkInfos,
+            scaledSegmentTime: tfxdSegment.time };
     }
     if (isChunked || !segment.complete) {
-        return { nextSegments: nextSegments, chunkInfos: null,
+        return { nextSegments,
+            chunkInfos: null,
             scaledSegmentTime: undefined };
     }
-    var segmentDuration = segment.duration * initTimescale;
+    const segmentDuration = segment.duration * initTimescale;
     // we could always make a mistake when reading a container.
     // If the estimate is too far from what the segment seems to imply, take
     // the segment infos instead.
-    var maxDecodeTimeDelta = Math.min(initTimescale * 0.9, segmentDuration / 4);
-    var trunDuration = getDurationFromTrun(data);
-    var scaledSegmentTime = ((_a = segment.privateInfos) === null || _a === void 0 ? void 0 : _a.smoothMediaSegment) !== undefined ?
+    const maxDecodeTimeDelta = Math.min(initTimescale * 0.9, segmentDuration / 4);
+    const trunDuration = (0, isobmff_1.getDurationFromTrun)(data);
+    const scaledSegmentTime = ((_a = segment.privateInfos) === null || _a === void 0 ? void 0 : _a.smoothMediaSegment) !== undefined ?
         segment.privateInfos.smoothMediaSegment.time :
         Math.round(segment.time * initTimescale);
     if (trunDuration !== undefined &&
@@ -74,5 +79,6 @@ export default function extractTimingsInfos(data, isChunked, initTimescale, segm
         chunkInfos = { time: segment.time,
             duration: segment.duration };
     }
-    return { nextSegments: nextSegments, chunkInfos: chunkInfos, scaledSegmentTime: scaledSegmentTime };
+    return { nextSegments, chunkInfos, scaledSegmentTime };
 }
+exports.default = extractTimingsInfos;

package/dist/_esm5.processed/transports/smooth/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,9 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * /!\ This file is feature-switchable.
  * It always should be imported through the `features` object.
  */
-import SmoothPipelines from "./pipelines";
-export default SmoothPipelines;
+const pipelines_1 = require("./pipelines");
+exports.default = pipelines_1.default;

package/dist/_esm5.processed/transports/smooth/is_mp4_embedded_track.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,12 +14,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Returns `true` if the given Representation refers to segments in an MP4
  * container
  * @param {Representation} representation
  * @returns {Boolean}
  */
-export default function isMP4EmbeddedTrack(mimeType) {
+function isMP4EmbeddedTrack(mimeType) {
     return typeof mimeType === "string" && mimeType.indexOf("mp4") >= 0;
 }
+exports.default = isMP4EmbeddedTrack;

package/dist/_esm5.processed/transports/smooth/isobmff/create_audio_init_segment.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,10 +14,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { createBoxWithChildren } from "../../../parsers/containers/isobmff";
-import { createENCABox, createESDSBox, createFRMABox, createMP4ABox, createSCHMBox, createSMHDBox, createSTSDBox, createTENCBox, } from "./create_boxes";
-import createInitSegment from "./create_init_segment";
-import getAacesHeader from "./get_aaces_header";
+Object.defineProperty(exports, "__esModule", { value: true });
+const isobmff_1 = require("../../../parsers/containers/isobmff");
+const create_boxes_1 = require("./create_boxes");
+const create_init_segment_1 = require("./create_init_segment");
+const get_aaces_header_1 = require("./get_aaces_header");
 /**
  * Return full audio initialization segment as Uint8Array.
  * @param {Number} timescale
@@ -30,23 +32,24 @@ import getAacesHeader from "./get_aaces_header";
  * @param {Array.<Object>} [pssList]
  * @returns {Uint8Array}
  */
-export default function createAudioInitSegment(timescale, channelsCount, sampleSize, packetSize, sampleRate, codecPrivateData, keyId) {
-    var _codecPrivateData = codecPrivateData.length === 0 ?
-        getAacesHeader(2, sampleRate, channelsCount) :
+function createAudioInitSegment(timescale, channelsCount, sampleSize, packetSize, sampleRate, codecPrivateData, keyId) {
+    const _codecPrivateData = codecPrivateData.length === 0 ?
+        (0, get_aaces_header_1.default)(2, sampleRate, channelsCount) :
         codecPrivateData;
-    var esds = createESDSBox(1, _codecPrivateData);
-    var stsd = (function () {
+    const esds = (0, create_boxes_1.createESDSBox)(1, _codecPrivateData);
+    const stsd = (() => {
         if (keyId === undefined) {
-            var mp4a = createMP4ABox(1, channelsCount, sampleSize, packetSize, sampleRate, esds);
-            return createSTSDBox([mp4a]);
+            const mp4a = (0, create_boxes_1.createMP4ABox)(1, channelsCount, sampleSize, packetSize, sampleRate, esds);
+            return (0, create_boxes_1.createSTSDBox)([mp4a]);
         }
-        var tenc = createTENCBox(1, 8, keyId);
-        var schi = createBoxWithChildren("schi", [tenc]);
-        var schm = createSCHMBox("cenc", 65536);
-        var frma = createFRMABox("mp4a");
-        var sinf = createBoxWithChildren("sinf", [frma, schm, schi]);
-        var enca = createENCABox(1, channelsCount, sampleSize, packetSize, sampleRate, esds, sinf);
-        return createSTSDBox([enca]);
+        const tenc = (0, create_boxes_1.createTENCBox)(1, 8, keyId);
+        const schi = (0, isobmff_1.createBoxWithChildren)("schi", [tenc]);
+        const schm = (0, create_boxes_1.createSCHMBox)("cenc", 65536);
+        const frma = (0, create_boxes_1.createFRMABox)("mp4a");
+        const sinf = (0, isobmff_1.createBoxWithChildren)("sinf", [frma, schm, schi]);
+        const enca = (0, create_boxes_1.createENCABox)(1, channelsCount, sampleSize, packetSize, sampleRate, esds, sinf);
+        return (0, create_boxes_1.createSTSDBox)([enca]);
     })();
-    return createInitSegment(timescale, "audio", stsd, createSMHDBox(), 0, 0);
+    return (0, create_init_segment_1.default)(timescale, "audio", stsd, (0, create_boxes_1.createSMHDBox)(), 0, 0);
 }
+exports.default = createAudioInitSegment;