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

package/dist/commonjs/parsers/manifest/dash/fast-js-parser/node_parsers/Period.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * 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.
+ */
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPeriodIntermediateRepresentation = void 0;
+var is_null_or_undefined_1 = require("../../../../../utils/is_null_or_undefined");
+var starts_with_1 = require("../../../../../utils/starts_with");
+var AdaptationSet_1 = require("./AdaptationSet");
+var BaseURL_1 = require("./BaseURL");
+var EventStream_1 = require("./EventStream");
+var SegmentTemplate_1 = require("./SegmentTemplate");
+var utils_1 = require("./utils");
+/**
+ * @param {Array.<Object | string>} periodChildren
+ * @param {string} fullMpd
+ * @returns {Array}
+ */
+function parsePeriodChildren(periodChildren, fullMpd) {
+    var baseURLs = [];
+    var adaptations = [];
+    var segmentTemplate;
+    var warnings = [];
+    var eventStreams = [];
+    for (var i = 0; i < periodChildren.length; i++) {
+        var currentElement = periodChildren[i];
+        if (typeof currentElement === "string") {
+            continue;
+        }
+        switch (currentElement.tagName) {
+            case "BaseURL":
+                var _a = __read((0, BaseURL_1.default)(currentElement), 2), baseURLObj = _a[0], baseURLWarnings = _a[1];
+                if (baseURLObj !== undefined) {
+                    baseURLs.push(baseURLObj);
+                }
+                warnings = warnings.concat(baseURLWarnings);
+                break;
+            case "AdaptationSet":
+                var _b = __read((0, AdaptationSet_1.createAdaptationSetIntermediateRepresentation)(currentElement), 2), adaptation = _b[0], adaptationWarnings = _b[1];
+                adaptations.push(adaptation);
+                warnings = warnings.concat(adaptationWarnings);
+                break;
+            case "EventStream":
+                var _c = __read((0, EventStream_1.createEventStreamIntermediateRepresentation)(currentElement, fullMpd), 2), eventStream = _c[0], eventStreamWarnings = _c[1];
+                eventStreams.push(eventStream);
+                warnings = warnings.concat(eventStreamWarnings);
+                break;
+            case "SegmentTemplate":
+                var _d = __read((0, SegmentTemplate_1.default)(currentElement), 2), parsedSegmentTemplate = _d[0], segmentTemplateWarnings = _d[1];
+                segmentTemplate = parsedSegmentTemplate;
+                if (segmentTemplateWarnings.length > 0) {
+                    warnings = warnings.concat(segmentTemplateWarnings);
+                }
+                break;
+        }
+    }
+    return [{ baseURLs: baseURLs, adaptations: adaptations, eventStreams: eventStreams, segmentTemplate: segmentTemplate }, warnings];
+}
+/**
+ * @param {Object} root
+ * @returns {Array}
+ */
+function parsePeriodAttributes(root) {
+    var e_1, _a;
+    var res = {};
+    var warnings = [];
+    var parseValue = (0, utils_1.ValueParser)(res, warnings);
+    try {
+        for (var _b = __values(Object.keys(root.attributes)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var attributeName = _c.value;
+            var attributeVal = root.attributes[attributeName];
+            if ((0, is_null_or_undefined_1.default)(attributeVal)) {
+                continue;
+            }
+            switch (attributeName) {
+                case "id":
+                    res.id = attributeVal;
+                    break;
+                case "start":
+                    parseValue(attributeVal, {
+                        asKey: "start",
+                        parser: utils_1.parseDuration,
+                        dashName: "start",
+                    });
+                    break;
+                case "duration":
+                    parseValue(attributeVal, {
+                        asKey: "duration",
+                        parser: utils_1.parseDuration,
+                        dashName: "duration",
+                    });
+                    break;
+                case "bitstreamSwitching":
+                    parseValue(attributeVal, {
+                        asKey: "bitstreamSwitching",
+                        parser: utils_1.parseBoolean,
+                        dashName: "bitstreamSwitching",
+                    });
+                    break;
+                case "xlink:href":
+                    res.xlinkHref = attributeVal;
+                    break;
+                case "xlink:actuate":
+                    res.xlinkActuate = attributeVal;
+                    break;
+                default:
+                    if ((0, starts_with_1.default)(attributeName, "xmlns:")) {
+                        if (res.namespaces === undefined) {
+                            res.namespaces = [];
+                        }
+                        res.namespaces.push({
+                            key: attributeName.substring(6),
+                            value: attributeVal,
+                        });
+                    }
+                    break;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return [res, warnings];
+}
+/**
+ * @param {Object} periodElement
+ * @param {string} fullMpd
+ * @returns {Array}
+ */
+function createPeriodIntermediateRepresentation(periodElement, fullMpd) {
+    var _a = __read(parsePeriodChildren(periodElement.children, fullMpd), 2), children = _a[0], childrenWarnings = _a[1];
+    var _b = __read(parsePeriodAttributes(periodElement), 2), attributes = _b[0], attrsWarnings = _b[1];
+    var warnings = childrenWarnings.concat(attrsWarnings);
+    return [{ children: children, attributes: attributes }, warnings];
+}
+exports.createPeriodIntermediateRepresentation = createPeriodIntermediateRepresentation;

package/dist/commonjs/parsers/manifest/dash/fast-js-parser/node_parsers/Representation.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 { IRepresentationIntermediateRepresentation } from "../../node_parser_types";
+/**
+ * @param {Object} representationElement
+ * @returns {Array}
+ */
+export declare function createRepresentationIntermediateRepresentation(representationElement: ITNode): [IRepresentationIntermediateRepresentation, Error[]];

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

@@ -0,0 +1,256 @@
+"use strict";
+/**
+ * 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.
+ */
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRepresentationIntermediateRepresentation = void 0;
+var is_null_or_undefined_1 = require("../../../../../utils/is_null_or_undefined");
+var BaseURL_1 = require("./BaseURL");
+var ContentProtection_1 = require("./ContentProtection");
+var SegmentBase_1 = require("./SegmentBase");
+var SegmentList_1 = require("./SegmentList");
+var SegmentTemplate_1 = require("./SegmentTemplate");
+var utils_1 = require("./utils");
+/**
+ * @param {Array.<Object | string>} representationChildren
+ * @returns {Object}
+ */
+function parseRepresentationChildren(representationChildren) {
+    var children = {
+        baseURLs: [],
+    };
+    var contentProtections = [];
+    var warnings = [];
+    for (var i = 0; i < representationChildren.length; i++) {
+        var currentElement = representationChildren[i];
+        if (typeof currentElement === "string") {
+            continue;
+        }
+        switch (currentElement.tagName) {
+            case "BaseURL":
+                var _a = __read((0, BaseURL_1.default)(currentElement), 2), baseURLObj = _a[0], baseURLWarnings = _a[1];
+                if (baseURLObj !== undefined) {
+                    children.baseURLs.push(baseURLObj);
+                }
+                warnings = warnings.concat(baseURLWarnings);
+                break;
+            case "InbandEventStream":
+                if (children.inbandEventStreams === undefined) {
+                    children.inbandEventStreams = [];
+                }
+                children.inbandEventStreams.push((0, utils_1.parseScheme)(currentElement));
+                break;
+            case "SegmentBase":
+                var _b = __read((0, SegmentBase_1.default)(currentElement), 2), segmentBase = _b[0], segmentBaseWarnings = _b[1];
+                children.segmentBase = segmentBase;
+                if (segmentBaseWarnings.length > 0) {
+                    warnings = warnings.concat(segmentBaseWarnings);
+                }
+                break;
+            case "SegmentList":
+                var _c = __read((0, SegmentList_1.default)(currentElement), 2), segmentList = _c[0], segmentListWarnings = _c[1];
+                warnings = warnings.concat(segmentListWarnings);
+                children.segmentList = segmentList;
+                break;
+            case "SegmentTemplate":
+                var _d = __read((0, SegmentTemplate_1.default)(currentElement), 2), segmentTemplate = _d[0], segmentTemplateWarnings = _d[1];
+                warnings = warnings.concat(segmentTemplateWarnings);
+                children.segmentTemplate = segmentTemplate;
+                break;
+            case "ContentProtection":
+                var _e = __read((0, ContentProtection_1.default)(currentElement), 2), contentProtection = _e[0], contentProtectionWarnings = _e[1];
+                if (contentProtectionWarnings.length > 0) {
+                    warnings = warnings.concat(contentProtectionWarnings);
+                }
+                if (contentProtection !== undefined) {
+                    contentProtections.push(contentProtection);
+                }
+                break;
+            case "SupplementalProperty":
+                if ((0, is_null_or_undefined_1.default)(children.supplementalProperties)) {
+                    children.supplementalProperties = [(0, utils_1.parseScheme)(currentElement)];
+                }
+                else {
+                    children.supplementalProperties.push((0, utils_1.parseScheme)(currentElement));
+                }
+                break;
+        }
+    }
+    if (contentProtections.length > 0) {
+        children.contentProtections = contentProtections;
+    }
+    return [children, warnings];
+}
+/**
+ * @param {Object} root
+ * @returns {Array}
+ */
+function parseRepresentationAttributes(root) {
+    var e_1, _a;
+    var attributes = {};
+    var warnings = [];
+    var parseValue = (0, utils_1.ValueParser)(attributes, warnings);
+    try {
+        for (var _b = __values(Object.keys(root.attributes)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var attributeName = _c.value;
+            var attributeVal = root.attributes[attributeName];
+            if ((0, is_null_or_undefined_1.default)(attributeVal)) {
+                continue;
+            }
+            switch (attributeName) {
+                case "audioSamplingRate":
+                    attributes.audioSamplingRate = attributeVal;
+                    break;
+                case "bandwidth":
+                    parseValue(attributeVal, {
+                        asKey: "bitrate",
+                        parser: utils_1.parseMPDInteger,
+                        dashName: "bandwidth",
+                    });
+                    break;
+                case "codecs":
+                    attributes.codecs = attributeVal;
+                    break;
+                case "codingDependency":
+                    parseValue(attributeVal, {
+                        asKey: "codingDependency",
+                        parser: utils_1.parseBoolean,
+                        dashName: "codingDependency",
+                    });
+                    break;
+                case "frameRate":
+                    parseValue(attributeVal, {
+                        asKey: "frameRate",
+                        parser: utils_1.parseMaybeDividedNumber,
+                        dashName: "frameRate",
+                    });
+                    break;
+                case "height":
+                    parseValue(attributeVal, {
+                        asKey: "height",
+                        parser: utils_1.parseMPDInteger,
+                        dashName: "height",
+                    });
+                    break;
+                case "id":
+                    attributes.id = attributeVal;
+                    break;
+                case "maxPlayoutRate":
+                    parseValue(attributeVal, {
+                        asKey: "maxPlayoutRate",
+                        parser: utils_1.parseMPDFloat,
+                        dashName: "maxPlayoutRate",
+                    });
+                    break;
+                case "maximumSAPPeriod":
+                    parseValue(attributeVal, {
+                        asKey: "maximumSAPPeriod",
+                        parser: utils_1.parseMPDFloat,
+                        dashName: "maximumSAPPeriod",
+                    });
+                    break;
+                case "mimeType":
+                    attributes.mimeType = attributeVal;
+                    break;
+                case "profiles":
+                    attributes.profiles = attributeVal;
+                    break;
+                case "qualityRanking":
+                    parseValue(attributeVal, {
+                        asKey: "qualityRanking",
+                        parser: utils_1.parseMPDInteger,
+                        dashName: "qualityRanking",
+                    });
+                    break;
+                case "scte214:supplementalCodecs":
+                    attributes.supplementalCodecs = attributeVal;
+                    break;
+                case "segmentProfiles":
+                    attributes.segmentProfiles = attributeVal;
+                    break;
+                case "width":
+                    parseValue(attributeVal, {
+                        asKey: "width",
+                        parser: utils_1.parseMPDInteger,
+                        dashName: "width",
+                    });
+                    break;
+                case "availabilityTimeOffset":
+                    parseValue(attributeVal, {
+                        asKey: "availabilityTimeOffset",
+                        parser: utils_1.parseMPDFloat,
+                        dashName: "availabilityTimeOffset",
+                    });
+                    break;
+                case "availabilityTimeComplete":
+                    parseValue(attributeVal, {
+                        asKey: "availabilityTimeComplete",
+                        parser: utils_1.parseBoolean,
+                        dashName: "availabilityTimeComplete",
+                    });
+                    break;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (attributes.bitrate === undefined) {
+        warnings.push(new utils_1.MPDError("No bitrate found on a Representation"));
+    }
+    return [attributes, warnings];
+}
+/**
+ * @param {Object} representationElement
+ * @returns {Array}
+ */
+function createRepresentationIntermediateRepresentation(representationElement) {
+    var _a = __read(parseRepresentationChildren(representationElement.children), 2), children = _a[0], childrenWarnings = _a[1];
+    var _b = __read(parseRepresentationAttributes(representationElement), 2), attributes = _b[0], attrsWarnings = _b[1];
+    var warnings = childrenWarnings.concat(attrsWarnings);
+    return [{ children: children, attributes: attributes }, warnings];
+}
+exports.createRepresentationIntermediateRepresentation = createRepresentationIntermediateRepresentation;

package/dist/commonjs/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/commonjs/parsers/manifest/dash/fast-js-parser/node_parsers/SegmentBase.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * 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.
+ */
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var is_null_or_undefined_1 = require("../../../../../utils/is_null_or_undefined");
+var Initialization_1 = require("./Initialization");
+var utils_1 = require("./utils");
+/**
+ * Parse a SegmentBase element into a SegmentBase intermediate representation.
+ * @param {Object} root - The SegmentBase root element.
+ * @returns {Array}
+ */
+function parseSegmentBase(root) {
+    var e_1, _a;
+    var attributes = {};
+    var warnings = [];
+    var parseValue = (0, utils_1.ValueParser)(attributes, warnings);
+    var segmentBaseChildren = root.children;
+    for (var i = 0; i < segmentBaseChildren.length; i++) {
+        var currentNode = segmentBaseChildren[i];
+        if (typeof currentNode !== "string") {
+            if (currentNode.tagName === "Initialization") {
+                var _b = __read((0, Initialization_1.default)(currentNode), 2), initialization = _b[0], initializationWarnings = _b[1];
+                attributes.initialization = initialization;
+                warnings = warnings.concat(initializationWarnings);
+            }
+        }
+    }
+    try {
+        for (var _c = __values(Object.keys(root.attributes)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var attributeName = _d.value;
+            var attributeVal = root.attributes[attributeName];
+            if ((0, is_null_or_undefined_1.default)(attributeVal)) {
+                continue;
+            }
+            switch (attributeName) {
+                case "timescale":
+                    parseValue(attributeVal, {
+                        asKey: "timescale",
+                        parser: utils_1.parseMPDInteger,
+                        dashName: "timescale",
+                    });
+                    break;
+                case "presentationTimeOffset":
+                    parseValue(attributeVal, {
+                        asKey: "presentationTimeOffset",
+                        parser: utils_1.parseMPDFloat,
+                        dashName: "presentationTimeOffset",
+                    });
+                    break;
+                case "indexRange":
+                    parseValue(attributeVal, {
+                        asKey: "indexRange",
+                        parser: utils_1.parseByteRange,
+                        dashName: "indexRange",
+                    });
+                    break;
+                case "indexRangeExact":
+                    parseValue(attributeVal, {
+                        asKey: "indexRangeExact",
+                        parser: utils_1.parseBoolean,
+                        dashName: "indexRangeExact",
+                    });
+                    break;
+                case "availabilityTimeOffset":
+                    parseValue(attributeVal, {
+                        asKey: "availabilityTimeOffset",
+                        parser: utils_1.parseMPDFloat,
+                        dashName: "availabilityTimeOffset",
+                    });
+                    break;
+                case "availabilityTimeComplete":
+                    parseValue(attributeVal, {
+                        asKey: "availabilityTimeComplete",
+                        parser: utils_1.parseBoolean,
+                        dashName: "availabilityTimeComplete",
+                    });
+                    break;
+                case "duration":
+                    parseValue(attributeVal, {
+                        asKey: "duration",
+                        parser: utils_1.parseMPDInteger,
+                        dashName: "duration",
+                    });
+                    break;
+                case "startNumber":
+                    parseValue(attributeVal, {
+                        asKey: "startNumber",
+                        parser: utils_1.parseMPDInteger,
+                        dashName: "startNumber",
+                    });
+                    break;
+                case "endNumber":
+                    parseValue(attributeVal, {
+                        asKey: "endNumber",
+                        parser: utils_1.parseMPDInteger,
+                        dashName: "endNumber",
+                    });
+                    break;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return [attributes, warnings];
+}
+exports.default = parseSegmentBase;

package/dist/commonjs/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[]];