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

package/dist/_esm5.processed/parsers/manifest/dash/js-parser/node_parsers/MPD.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,26 +14,28 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import parseBaseURL from "./BaseURL";
-import { createPeriodIntermediateRepresentation, } from "./Period";
-import { parseDateTime, parseDuration, parseScheme, ValueParser, } from "./utils";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMPDIntermediateRepresentation = void 0;
+const BaseURL_1 = require("./BaseURL");
+const Period_1 = require("./Period");
+const utils_1 = require("./utils");
 /**
  * Parse children of the MPD's root into a simple object.
  * @param {NodeList} mpdChildren
  * @returns {Array.<Object>}
  */
 function parseMPDChildren(mpdChildren) {
-    var baseURLs = [];
-    var locations = [];
-    var periods = [];
-    var utcTimings = [];
-    var warnings = [];
-    for (var i = 0; i < mpdChildren.length; i++) {
+    const baseURLs = [];
+    const locations = [];
+    const periods = [];
+    const utcTimings = [];
+    let warnings = [];
+    for (let i = 0; i < mpdChildren.length; i++) {
         if (mpdChildren[i].nodeType === Node.ELEMENT_NODE) {
-            var currentNode = mpdChildren[i];
+            const currentNode = mpdChildren[i];
             switch (currentNode.nodeName) {
                 case "BaseURL":
-                    var _a = parseBaseURL(currentNode), baseURLObj = _a[0], baseURLWarnings = _a[1];
+                    const [baseURLObj, baseURLWarnings] = (0, BaseURL_1.default)(currentNode);
                     if (baseURLObj !== undefined) {
                         baseURLs.push(baseURLObj);
                     }
@@ -44,18 +47,18 @@ function parseMPDChildren(mpdChildren) {
                         currentNode.textContent);
                     break;
                 case "Period":
-                    var _b = createPeriodIntermediateRepresentation(currentNode), period = _b[0], periodWarnings = _b[1];
+                    const [period, periodWarnings] = (0, Period_1.createPeriodIntermediateRepresentation)(currentNode);
                     periods.push(period);
                     warnings = warnings.concat(periodWarnings);
                     break;
                 case "UTCTiming":
-                    var utcTiming = parseScheme(currentNode);
+                    const utcTiming = (0, utils_1.parseScheme)(currentNode);
                     utcTimings.push(utcTiming);
                     break;
             }
         }
     }
-    return [{ baseURLs: baseURLs, locations: locations, periods: periods, utcTimings: utcTimings },
+    return [{ baseURLs, locations, periods, utcTimings },
         warnings];
 }
 /**
@@ -63,11 +66,11 @@ function parseMPDChildren(mpdChildren) {
  * @returns {Array.<Object>}
  */
 function parseMPDAttributes(root) {
-    var res = {};
-    var warnings = [];
-    var parseValue = ValueParser(res, warnings);
-    for (var i = 0; i < root.attributes.length; i++) {
-        var attribute = root.attributes[i];
+    const res = {};
+    const warnings = [];
+    const parseValue = (0, utils_1.ValueParser)(res, warnings);
+    for (let i = 0; i < root.attributes.length; i++) {
+        const attribute = root.attributes[i];
         switch (attribute.name) {
             case "id":
                 res.id = attribute.value;
@@ -80,52 +83,52 @@ function parseMPDAttributes(root) {
                 break;
             case "availabilityStartTime":
                 parseValue(attribute.value, { asKey: "availabilityStartTime",
-                    parser: parseDateTime,
+                    parser: utils_1.parseDateTime,
                     dashName: "availabilityStartTime" });
                 break;
             case "availabilityEndTime":
                 parseValue(attribute.value, { asKey: "availabilityEndTime",
-                    parser: parseDateTime,
+                    parser: utils_1.parseDateTime,
                     dashName: "availabilityEndTime" });
                 break;
             case "publishTime":
                 parseValue(attribute.value, { asKey: "publishTime",
-                    parser: parseDateTime,
+                    parser: utils_1.parseDateTime,
                     dashName: "publishTime" });
                 break;
             case "mediaPresentationDuration":
                 parseValue(attribute.value, { asKey: "duration",
-                    parser: parseDuration,
+                    parser: utils_1.parseDuration,
                     dashName: "mediaPresentationDuration" });
                 break;
             case "minimumUpdatePeriod":
                 parseValue(attribute.value, { asKey: "minimumUpdatePeriod",
-                    parser: parseDuration,
+                    parser: utils_1.parseDuration,
                     dashName: "minimumUpdatePeriod" });
                 break;
             case "minBufferTime":
                 parseValue(attribute.value, { asKey: "minBufferTime",
-                    parser: parseDuration,
+                    parser: utils_1.parseDuration,
                     dashName: "minBufferTime" });
                 break;
             case "timeShiftBufferDepth":
                 parseValue(attribute.value, { asKey: "timeShiftBufferDepth",
-                    parser: parseDuration,
+                    parser: utils_1.parseDuration,
                     dashName: "timeShiftBufferDepth" });
                 break;
             case "suggestedPresentationDelay":
                 parseValue(attribute.value, { asKey: "suggestedPresentationDelay",
-                    parser: parseDuration,
+                    parser: utils_1.parseDuration,
                     dashName: "suggestedPresentationDelay" });
                 break;
             case "maxSegmentDuration":
                 parseValue(attribute.value, { asKey: "maxSegmentDuration",
-                    parser: parseDuration,
+                    parser: utils_1.parseDuration,
                     dashName: "maxSegmentDuration" });
                 break;
             case "maxSubsegmentDuration":
                 parseValue(attribute.value, { asKey: "maxSubsegmentDuration",
-                    parser: parseDuration,
+                    parser: utils_1.parseDuration,
                     dashName: "maxSubsegmentDuration" });
                 break;
         }
@@ -136,9 +139,10 @@ function parseMPDAttributes(root) {
  * @param {Element} root
  * @returns {Array.<Object>}
  */
-export function createMPDIntermediateRepresentation(root) {
-    var _a = parseMPDChildren(root.childNodes), children = _a[0], childrenWarnings = _a[1];
-    var _b = parseMPDAttributes(root), attributes = _b[0], attrsWarnings = _b[1];
-    var warnings = childrenWarnings.concat(attrsWarnings);
-    return [{ children: children, attributes: attributes }, warnings];
+function createMPDIntermediateRepresentation(root) {
+    const [children, childrenWarnings] = parseMPDChildren(root.childNodes);
+    const [attributes, attrsWarnings] = parseMPDAttributes(root);
+    const warnings = childrenWarnings.concat(attrsWarnings);
+    return [{ children, attributes }, warnings];
 }
+exports.createMPDIntermediateRepresentation = createMPDIntermediateRepresentation;

package/dist/_esm5.processed/parsers/manifest/dash/js-parser/node_parsers/Period.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,44 +14,46 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { createAdaptationSetIntermediateRepresentation, } from "./AdaptationSet";
-import parseBaseURL from "./BaseURL";
-import parseEventStream from "./EventStream";
-import parseSegmentTemplate from "./SegmentTemplate";
-import { parseBoolean, parseDuration, ValueParser, } from "./utils";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPeriodIntermediateRepresentation = void 0;
+const AdaptationSet_1 = require("./AdaptationSet");
+const BaseURL_1 = require("./BaseURL");
+const EventStream_1 = require("./EventStream");
+const SegmentTemplate_1 = require("./SegmentTemplate");
+const utils_1 = require("./utils");
 /**
  * @param {NodeList} periodChildren
  * @returns {Array}
  */
 function parsePeriodChildren(periodChildren) {
-    var baseURLs = [];
-    var adaptations = [];
-    var segmentTemplate;
-    var warnings = [];
-    var eventStreams = [];
-    for (var i = 0; i < periodChildren.length; i++) {
+    const baseURLs = [];
+    const adaptations = [];
+    let segmentTemplate;
+    let warnings = [];
+    const eventStreams = [];
+    for (let i = 0; i < periodChildren.length; i++) {
         if (periodChildren[i].nodeType === Node.ELEMENT_NODE) {
-            var currentElement = periodChildren[i];
+            const currentElement = periodChildren[i];
             switch (currentElement.nodeName) {
                 case "BaseURL":
-                    var _a = parseBaseURL(currentElement), baseURLObj = _a[0], baseURLWarnings = _a[1];
+                    const [baseURLObj, baseURLWarnings] = (0, BaseURL_1.default)(currentElement);
                     if (baseURLObj !== undefined) {
                         baseURLs.push(baseURLObj);
                     }
                     warnings = warnings.concat(baseURLWarnings);
                     break;
                 case "AdaptationSet":
-                    var _b = createAdaptationSetIntermediateRepresentation(currentElement), adaptation = _b[0], adaptationWarnings = _b[1];
+                    const [adaptation, adaptationWarnings] = (0, AdaptationSet_1.createAdaptationSetIntermediateRepresentation)(currentElement);
                     adaptations.push(adaptation);
                     warnings = warnings.concat(adaptationWarnings);
                     break;
                 case "EventStream":
-                    var _c = parseEventStream(currentElement), eventStream = _c[0], eventStreamWarnings = _c[1];
+                    const [eventStream, eventStreamWarnings] = (0, EventStream_1.default)(currentElement);
                     eventStreams.push(eventStream);
                     warnings = warnings.concat(eventStreamWarnings);
                     break;
                 case "SegmentTemplate":
-                    var _d = parseSegmentTemplate(currentElement), parsedSegmentTemplate = _d[0], segmentTemplateWarnings = _d[1];
+                    const [parsedSegmentTemplate, segmentTemplateWarnings] = (0, SegmentTemplate_1.default)(currentElement);
                     segmentTemplate = parsedSegmentTemplate;
                     if (segmentTemplateWarnings.length > 0) {
                         warnings = warnings.concat(segmentTemplateWarnings);
@@ -59,35 +62,35 @@ function parsePeriodChildren(periodChildren) {
             }
         }
     }
-    return [{ baseURLs: baseURLs, adaptations: adaptations, eventStreams: eventStreams, segmentTemplate: segmentTemplate }, warnings];
+    return [{ baseURLs, adaptations, eventStreams, segmentTemplate }, warnings];
 }
 /**
  * @param {Element} periodElement
  * @returns {Array}
  */
 function parsePeriodAttributes(periodElement) {
-    var res = {};
-    var warnings = [];
-    var parseValue = ValueParser(res, warnings);
-    for (var i = 0; i < periodElement.attributes.length; i++) {
-        var attr = periodElement.attributes[i];
+    const res = {};
+    const warnings = [];
+    const parseValue = (0, utils_1.ValueParser)(res, warnings);
+    for (let i = 0; i < periodElement.attributes.length; i++) {
+        const attr = periodElement.attributes[i];
         switch (attr.name) {
             case "id":
                 res.id = attr.value;
                 break;
             case "start":
                 parseValue(attr.value, { asKey: "start",
-                    parser: parseDuration,
+                    parser: utils_1.parseDuration,
                     dashName: "start" });
                 break;
             case "duration":
                 parseValue(attr.value, { asKey: "duration",
-                    parser: parseDuration,
+                    parser: utils_1.parseDuration,
                     dashName: "duration" });
                 break;
             case "bitstreamSwitching":
                 parseValue(attr.value, { asKey: "bitstreamSwitching",
-                    parser: parseBoolean,
+                    parser: utils_1.parseBoolean,
                     dashName: "bitstreamSwitching" });
                 break;
             case "xlink:href":
@@ -104,9 +107,10 @@ function parsePeriodAttributes(periodElement) {
  * @param {Element} periodElement
  * @returns {Array}
  */
-export function createPeriodIntermediateRepresentation(periodElement) {
-    var _a = parsePeriodChildren(periodElement.childNodes), children = _a[0], childrenWarnings = _a[1];
-    var _b = parsePeriodAttributes(periodElement), attributes = _b[0], attrsWarnings = _b[1];
-    var warnings = childrenWarnings.concat(attrsWarnings);
-    return [{ children: children, attributes: attributes }, warnings];
+function createPeriodIntermediateRepresentation(periodElement) {
+    const [children, childrenWarnings] = parsePeriodChildren(periodElement.childNodes);
+    const [attributes, attrsWarnings] = parsePeriodAttributes(periodElement);
+    const warnings = childrenWarnings.concat(attrsWarnings);
+    return [{ children, attributes }, warnings];
 }
+exports.createPeriodIntermediateRepresentation = createPeriodIntermediateRepresentation;

package/dist/_esm5.processed/parsers/manifest/dash/js-parser/node_parsers/Representation.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,28 +14,30 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import parseBaseURL from "./BaseURL";
-import parseContentProtection from "./ContentProtection";
-import parseSegmentBase from "./SegmentBase";
-import parseSegmentList from "./SegmentList";
-import parseSegmentTemplate from "./SegmentTemplate";
-import { MPDError, parseBoolean, parseMaybeDividedNumber, parseMPDFloat, parseMPDInteger, parseScheme, ValueParser, } from "./utils";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRepresentationIntermediateRepresentation = void 0;
+const BaseURL_1 = require("./BaseURL");
+const ContentProtection_1 = require("./ContentProtection");
+const SegmentBase_1 = require("./SegmentBase");
+const SegmentList_1 = require("./SegmentList");
+const SegmentTemplate_1 = require("./SegmentTemplate");
+const utils_1 = require("./utils");
 /**
  * @param {NodeList} representationChildren
  * @returns {Object}
  */
 function parseRepresentationChildren(representationChildren) {
-    var children = {
+    const children = {
         baseURLs: [],
     };
-    var contentProtections = [];
-    var warnings = [];
-    for (var i = 0; i < representationChildren.length; i++) {
+    const contentProtections = [];
+    let warnings = [];
+    for (let i = 0; i < representationChildren.length; i++) {
         if (representationChildren[i].nodeType === Node.ELEMENT_NODE) {
-            var currentElement = representationChildren[i];
+            const currentElement = representationChildren[i];
             switch (currentElement.nodeName) {
                 case "BaseURL":
-                    var _a = parseBaseURL(currentElement), baseURLObj = _a[0], baseURLWarnings = _a[1];
+                    const [baseURLObj, baseURLWarnings] = (0, BaseURL_1.default)(currentElement);
                     if (baseURLObj !== undefined) {
                         children.baseURLs.push(baseURLObj);
                     }
@@ -44,27 +47,27 @@ function parseRepresentationChildren(representationChildren) {
                     if (children.inbandEventStreams === undefined) {
                         children.inbandEventStreams = [];
                     }
-                    children.inbandEventStreams.push(parseScheme(currentElement));
+                    children.inbandEventStreams.push((0, utils_1.parseScheme)(currentElement));
                     break;
                 case "SegmentBase":
-                    var _b = parseSegmentBase(currentElement), segmentBase = _b[0], segmentBaseWarnings = _b[1];
+                    const [segmentBase, segmentBaseWarnings] = (0, SegmentBase_1.default)(currentElement);
                     children.segmentBase = segmentBase;
                     if (segmentBaseWarnings.length > 0) {
                         warnings = warnings.concat(segmentBaseWarnings);
                     }
                     break;
                 case "SegmentList":
-                    var _c = parseSegmentList(currentElement), segmentList = _c[0], segmentListWarnings = _c[1];
+                    const [segmentList, segmentListWarnings] = (0, SegmentList_1.default)(currentElement);
                     warnings = warnings.concat(segmentListWarnings);
                     children.segmentList = segmentList;
                     break;
                 case "SegmentTemplate":
-                    var _d = parseSegmentTemplate(currentElement), segmentTemplate = _d[0], segmentTemplateWarnings = _d[1];
+                    const [segmentTemplate, segmentTemplateWarnings] = (0, SegmentTemplate_1.default)(currentElement);
                     warnings = warnings.concat(segmentTemplateWarnings);
                     children.segmentTemplate = segmentTemplate;
                     break;
                 case "ContentProtection":
-                    var _e = parseContentProtection(currentElement), contentProtection = _e[0], contentProtectionWarnings = _e[1];
+                    const [contentProtection, contentProtectionWarnings] = (0, ContentProtection_1.default)(currentElement);
                     if (contentProtectionWarnings.length > 0) {
                         warnings = warnings.concat(contentProtectionWarnings);
                     }
@@ -74,10 +77,10 @@ function parseRepresentationChildren(representationChildren) {
                     break;
                 case "SupplementalProperty":
                     if (children.supplementalProperties == null) {
-                        children.supplementalProperties = [parseScheme(currentElement)];
+                        children.supplementalProperties = [(0, utils_1.parseScheme)(currentElement)];
                     }
                     else {
-                        children.supplementalProperties.push(parseScheme(currentElement));
+                        children.supplementalProperties.push((0, utils_1.parseScheme)(currentElement));
                     }
                     break;
             }
@@ -93,18 +96,18 @@ function parseRepresentationChildren(representationChildren) {
  * @returns {Array}
  */
 function parseRepresentationAttributes(representationElement) {
-    var attributes = {};
-    var warnings = [];
-    var parseValue = ValueParser(attributes, warnings);
-    for (var i = 0; i < representationElement.attributes.length; i++) {
-        var attr = representationElement.attributes[i];
+    const attributes = {};
+    const warnings = [];
+    const parseValue = (0, utils_1.ValueParser)(attributes, warnings);
+    for (let i = 0; i < representationElement.attributes.length; i++) {
+        const attr = representationElement.attributes[i];
         switch (attr.name) {
             case "audioSamplingRate":
                 attributes.audioSamplingRate = attr.value;
                 break;
             case "bandwidth":
                 parseValue(attr.value, { asKey: "bitrate",
-                    parser: parseMPDInteger,
+                    parser: utils_1.parseMPDInteger,
                     dashName: "bandwidth" });
                 break;
             case "codecs":
@@ -112,17 +115,17 @@ function parseRepresentationAttributes(representationElement) {
                 break;
             case "codingDependency":
                 parseValue(attr.value, { asKey: "codingDependency",
-                    parser: parseBoolean,
+                    parser: utils_1.parseBoolean,
                     dashName: "codingDependency" });
                 break;
             case "frameRate":
                 parseValue(attr.value, { asKey: "frameRate",
-                    parser: parseMaybeDividedNumber,
+                    parser: utils_1.parseMaybeDividedNumber,
                     dashName: "frameRate" });
                 break;
             case "height":
                 parseValue(attr.value, { asKey: "height",
-                    parser: parseMPDInteger,
+                    parser: utils_1.parseMPDInteger,
                     dashName: "height" });
                 break;
             case "id":
@@ -130,12 +133,12 @@ function parseRepresentationAttributes(representationElement) {
                 break;
             case "maxPlayoutRate":
                 parseValue(attr.value, { asKey: "maxPlayoutRate",
-                    parser: parseMPDFloat,
+                    parser: utils_1.parseMPDFloat,
                     dashName: "maxPlayoutRate" });
                 break;
             case "maximumSAPPeriod":
                 parseValue(attr.value, { asKey: "maximumSAPPeriod",
-                    parser: parseMPDFloat,
+                    parser: utils_1.parseMPDFloat,
                     dashName: "maximumSAPPeriod" });
                 break;
             case "mimeType":
@@ -146,7 +149,7 @@ function parseRepresentationAttributes(representationElement) {
                 break;
             case "qualityRanking":
                 parseValue(attr.value, { asKey: "qualityRanking",
-                    parser: parseMPDInteger,
+                    parser: utils_1.parseMPDInteger,
                     dashName: "qualityRanking" });
                 break;
             case "segmentProfiles":
@@ -154,23 +157,23 @@ function parseRepresentationAttributes(representationElement) {
                 break;
             case "width":
                 parseValue(attr.value, { asKey: "width",
-                    parser: parseMPDInteger,
+                    parser: utils_1.parseMPDInteger,
                     dashName: "width" });
                 break;
             case "availabilityTimeOffset":
                 parseValue(attr.value, { asKey: "availabilityTimeOffset",
-                    parser: parseMPDFloat,
+                    parser: utils_1.parseMPDFloat,
                     dashName: "availabilityTimeOffset" });
                 break;
             case "availabilityTimeComplete":
                 parseValue(attr.value, { asKey: "availabilityTimeComplete",
-                    parser: parseBoolean,
+                    parser: utils_1.parseBoolean,
                     dashName: "availabilityTimeComplete" });
                 break;
         }
     }
     if (attributes.bitrate === undefined) {
-        warnings.push(new MPDError("No bitrate found on a Representation"));
+        warnings.push(new utils_1.MPDError("No bitrate found on a Representation"));
     }
     return [attributes, warnings];
 }
@@ -178,9 +181,10 @@ function parseRepresentationAttributes(representationElement) {
  * @param {Element} representationElement
  * @returns {Array}
  */
-export function createRepresentationIntermediateRepresentation(representationElement) {
-    var _a = parseRepresentationChildren(representationElement.childNodes), children = _a[0], childrenWarnings = _a[1];
-    var _b = parseRepresentationAttributes(representationElement), attributes = _b[0], attrsWarnings = _b[1];
-    var warnings = childrenWarnings.concat(attrsWarnings);
-    return [{ children: children, attributes: attributes }, warnings];
+function createRepresentationIntermediateRepresentation(representationElement) {
+    const [children, childrenWarnings] = parseRepresentationChildren(representationElement.childNodes);
+    const [attributes, attrsWarnings] = parseRepresentationAttributes(representationElement);
+    const warnings = childrenWarnings.concat(attrsWarnings);
+    return [{ children, attributes }, warnings];
 }
+exports.createRepresentationIntermediateRepresentation = createRepresentationIntermediateRepresentation;

package/dist/_esm5.processed/parsers/manifest/dash/js-parser/node_parsers/SegmentBase.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,77 +14,79 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import parseInitialization from "./Initialization";
-import { parseBoolean, parseByteRange, parseMPDFloat, parseMPDInteger, ValueParser, } from "./utils";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Initialization_1 = require("./Initialization");
+const utils_1 = require("./utils");
 /**
  * Parse a SegmentBase element into a SegmentBase intermediate representation.
  * @param {Element} root - The SegmentBase root element.
  * @returns {Array}
  */
-export default function parseSegmentBase(root) {
-    var attributes = {};
-    var warnings = [];
-    var parseValue = ValueParser(attributes, warnings);
-    var segmentBaseChildren = root.childNodes;
-    for (var i = 0; i < segmentBaseChildren.length; i++) {
+function parseSegmentBase(root) {
+    const attributes = {};
+    let warnings = [];
+    const parseValue = (0, utils_1.ValueParser)(attributes, warnings);
+    const segmentBaseChildren = root.childNodes;
+    for (let i = 0; i < segmentBaseChildren.length; i++) {
         if (segmentBaseChildren[i].nodeType === Node.ELEMENT_NODE) {
-            var currentNode = segmentBaseChildren[i];
+            const currentNode = segmentBaseChildren[i];
             if (currentNode.nodeName === "Initialization") {
-                var _a = parseInitialization(currentNode), initialization = _a[0], initializationWarnings = _a[1];
+                const [initialization, initializationWarnings] = (0, Initialization_1.default)(currentNode);
                 attributes.initialization = initialization;
                 warnings = warnings.concat(initializationWarnings);
             }
         }
     }
-    for (var i = 0; i < root.attributes.length; i++) {
-        var attr = root.attributes[i];
+    for (let i = 0; i < root.attributes.length; i++) {
+        const attr = root.attributes[i];
         switch (attr.name) {
             case "timescale":
                 parseValue(attr.value, { asKey: "timescale",
-                    parser: parseMPDInteger,
+                    parser: utils_1.parseMPDInteger,
                     dashName: "timescale" });
                 break;
             case "presentationTimeOffset":
                 parseValue(attr.value, { asKey: "presentationTimeOffset",
-                    parser: parseMPDFloat,
+                    parser: utils_1.parseMPDFloat,
                     dashName: "presentationTimeOffset" });
                 break;
             case "indexRange":
                 parseValue(attr.value, { asKey: "indexRange",
-                    parser: parseByteRange,
+                    parser: utils_1.parseByteRange,
                     dashName: "indexRange" });
                 break;
             case "indexRangeExact":
                 parseValue(attr.value, { asKey: "indexRangeExact",
-                    parser: parseBoolean,
+                    parser: utils_1.parseBoolean,
                     dashName: "indexRangeExact" });
                 break;
             case "availabilityTimeOffset":
                 parseValue(attr.value, { asKey: "availabilityTimeOffset",
-                    parser: parseMPDFloat,
+                    parser: utils_1.parseMPDFloat,
                     dashName: "availabilityTimeOffset" });
                 break;
             case "availabilityTimeComplete":
                 parseValue(attr.value, { asKey: "availabilityTimeComplete",
-                    parser: parseBoolean,
+                    parser: utils_1.parseBoolean,
                     dashName: "availabilityTimeComplete" });
                 break;
             case "duration":
                 parseValue(attr.value, { asKey: "duration",
-                    parser: parseMPDInteger,
+                    parser: utils_1.parseMPDInteger,
                     dashName: "duration" });
                 break;
             case "startNumber":
                 parseValue(attr.value, { asKey: "startNumber",
-                    parser: parseMPDInteger,
+                    parser: utils_1.parseMPDInteger,
                     dashName: "startNumber" });
                 break;
             case "endNumber":
                 parseValue(attr.value, { asKey: "endNumber",
-                    parser: parseMPDInteger,
+                    parser: utils_1.parseMPDInteger,
                     dashName: "endNumber" });
                 break;
         }
     }
     return [attributes, warnings];
 }
+exports.default = parseSegmentBase;

package/dist/_esm5.processed/parsers/manifest/dash/js-parser/node_parsers/SegmentList.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,28 +14,30 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import objectAssign from "../../../../../utils/object_assign";
-import parseSegmentBase from "./SegmentBase";
-import parseSegmentURL from "./SegmentURL";
+Object.defineProperty(exports, "__esModule", { value: true });
+const object_assign_1 = require("../../../../../utils/object_assign");
+const SegmentBase_1 = require("./SegmentBase");
+const SegmentURL_1 = require("./SegmentURL");
 /**
  * @param {Element} root
  * @returns {Array}
  */
-export default function parseSegmentList(root) {
-    var _a = parseSegmentBase(root), base = _a[0], baseWarnings = _a[1];
-    var warnings = baseWarnings;
-    var list = [];
-    var segmentListChildren = root.childNodes;
-    for (var i = 0; i < segmentListChildren.length; i++) {
+function parseSegmentList(root) {
+    const [base, baseWarnings] = (0, SegmentBase_1.default)(root);
+    let warnings = baseWarnings;
+    const list = [];
+    const segmentListChildren = root.childNodes;
+    for (let i = 0; i < segmentListChildren.length; i++) {
         if (segmentListChildren[i].nodeType === Node.ELEMENT_NODE) {
-            var currentNode = segmentListChildren[i];
+            const currentNode = segmentListChildren[i];
             if (currentNode.nodeName === "SegmentURL") {
-                var _b = parseSegmentURL(currentNode), segmentURL = _b[0], segmentURLWarnings = _b[1];
+                const [segmentURL, segmentURLWarnings] = (0, SegmentURL_1.default)(currentNode);
                 list.push(segmentURL);
                 warnings = warnings.concat(segmentURLWarnings);
             }
         }
     }
-    var ret = objectAssign(base, { list: list });
+    const ret = (0, object_assign_1.default)(base, { list });
     return [ret, warnings];
 }
+exports.default = parseSegmentList;