rx-player 4.0.0-dev.202402213 → 4.0.0-dev.2024022300

package/dist/es2017/parsers/manifest/dash/fast-js-parser/node_parsers/Representation.js

@@ -0,0 +1,214 @@
+/**
+ * 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";
+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";
+/**
+ * @param {Array.<Object | string>} representationChildren
+ * @returns {Object}
+ */
+function parseRepresentationChildren(representationChildren) {
+    const children = {
+        baseURLs: [],
+    };
+    const contentProtections = [];
+    let warnings = [];
+    for (let i = 0; i < representationChildren.length; i++) {
+        const currentElement = representationChildren[i];
+        if (typeof currentElement === "string") {
+            continue;
+        }
+        switch (currentElement.tagName) {
+            case "BaseURL":
+                const [baseURLObj, baseURLWarnings] = parseBaseURL(currentElement);
+                if (baseURLObj !== undefined) {
+                    children.baseURLs.push(baseURLObj);
+                }
+                warnings = warnings.concat(baseURLWarnings);
+                break;
+            case "InbandEventStream":
+                if (children.inbandEventStreams === undefined) {
+                    children.inbandEventStreams = [];
+                }
+                children.inbandEventStreams.push(parseScheme(currentElement));
+                break;
+            case "SegmentBase":
+                const [segmentBase, segmentBaseWarnings] = parseSegmentBase(currentElement);
+                children.segmentBase = segmentBase;
+                if (segmentBaseWarnings.length > 0) {
+                    warnings = warnings.concat(segmentBaseWarnings);
+                }
+                break;
+            case "SegmentList":
+                const [segmentList, segmentListWarnings] = parseSegmentList(currentElement);
+                warnings = warnings.concat(segmentListWarnings);
+                children.segmentList = segmentList;
+                break;
+            case "SegmentTemplate":
+                const [segmentTemplate, segmentTemplateWarnings] = parseSegmentTemplate(currentElement);
+                warnings = warnings.concat(segmentTemplateWarnings);
+                children.segmentTemplate = segmentTemplate;
+                break;
+            case "ContentProtection":
+                const [contentProtection, contentProtectionWarnings] = parseContentProtection(currentElement);
+                if (contentProtectionWarnings.length > 0) {
+                    warnings = warnings.concat(contentProtectionWarnings);
+                }
+                if (contentProtection !== undefined) {
+                    contentProtections.push(contentProtection);
+                }
+                break;
+            case "SupplementalProperty":
+                if (isNullOrUndefined(children.supplementalProperties)) {
+                    children.supplementalProperties = [parseScheme(currentElement)];
+                }
+                else {
+                    children.supplementalProperties.push(parseScheme(currentElement));
+                }
+                break;
+        }
+    }
+    if (contentProtections.length > 0) {
+        children.contentProtections = contentProtections;
+    }
+    return [children, warnings];
+}
+/**
+ * @param {Object} root
+ * @returns {Array}
+ */
+function parseRepresentationAttributes(root) {
+    const attributes = {};
+    const warnings = [];
+    const parseValue = ValueParser(attributes, warnings);
+    for (const attributeName of Object.keys(root.attributes)) {
+        const attributeVal = root.attributes[attributeName];
+        if (isNullOrUndefined(attributeVal)) {
+            continue;
+        }
+        switch (attributeName) {
+            case "audioSamplingRate":
+                attributes.audioSamplingRate = attributeVal;
+                break;
+            case "bandwidth":
+                parseValue(attributeVal, {
+                    asKey: "bitrate",
+                    parser: parseMPDInteger,
+                    dashName: "bandwidth",
+                });
+                break;
+            case "codecs":
+                attributes.codecs = attributeVal;
+                break;
+            case "codingDependency":
+                parseValue(attributeVal, {
+                    asKey: "codingDependency",
+                    parser: parseBoolean,
+                    dashName: "codingDependency",
+                });
+                break;
+            case "frameRate":
+                parseValue(attributeVal, {
+                    asKey: "frameRate",
+                    parser: parseMaybeDividedNumber,
+                    dashName: "frameRate",
+                });
+                break;
+            case "height":
+                parseValue(attributeVal, {
+                    asKey: "height",
+                    parser: parseMPDInteger,
+                    dashName: "height",
+                });
+                break;
+            case "id":
+                attributes.id = attributeVal;
+                break;
+            case "maxPlayoutRate":
+                parseValue(attributeVal, {
+                    asKey: "maxPlayoutRate",
+                    parser: parseMPDFloat,
+                    dashName: "maxPlayoutRate",
+                });
+                break;
+            case "maximumSAPPeriod":
+                parseValue(attributeVal, {
+                    asKey: "maximumSAPPeriod",
+                    parser: parseMPDFloat,
+                    dashName: "maximumSAPPeriod",
+                });
+                break;
+            case "mimeType":
+                attributes.mimeType = attributeVal;
+                break;
+            case "profiles":
+                attributes.profiles = attributeVal;
+                break;
+            case "qualityRanking":
+                parseValue(attributeVal, {
+                    asKey: "qualityRanking",
+                    parser: parseMPDInteger,
+                    dashName: "qualityRanking",
+                });
+                break;
+            case "scte214:supplementalCodecs":
+                attributes.supplementalCodecs = attributeVal;
+                break;
+            case "segmentProfiles":
+                attributes.segmentProfiles = attributeVal;
+                break;
+            case "width":
+                parseValue(attributeVal, {
+                    asKey: "width",
+                    parser: parseMPDInteger,
+                    dashName: "width",
+                });
+                break;
+            case "availabilityTimeOffset":
+                parseValue(attributeVal, {
+                    asKey: "availabilityTimeOffset",
+                    parser: parseMPDFloat,
+                    dashName: "availabilityTimeOffset",
+                });
+                break;
+            case "availabilityTimeComplete":
+                parseValue(attributeVal, {
+                    asKey: "availabilityTimeComplete",
+                    parser: parseBoolean,
+                    dashName: "availabilityTimeComplete",
+                });
+                break;
+        }
+    }
+    if (attributes.bitrate === undefined) {
+        warnings.push(new MPDError("No bitrate found on a Representation"));
+    }
+    return [attributes, warnings];
+}
+/**
+ * @param {Object} representationElement
+ * @returns {Array}
+ */
+export function createRepresentationIntermediateRepresentation(representationElement) {
+    const [children, childrenWarnings] = parseRepresentationChildren(representationElement.children);
+    const [attributes, attrsWarnings] = parseRepresentationAttributes(representationElement);
+    const warnings = childrenWarnings.concat(attrsWarnings);
+    return [{ children, attributes }, warnings];
+}

package/dist/es2017/parsers/manifest/dash/fast-js-parser/node_parsers/SegmentBase.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { ITNode } from "../../../../../utils/xml-parser";
+import type { ISegmentBaseIntermediateRepresentation } from "../../node_parser_types";
+/**
+ * Parse a SegmentBase element into a SegmentBase intermediate representation.
+ * @param {Object} root - The SegmentBase root element.
+ * @returns {Array}
+ */
+export default function parseSegmentBase(root: ITNode): [ISegmentBaseIntermediateRepresentation, Error[]];

package/dist/es2017/parsers/manifest/dash/fast-js-parser/node_parsers/SegmentBase.js

@@ -0,0 +1,111 @@
+/**
+ * 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";
+import parseInitialization from "./Initialization";
+import { parseBoolean, parseByteRange, parseMPDFloat, parseMPDInteger, ValueParser, } from "./utils";
+/**
+ * Parse a SegmentBase element into a SegmentBase intermediate representation.
+ * @param {Object} root - The SegmentBase root element.
+ * @returns {Array}
+ */
+export default function parseSegmentBase(root) {
+    const attributes = {};
+    let warnings = [];
+    const parseValue = ValueParser(attributes, warnings);
+    const segmentBaseChildren = root.children;
+    for (let i = 0; i < segmentBaseChildren.length; i++) {
+        const currentNode = segmentBaseChildren[i];
+        if (typeof currentNode !== "string") {
+            if (currentNode.tagName === "Initialization") {
+                const [initialization, initializationWarnings] = parseInitialization(currentNode);
+                attributes.initialization = initialization;
+                warnings = warnings.concat(initializationWarnings);
+            }
+        }
+    }
+    for (const attributeName of Object.keys(root.attributes)) {
+        const attributeVal = root.attributes[attributeName];
+        if (isNullOrUndefined(attributeVal)) {
+            continue;
+        }
+        switch (attributeName) {
+            case "timescale":
+                parseValue(attributeVal, {
+                    asKey: "timescale",
+                    parser: parseMPDInteger,
+                    dashName: "timescale",
+                });
+                break;
+            case "presentationTimeOffset":
+                parseValue(attributeVal, {
+                    asKey: "presentationTimeOffset",
+                    parser: parseMPDFloat,
+                    dashName: "presentationTimeOffset",
+                });
+                break;
+            case "indexRange":
+                parseValue(attributeVal, {
+                    asKey: "indexRange",
+                    parser: parseByteRange,
+                    dashName: "indexRange",
+                });
+                break;
+            case "indexRangeExact":
+                parseValue(attributeVal, {
+                    asKey: "indexRangeExact",
+                    parser: parseBoolean,
+                    dashName: "indexRangeExact",
+                });
+                break;
+            case "availabilityTimeOffset":
+                parseValue(attributeVal, {
+                    asKey: "availabilityTimeOffset",
+                    parser: parseMPDFloat,
+                    dashName: "availabilityTimeOffset",
+                });
+                break;
+            case "availabilityTimeComplete":
+                parseValue(attributeVal, {
+                    asKey: "availabilityTimeComplete",
+                    parser: parseBoolean,
+                    dashName: "availabilityTimeComplete",
+                });
+                break;
+            case "duration":
+                parseValue(attributeVal, {
+                    asKey: "duration",
+                    parser: parseMPDInteger,
+                    dashName: "duration",
+                });
+                break;
+            case "startNumber":
+                parseValue(attributeVal, {
+                    asKey: "startNumber",
+                    parser: parseMPDInteger,
+                    dashName: "startNumber",
+                });
+                break;
+            case "endNumber":
+                parseValue(attributeVal, {
+                    asKey: "endNumber",
+                    parser: parseMPDInteger,
+                    dashName: "endNumber",
+                });
+                break;
+        }
+    }
+    return [attributes, warnings];
+}

package/dist/es2017/parsers/manifest/dash/fast-js-parser/node_parsers/SegmentList.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { ITNode } from "../../../../../utils/xml-parser";
+import type { ISegmentListIntermediateRepresentation } from "../../node_parser_types";
+/**
+ * @param {Object} root
+ * @returns {Array}
+ */
+export default function parseSegmentList(root: ITNode): [ISegmentListIntermediateRepresentation, Error[]];

package/dist/es2017/parsers/manifest/dash/fast-js-parser/node_parsers/SegmentList.js

@@ -0,0 +1,41 @@
+/**
+ * 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 objectAssign from "../../../../../utils/object_assign";
+import parseSegmentBase from "./SegmentBase";
+import parseSegmentURL from "./SegmentURL";
+/**
+ * @param {Object} root
+ * @returns {Array}
+ */
+export default function parseSegmentList(root) {
+    const [base, baseWarnings] = parseSegmentBase(root);
+    let warnings = baseWarnings;
+    const list = [];
+    const segmentListChildren = root.children;
+    for (let i = 0; i < segmentListChildren.length; i++) {
+        const currentNode = segmentListChildren[i];
+        if (typeof currentNode === "string") {
+            continue;
+        }
+        if (currentNode.tagName === "SegmentURL") {
+            const [segmentURL, segmentURLWarnings] = parseSegmentURL(currentNode);
+            list.push(segmentURL);
+            warnings = warnings.concat(segmentURLWarnings);
+        }
+    }
+    const ret = objectAssign(base, { list });
+    return [ret, warnings];
+}

package/dist/es2017/parsers/manifest/dash/fast-js-parser/node_parsers/SegmentTemplate.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { ITNode } from "../../../../../utils/xml-parser";
+import type { ISegmentTemplateIntermediateRepresentation } from "../../node_parser_types";
+/**
+ * Parse a SegmentTemplate element into a SegmentTemplate intermediate
+ * representation.
+ * @param {Object} root - The SegmentTemplate root element.
+ * @returns {Array}
+ */
+export default function parseSegmentTemplate(root: ITNode): [ISegmentTemplateIntermediateRepresentation, Error[]];

package/dist/es2017/parsers/manifest/dash/fast-js-parser/node_parsers/SegmentTemplate.js

@@ -0,0 +1,84 @@
+/**
+ * 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";
+import objectAssign from "../../../../../utils/object_assign";
+import parseSegmentBase from "./SegmentBase";
+import createSegmentTimelineParser from "./SegmentTimeline";
+import { parseBoolean, parseMPDFloat, ValueParser } from "./utils";
+/**
+ * Parse a SegmentTemplate element into a SegmentTemplate intermediate
+ * representation.
+ * @param {Object} root - The SegmentTemplate root element.
+ * @returns {Array}
+ */
+export default function parseSegmentTemplate(root) {
+    const [base, segmentBaseWarnings] = parseSegmentBase(root);
+    const warnings = segmentBaseWarnings;
+    let timelineParser;
+    // First look for a possible SegmentTimeline
+    for (let i = 0; i < root.children.length; i++) {
+        const currentNode = root.children[i];
+        if (typeof currentNode !== "string" && currentNode.tagName === "SegmentTimeline") {
+            timelineParser = createSegmentTimelineParser(currentNode);
+        }
+    }
+    const ret = objectAssign({}, base, {
+        duration: base.duration,
+        timelineParser,
+    });
+    const parseValue = ValueParser(ret, warnings);
+    for (const attributeName of Object.keys(root.attributes)) {
+        const attributeVal = root.attributes[attributeName];
+        if (isNullOrUndefined(attributeVal)) {
+            continue;
+        }
+        switch (attributeName) {
+            case "initialization":
+                if (isNullOrUndefined(ret.initialization)) {
+                    ret.initialization = { media: attributeVal };
+                }
+                break;
+            case "index":
+                ret.index = attributeVal;
+                break;
+            case "availabilityTimeOffset":
+                parseValue(attributeVal, {
+                    asKey: "availabilityTimeOffset",
+                    parser: parseMPDFloat,
+                    dashName: "availabilityTimeOffset",
+                });
+                break;
+            case "availabilityTimeComplete":
+                parseValue(attributeVal, {
+                    asKey: "availabilityTimeComplete",
+                    parser: parseBoolean,
+                    dashName: "availabilityTimeComplete",
+                });
+                break;
+            case "media":
+                ret.media = attributeVal;
+                break;
+            case "bitstreamSwitching":
+                parseValue(attributeVal, {
+                    asKey: "bitstreamSwitching",
+                    parser: parseBoolean,
+                    dashName: "bitstreamSwitching",
+                });
+                break;
+        }
+    }
+    return [ret, warnings];
+}

package/dist/es2017/parsers/manifest/dash/fast-js-parser/node_parsers/SegmentTimeline.d.ts

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

package/dist/es2017/parsers/manifest/dash/fast-js-parser/node_parsers/SegmentTimeline.js

@@ -0,0 +1,33 @@
+/**
+ * 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.
+ */
+/**
+ * @param {Object} root
+ * @returns {Function}
+ */
+export default function createSegmentTimelineParser(root) {
+    const result = root.children;
+    return function () {
+        // In the great majority of cases, there's only `S` elements inside.
+        // However still clean-up just in rare occasions when that's not the case.
+        for (let i = result.length - 1; i >= 0; i--) {
+            const item = result[i];
+            if (typeof item === "string" || item.tagName !== "S") {
+                result.splice(i, 1);
+            }
+        }
+        return result;
+    };
+}

package/dist/es2017/parsers/manifest/dash/fast-js-parser/node_parsers/SegmentURL.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { ITNode } from "../../../../../utils/xml-parser";
+import type { ISegmentUrlIntermediateRepresentation } from "../../node_parser_types";
+/**
+ * Parse a SegmentURL element into a SegmentURL intermediate
+ * representation.
+ * @param {Object} root - The SegmentURL root element.
+ * @returns {Array}
+ */
+export default function parseSegmentURL(root: ITNode): [ISegmentUrlIntermediateRepresentation, Error[]];

package/dist/es2017/parsers/manifest/dash/fast-js-parser/node_parsers/SegmentURL.js

@@ -0,0 +1,57 @@
+/**
+ * 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";
+import { parseByteRange, ValueParser } from "./utils";
+/**
+ * Parse a SegmentURL element into a SegmentURL intermediate
+ * representation.
+ * @param {Object} root - The SegmentURL root element.
+ * @returns {Array}
+ */
+export default function parseSegmentURL(root) {
+    const parsedSegmentURL = {};
+    const warnings = [];
+    const parseValue = ValueParser(parsedSegmentURL, warnings);
+    for (const attributeName of Object.keys(root.attributes)) {
+        const attributeVal = root.attributes[attributeName];
+        if (isNullOrUndefined(attributeVal)) {
+            continue;
+        }
+        switch (attributeName) {
+            case "media":
+                parsedSegmentURL.media = attributeVal;
+                break;
+            case "indexRange":
+                parseValue(attributeVal, {
+                    asKey: "indexRange",
+                    parser: parseByteRange,
+                    dashName: "indexRange",
+                });
+                break;
+            case "index":
+                parsedSegmentURL.index = attributeVal;
+                break;
+            case "mediaRange":
+                parseValue(attributeVal, {
+                    asKey: "mediaRange",
+                    parser: parseByteRange,
+                    dashName: "mediaRange",
+                });
+                break;
+        }
+    }
+    return [parsedSegmentURL, warnings];
+}