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

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

@@ -0,0 +1,118 @@
+"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 log_1 = require("../../../../../log");
+var is_null_or_undefined_1 = require("../../../../../utils/is_null_or_undefined");
+var string_parsing_1 = require("../../../../../utils/string_parsing");
+var utils_1 = require("./utils");
+/**
+ * @param {Array.<Object | string>} contentProtectionChildren
+ * @Returns {Object}
+ */
+function parseContentProtectionChildren(contentProtectionChildren) {
+    var warnings = [];
+    var cencPssh = [];
+    for (var i = 0; i < contentProtectionChildren.length; i++) {
+        var currentElement = contentProtectionChildren[i];
+        if (typeof currentElement !== "string" && currentElement.tagName === "cenc:pssh") {
+            var content = (0, utils_1.textContent)(currentElement.children);
+            if (content !== null && content.length > 0) {
+                var _a = __read((0, utils_1.parseBase64)(content, "cenc:pssh"), 2), toUint8Array = _a[0], error = _a[1];
+                if (error !== null) {
+                    log_1.default.warn(error.message);
+                    warnings.push(error);
+                }
+                if (toUint8Array !== null) {
+                    cencPssh.push(toUint8Array);
+                }
+            }
+        }
+    }
+    return [{ cencPssh: cencPssh }, warnings];
+}
+/**
+ * @param {Object} root
+ * @returns {Object}
+ */
+function parseContentProtectionAttributes(root) {
+    var e_1, _a;
+    var ret = {};
+    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 "schemeIdUri":
+                    ret.schemeIdUri = attributeVal;
+                    break;
+                case "value":
+                    ret.value = attributeVal;
+                    break;
+                case "cenc:default_KID":
+                    ret.keyId = (0, string_parsing_1.hexToBytes)(attributeVal.replace(/-/g, ""));
+            }
+        }
+    }
+    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 ret;
+}
+/**
+ * @param {Object} contentProtectionElement
+ * @returns {Object}
+ */
+function parseContentProtection(contentProtectionElement) {
+    var _a = __read(parseContentProtectionChildren(contentProtectionElement.children), 2), children = _a[0], childrenWarnings = _a[1];
+    var attributes = parseContentProtectionAttributes(contentProtectionElement);
+    return [{ children: children, attributes: attributes }, childrenWarnings];
+}
+exports.default = parseContentProtection;

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

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

@@ -0,0 +1,154 @@
+"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 __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.");
+};
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventStreamIntermediateRepresentation = void 0;
+var is_null_or_undefined_1 = require("../../../../../utils/is_null_or_undefined");
+var starts_with_1 = require("../../../../../utils/starts_with");
+var utils_1 = require("./utils");
+/**
+ * @param {Object} root
+ * @returns {Array}
+ */
+function parseEventStreamAttributes(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 "schemeIdUri":
+                    res.schemeIdUri = attributeVal;
+                    break;
+                case "value":
+                    res.value = attributeVal;
+                    break;
+                case "timescale":
+                    parseValue(attributeVal, {
+                        asKey: "timescale",
+                        parser: utils_1.parseMPDInteger,
+                        dashName: "timescale",
+                    });
+                    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} root
+ * @param {string} fullMpd
+ * @returns {Array}
+ */
+function createEventStreamIntermediateRepresentation(root, fullMpd) {
+    var e_2, _a;
+    var _b = __read(parseEventStreamAttributes(root), 2), attributes = _b[0], warnings = _b[1];
+    var events = [];
+    try {
+        for (var _c = __values(root.children), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var child = _d.value;
+            if (typeof child !== "string" && child.tagName === "Event") {
+                var data = {};
+                if (!(0, is_null_or_undefined_1.default)(child.attributes.id)) {
+                    data.id = child.attributes.id;
+                }
+                if (!(0, is_null_or_undefined_1.default)(child.attributes.presentationTime)) {
+                    var _e = __read((0, utils_1.parseMPDInteger)(child.attributes.presentationTime, "presentationTime"), 2), val = _e[0], parsedWarning = _e[1];
+                    if (parsedWarning !== null) {
+                        warnings.push(parsedWarning);
+                    }
+                    if (val !== null) {
+                        data.presentationTime = val;
+                    }
+                }
+                if (!(0, is_null_or_undefined_1.default)(child.attributes.duration)) {
+                    var _f = __read((0, utils_1.parseMPDInteger)(child.attributes.duration, "duration"), 2), val = _f[0], parsedWarning = _f[1];
+                    if (parsedWarning !== null) {
+                        warnings.push(parsedWarning);
+                    }
+                    if (val !== null) {
+                        data.duration = val;
+                    }
+                }
+                if (child.posStart < child.posEnd) {
+                    var eventStr = fullMpd.substring(child.posStart, child.posEnd);
+                    data.eventStreamData = eventStr;
+                }
+                events.push(data);
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return [{ children: { events: events }, attributes: attributes }, warnings];
+}
+exports.createEventStreamIntermediateRepresentation = createEventStreamIntermediateRepresentation;

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

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

@@ -0,0 +1,70 @@
+"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 __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 utils_1 = require("./utils");
+/**
+ * @param {Object} root
+ * @returns {Array.<Object>}
+ */
+function parseInitialization(root) {
+    var e_1, _a;
+    var parsedInitialization = {};
+    var warnings = [];
+    var parseValue = (0, utils_1.ValueParser)(parsedInitialization, 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 "range":
+                    parseValue(attributeVal, {
+                        asKey: "range",
+                        parser: utils_1.parseByteRange,
+                        dashName: "range",
+                    });
+                    break;
+                case "sourceURL":
+                    parsedInitialization.media = 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 [parsedInitialization, warnings];
+}
+exports.default = parseInitialization;

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

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

@@ -0,0 +1,221 @@
+"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.createMPDIntermediateRepresentation = void 0;
+var is_null_or_undefined_1 = require("../../../../../utils/is_null_or_undefined");
+var starts_with_1 = require("../../../../../utils/starts_with");
+var BaseURL_1 = require("./BaseURL");
+var Period_1 = require("./Period");
+var utils_1 = require("./utils");
+/**
+ * Parse children of the MPD's root into a simple object.
+ * @param {Array.<Object | string>} mpdChildren
+ * @returns {Array.<Object>}
+ */
+function parseMPDChildren(mpdChildren, fullMpd) {
+    var baseURLs = [];
+    var locations = [];
+    var periods = [];
+    var utcTimings = [];
+    var warnings = [];
+    for (var i = 0; i < mpdChildren.length; i++) {
+        var currentNode = mpdChildren[i];
+        if (typeof currentNode === "string") {
+            continue;
+        }
+        switch (currentNode.tagName) {
+            case "BaseURL":
+                var _a = __read((0, BaseURL_1.default)(currentNode), 2), baseURLObj = _a[0], baseURLWarnings = _a[1];
+                if (baseURLObj !== undefined) {
+                    baseURLs.push(baseURLObj);
+                }
+                warnings = warnings.concat(baseURLWarnings);
+                break;
+            case "Location":
+                locations.push((0, utils_1.textContent)(currentNode.children));
+                break;
+            case "Period":
+                var _b = __read((0, Period_1.createPeriodIntermediateRepresentation)(currentNode, fullMpd), 2), period = _b[0], periodWarnings = _b[1];
+                periods.push(period);
+                warnings = warnings.concat(periodWarnings);
+                break;
+            case "UTCTiming":
+                var utcTiming = (0, utils_1.parseScheme)(currentNode);
+                utcTimings.push(utcTiming);
+                break;
+        }
+    }
+    return [{ baseURLs: baseURLs, locations: locations, periods: periods, utcTimings: utcTimings }, warnings];
+}
+/**
+ * @param {Object} root
+ * @returns {Array.<Object>}
+ */
+function parseMPDAttributes(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 "profiles":
+                    res.profiles = attributeVal;
+                    break;
+                case "type":
+                    res.type = attributeVal;
+                    break;
+                case "availabilityStartTime":
+                    parseValue(attributeVal, {
+                        asKey: "availabilityStartTime",
+                        parser: utils_1.parseDateTime,
+                        dashName: "availabilityStartTime",
+                    });
+                    break;
+                case "availabilityEndTime":
+                    parseValue(attributeVal, {
+                        asKey: "availabilityEndTime",
+                        parser: utils_1.parseDateTime,
+                        dashName: "availabilityEndTime",
+                    });
+                    break;
+                case "publishTime":
+                    parseValue(attributeVal, {
+                        asKey: "publishTime",
+                        parser: utils_1.parseDateTime,
+                        dashName: "publishTime",
+                    });
+                    break;
+                case "mediaPresentationDuration":
+                    parseValue(attributeVal, {
+                        asKey: "duration",
+                        parser: utils_1.parseDuration,
+                        dashName: "mediaPresentationDuration",
+                    });
+                    break;
+                case "minimumUpdatePeriod":
+                    parseValue(attributeVal, {
+                        asKey: "minimumUpdatePeriod",
+                        parser: utils_1.parseDuration,
+                        dashName: "minimumUpdatePeriod",
+                    });
+                    break;
+                case "minBufferTime":
+                    parseValue(attributeVal, {
+                        asKey: "minBufferTime",
+                        parser: utils_1.parseDuration,
+                        dashName: "minBufferTime",
+                    });
+                    break;
+                case "timeShiftBufferDepth":
+                    parseValue(attributeVal, {
+                        asKey: "timeShiftBufferDepth",
+                        parser: utils_1.parseDuration,
+                        dashName: "timeShiftBufferDepth",
+                    });
+                    break;
+                case "suggestedPresentationDelay":
+                    parseValue(attributeVal, {
+                        asKey: "suggestedPresentationDelay",
+                        parser: utils_1.parseDuration,
+                        dashName: "suggestedPresentationDelay",
+                    });
+                    break;
+                case "maxSegmentDuration":
+                    parseValue(attributeVal, {
+                        asKey: "maxSegmentDuration",
+                        parser: utils_1.parseDuration,
+                        dashName: "maxSegmentDuration",
+                    });
+                    break;
+                case "maxSubsegmentDuration":
+                    parseValue(attributeVal, {
+                        asKey: "maxSubsegmentDuration",
+                        parser: utils_1.parseDuration,
+                        dashName: "maxSubsegmentDuration",
+                    });
+                    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} root
+ * @param {string} fullMpd
+ * @returns {Array.<Object>}
+ */
+function createMPDIntermediateRepresentation(root, fullMpd) {
+    var _a = __read(parseMPDChildren(root.children, fullMpd), 2), children = _a[0], childrenWarnings = _a[1];
+    var _b = __read(parseMPDAttributes(root), 2), attributes = _b[0], attrsWarnings = _b[1];
+    var warnings = childrenWarnings.concat(attrsWarnings);
+    return [{ children: children, attributes: attributes }, warnings];
+}
+exports.createMPDIntermediateRepresentation = createMPDIntermediateRepresentation;

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