rx-player 4.0.0-beta.2 → 4.0.0-beta.3

package/dist/_esm5.processed/parsers/manifest/dash/wasm-parser/ts/generators/MPD.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,11 +14,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import noop from "../../../../../../utils/noop";
-import { parseString } from "../utils";
-import { generateBaseUrlAttrParser } from "./BaseURL";
-import { generatePeriodAttrParser, generatePeriodChildrenParser, } from "./Period";
-import { generateSchemeAttrParser } from "./Scheme";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMPDAttrParser = exports.generateMPDChildrenParser = void 0;
+const noop_1 = require("../../../../../../utils/noop");
+const utils_1 = require("../utils");
+const BaseURL_1 = require("./BaseURL");
+const Period_1 = require("./Period");
+const Scheme_1 = require("./Scheme");
 /**
  * Generate a "children parser" once inside an `MPD` node.
  * @param {Object} mpdChildren
@@ -26,68 +29,69 @@ import { generateSchemeAttrParser } from "./Scheme";
  * @param {ArrayBuffer} fullMpd
  * @returns {Function}
  */
-export function generateMPDChildrenParser(mpdChildren, linearMemory, parsersStack, fullMpd) {
+function generateMPDChildrenParser(mpdChildren, linearMemory, parsersStack, fullMpd) {
     return function onRootChildren(nodeId) {
         switch (nodeId) {
             case 15 /* TagName.BaseURL */: {
-                var baseUrl = { value: "", attributes: {} };
+                const baseUrl = { value: "", attributes: {} };
                 mpdChildren.baseURLs.push(baseUrl);
-                var childrenParser = noop; // BaseURL have no sub-element
-                var attributeParser = generateBaseUrlAttrParser(baseUrl, linearMemory);
+                const childrenParser = noop_1.default; // BaseURL have no sub-element
+                const attributeParser = (0, BaseURL_1.generateBaseUrlAttrParser)(baseUrl, linearMemory);
                 parsersStack.pushParsers(nodeId, childrenParser, attributeParser);
                 break;
             }
             case 2 /* TagName.Period */: {
-                var period = { children: { adaptations: [],
+                const period = { children: { adaptations: [],
                         baseURLs: [],
                         eventStreams: [] },
                     attributes: {} };
                 mpdChildren.periods.push(period);
-                var childrenParser = generatePeriodChildrenParser(period.children, linearMemory, parsersStack, fullMpd);
-                var attributeParser = generatePeriodAttrParser(period.attributes, linearMemory);
+                const childrenParser = (0, Period_1.generatePeriodChildrenParser)(period.children, linearMemory, parsersStack, fullMpd);
+                const attributeParser = (0, Period_1.generatePeriodAttrParser)(period.attributes, linearMemory);
                 parsersStack.pushParsers(nodeId, childrenParser, attributeParser);
                 break;
             }
             case 3 /* TagName.UtcTiming */: {
-                var utcTiming = {};
+                const utcTiming = {};
                 mpdChildren.utcTimings.push(utcTiming);
-                var childrenParser = noop; // UTCTiming have no sub-element
-                var attributeParser = generateSchemeAttrParser(utcTiming, linearMemory);
+                const childrenParser = noop_1.default; // UTCTiming have no sub-element
+                const attributeParser = (0, Scheme_1.generateSchemeAttrParser)(utcTiming, linearMemory);
                 parsersStack.pushParsers(nodeId, childrenParser, attributeParser);
                 break;
             }
             default:
                 // Allows to make sure we're not mistakenly closing a re-opened
                 // tag.
-                parsersStack.pushParsers(nodeId, noop, noop);
+                parsersStack.pushParsers(nodeId, noop_1.default, noop_1.default);
                 break;
         }
     };
 }
-export function generateMPDAttrParser(mpdChildren, mpdAttrs, linearMemory) {
-    var dataView;
-    var textDecoder = new TextDecoder();
+exports.generateMPDChildrenParser = generateMPDChildrenParser;
+function generateMPDAttrParser(mpdChildren, mpdAttrs, linearMemory) {
+    let dataView;
+    const textDecoder = new TextDecoder();
     return function onMPDAttribute(attr, ptr, len) {
         switch (attr) {
             case 0 /* AttributeName.Id */:
-                mpdAttrs.id = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                mpdAttrs.id = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 2 /* AttributeName.Profiles */:
-                mpdAttrs.profiles = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                mpdAttrs.profiles = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 33 /* AttributeName.Type */:
-                mpdAttrs.type = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                mpdAttrs.type = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 34 /* AttributeName.AvailabilityStartTime */:
-                var startTime = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                const startTime = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 mpdAttrs.availabilityStartTime = new Date(startTime).getTime() / 1000;
                 break;
             case 35 /* AttributeName.AvailabilityEndTime */:
-                var endTime = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                const endTime = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 mpdAttrs.availabilityEndTime = new Date(endTime).getTime() / 1000;
                 break;
             case 36 /* AttributeName.PublishTime */:
-                var publishTime = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                const publishTime = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 mpdAttrs.publishTime = new Date(publishTime).getTime() / 1000;
                 break;
             case 68 /* AttributeName.MediaPresentationDuration */:
@@ -119,20 +123,20 @@ export function generateMPDAttrParser(mpdChildren, mpdAttrs, linearMemory) {
                 mpdAttrs.maxSubsegmentDuration = dataView.getFloat64(ptr, true);
                 break;
             case 66 /* AttributeName.Location */:
-                var location_1 = parseString(textDecoder, linearMemory.buffer, ptr, len);
-                mpdChildren.locations.push(location_1);
+                const location = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
+                mpdChildren.locations.push(location);
                 break;
             case 70 /* AttributeName.Namespace */:
-                var xmlNs = { key: "", value: "" };
+                const xmlNs = { key: "", value: "" };
                 dataView = new DataView(linearMemory.buffer);
-                var offset = ptr;
-                var keySize = dataView.getUint32(offset);
+                let offset = ptr;
+                const keySize = dataView.getUint32(offset);
                 offset += 4;
-                xmlNs.key = parseString(textDecoder, linearMemory.buffer, offset, keySize);
+                xmlNs.key = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, offset, keySize);
                 offset += keySize;
-                var valSize = dataView.getUint32(offset);
+                const valSize = dataView.getUint32(offset);
                 offset += 4;
-                xmlNs.value = parseString(textDecoder, linearMemory.buffer, offset, valSize);
+                xmlNs.value = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, offset, valSize);
                 if (mpdAttrs.namespaces === undefined) {
                     mpdAttrs.namespaces = [xmlNs];
                 }
@@ -143,3 +147,4 @@ export function generateMPDAttrParser(mpdChildren, mpdAttrs, linearMemory) {
         }
     };
 }
+exports.generateMPDAttrParser = generateMPDAttrParser;

package/dist/_esm5.processed/parsers/manifest/dash/wasm-parser/ts/generators/Period.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,12 +14,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import noop from "../../../../../../utils/noop";
-import { parseString } from "../utils";
-import { generateAdaptationSetAttrParser, generateAdaptationSetChildrenParser, } from "./AdaptationSet";
-import { generateBaseUrlAttrParser } from "./BaseURL";
-import { generateEventStreamAttrParser, generateEventStreamChildrenParser, } from "./EventStream";
-import { generateSegmentTemplateAttrParser } from "./SegmentTemplate";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePeriodAttrParser = exports.generatePeriodChildrenParser = void 0;
+const noop_1 = require("../../../../../../utils/noop");
+const utils_1 = require("../utils");
+const AdaptationSet_1 = require("./AdaptationSet");
+const BaseURL_1 = require("./BaseURL");
+const EventStream_1 = require("./EventStream");
+const SegmentTemplate_1 = require("./SegmentTemplate");
 /**
  * Generate a "children parser" once inside a `Perod` node.
  * @param {Object} periodChildren
@@ -27,61 +30,62 @@ import { generateSegmentTemplateAttrParser } from "./SegmentTemplate";
  * @param {ArrayBuffer} fullMpd
  * @returns {Function}
  */
-export function generatePeriodChildrenParser(periodChildren, linearMemory, parsersStack, fullMpd) {
+function generatePeriodChildrenParser(periodChildren, linearMemory, parsersStack, fullMpd) {
     return function onRootChildren(nodeId) {
         switch (nodeId) {
             case 4 /* TagName.AdaptationSet */: {
-                var adaptationObj = { children: { baseURLs: [],
+                const adaptationObj = { children: { baseURLs: [],
                         representations: [] },
                     attributes: {} };
                 periodChildren.adaptations.push(adaptationObj);
-                var childrenParser = generateAdaptationSetChildrenParser(adaptationObj.children, linearMemory, parsersStack);
-                var attributeParser = generateAdaptationSetAttrParser(adaptationObj.attributes, linearMemory);
+                const childrenParser = (0, AdaptationSet_1.generateAdaptationSetChildrenParser)(adaptationObj.children, linearMemory, parsersStack);
+                const attributeParser = (0, AdaptationSet_1.generateAdaptationSetAttrParser)(adaptationObj.attributes, linearMemory);
                 parsersStack.pushParsers(nodeId, childrenParser, attributeParser);
                 break;
             }
             case 15 /* TagName.BaseURL */: {
-                var baseUrl = { value: "", attributes: {} };
+                const baseUrl = { value: "", attributes: {} };
                 periodChildren.baseURLs.push(baseUrl);
-                var childrenParser = noop;
-                var attributeParser = generateBaseUrlAttrParser(baseUrl, linearMemory);
+                const childrenParser = noop_1.default;
+                const attributeParser = (0, BaseURL_1.generateBaseUrlAttrParser)(baseUrl, linearMemory);
                 parsersStack.pushParsers(nodeId, childrenParser, attributeParser);
                 break;
             }
             case 5 /* TagName.EventStream */: {
-                var eventStream = { children: { events: [] }, attributes: {} };
+                const eventStream = { children: { events: [] }, attributes: {} };
                 periodChildren.eventStreams.push(eventStream);
-                var childrenParser = generateEventStreamChildrenParser(eventStream.children, linearMemory, parsersStack, fullMpd);
-                var attrParser = generateEventStreamAttrParser(eventStream.attributes, linearMemory);
+                const childrenParser = (0, EventStream_1.generateEventStreamChildrenParser)(eventStream.children, linearMemory, parsersStack, fullMpd);
+                const attrParser = (0, EventStream_1.generateEventStreamAttrParser)(eventStream.attributes, linearMemory);
                 parsersStack.pushParsers(nodeId, childrenParser, attrParser);
                 break;
             }
             case 16 /* TagName.SegmentTemplate */: {
-                var stObj = {};
+                const stObj = {};
                 periodChildren.segmentTemplate = stObj;
-                parsersStack.pushParsers(nodeId, noop, // SegmentTimeline as treated like an attribute
-                generateSegmentTemplateAttrParser(stObj, linearMemory));
+                parsersStack.pushParsers(nodeId, noop_1.default, // SegmentTimeline as treated like an attribute
+                (0, SegmentTemplate_1.generateSegmentTemplateAttrParser)(stObj, linearMemory));
                 break;
             }
             default:
                 // Allows to make sure we're not mistakenly closing a re-opened
                 // tag.
-                parsersStack.pushParsers(nodeId, noop, noop);
+                parsersStack.pushParsers(nodeId, noop_1.default, noop_1.default);
                 break;
         }
     };
 }
+exports.generatePeriodChildrenParser = generatePeriodChildrenParser;
 /**
  * @param {Object} periodAttrs
  * @param {WebAssembly.Memory} linearMemory
  * @returns {Function}
  */
-export function generatePeriodAttrParser(periodAttrs, linearMemory) {
-    var textDecoder = new TextDecoder();
+function generatePeriodAttrParser(periodAttrs, linearMemory) {
+    const textDecoder = new TextDecoder();
     return function onPeriodAttribute(attr, ptr, len) {
         switch (attr) {
             case 0 /* AttributeName.Id */:
-                periodAttrs.id = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                periodAttrs.id = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 45 /* AttributeName.Start */:
                 periodAttrs.start = new DataView(linearMemory.buffer).getFloat64(ptr, true);
@@ -94,10 +98,10 @@ export function generatePeriodAttrParser(periodAttrs, linearMemory) {
                     new DataView(linearMemory.buffer).getUint8(0) === 0;
                 break;
             case 46 /* AttributeName.XLinkHref */:
-                periodAttrs.xlinkHref = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                periodAttrs.xlinkHref = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 47 /* AttributeName.XLinkActuate */:
-                periodAttrs.xlinkActuate = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                periodAttrs.xlinkActuate = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 43 /* AttributeName.AvailabilityTimeOffset */:
                 periodAttrs.availabilityTimeOffset =
@@ -108,16 +112,16 @@ export function generatePeriodAttrParser(periodAttrs, linearMemory) {
                     new DataView(linearMemory.buffer).getUint8(0) === 0;
                 break;
             case 70 /* AttributeName.Namespace */:
-                var xmlNs = { key: "", value: "" };
-                var dataView = new DataView(linearMemory.buffer);
-                var offset = ptr;
-                var keySize = dataView.getUint32(offset);
+                const xmlNs = { key: "", value: "" };
+                const dataView = new DataView(linearMemory.buffer);
+                let offset = ptr;
+                const keySize = dataView.getUint32(offset);
                 offset += 4;
-                xmlNs.key = parseString(textDecoder, linearMemory.buffer, offset, keySize);
+                xmlNs.key = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, offset, keySize);
                 offset += keySize;
-                var valSize = dataView.getUint32(offset);
+                const valSize = dataView.getUint32(offset);
                 offset += 4;
-                xmlNs.value = parseString(textDecoder, linearMemory.buffer, offset, valSize);
+                xmlNs.value = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, offset, valSize);
                 if (periodAttrs.namespaces === undefined) {
                     periodAttrs.namespaces = [xmlNs];
                 }
@@ -128,3 +132,4 @@ export function generatePeriodAttrParser(periodAttrs, linearMemory) {
         }
     };
 }
+exports.generatePeriodAttrParser = generatePeriodAttrParser;

package/dist/_esm5.processed/parsers/manifest/dash/wasm-parser/ts/generators/Representation.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,14 +14,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import noop from "../../../../../../utils/noop";
-import { parseString } from "../utils";
-import { generateBaseUrlAttrParser } from "./BaseURL";
-import { generateContentProtectionAttrParser } from "./ContentProtection";
-import { generateSchemeAttrParser } from "./Scheme";
-import { generateSegmentBaseAttrParser } from "./SegmentBase";
-import { generateSegmentListChildrenParser } from "./SegmentList";
-import { generateSegmentTemplateAttrParser } from "./SegmentTemplate";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRepresentationAttrParser = exports.generateRepresentationChildrenParser = void 0;
+const noop_1 = require("../../../../../../utils/noop");
+const utils_1 = require("../utils");
+const BaseURL_1 = require("./BaseURL");
+const ContentProtection_1 = require("./ContentProtection");
+const Scheme_1 = require("./Scheme");
+const SegmentBase_1 = require("./SegmentBase");
+const SegmentList_1 = require("./SegmentList");
+const SegmentTemplate_1 = require("./SegmentTemplate");
 /**
  * Generate a "children parser" once inside a `Representation` node.
  * @param {Object} childrenObj
@@ -28,89 +31,100 @@ import { generateSegmentTemplateAttrParser } from "./SegmentTemplate";
  * @param {ParsersStack} parsersStack
  * @returns {Function}
  */
-export function generateRepresentationChildrenParser(childrenObj, linearMemory, parsersStack) {
+function generateRepresentationChildrenParser(childrenObj, linearMemory, parsersStack) {
     return function onRootChildren(nodeId) {
         switch (nodeId) {
             case 15 /* TagName.BaseURL */: {
-                var baseUrl = { value: "", attributes: {} };
+                const baseUrl = { value: "", attributes: {} };
                 childrenObj.baseURLs.push(baseUrl);
-                parsersStack.pushParsers(nodeId, noop, generateBaseUrlAttrParser(baseUrl, linearMemory));
+                parsersStack.pushParsers(nodeId, noop_1.default, (0, BaseURL_1.generateBaseUrlAttrParser)(baseUrl, linearMemory));
                 break;
             }
             case 10 /* TagName.ContentProtection */: {
-                var contentProtection = { children: { cencPssh: [] },
+                const contentProtection = { children: { cencPssh: [] },
                     attributes: {} };
                 if (childrenObj.contentProtections === undefined) {
                     childrenObj.contentProtections = [];
                 }
                 childrenObj.contentProtections.push(contentProtection);
-                var contentProtAttrParser = generateContentProtectionAttrParser(contentProtection, linearMemory);
-                parsersStack.pushParsers(nodeId, noop, contentProtAttrParser);
+                const contentProtAttrParser = (0, ContentProtection_1.generateContentProtectionAttrParser)(contentProtection, linearMemory);
+                parsersStack.pushParsers(nodeId, noop_1.default, contentProtAttrParser);
                 break;
             }
             case 19 /* TagName.InbandEventStream */: {
-                var inbandEvent = {};
+                const inbandEvent = {};
                 if (childrenObj.inbandEventStreams === undefined) {
                     childrenObj.inbandEventStreams = [];
                 }
                 childrenObj.inbandEventStreams.push(inbandEvent);
-                parsersStack.pushParsers(nodeId, noop, generateSchemeAttrParser(inbandEvent, linearMemory));
+                parsersStack.pushParsers(nodeId, noop_1.default, (0, Scheme_1.generateSchemeAttrParser)(inbandEvent, linearMemory));
+                break;
+            }
+            case 13 /* TagName.SupplementalProperty */: {
+                const supplementalProperty = {};
+                if (childrenObj.supplementalProperties === undefined) {
+                    childrenObj.supplementalProperties = [];
+                }
+                childrenObj.supplementalProperties.push(supplementalProperty);
+                const attributeParser = (0, Scheme_1.generateSchemeAttrParser)(supplementalProperty, linearMemory);
+                parsersStack.pushParsers(nodeId, noop_1.default, attributeParser);
                 break;
             }
             case 17 /* TagName.SegmentBase */: {
-                var segmentBaseObj = {};
+                const segmentBaseObj = {};
                 childrenObj.segmentBase = segmentBaseObj;
-                var attributeParser = generateSegmentBaseAttrParser(segmentBaseObj, linearMemory);
-                parsersStack.pushParsers(nodeId, noop, attributeParser);
+                const attributeParser = (0, SegmentBase_1.generateSegmentBaseAttrParser)(segmentBaseObj, linearMemory);
+                parsersStack.pushParsers(nodeId, noop_1.default, attributeParser);
                 break;
             }
             case 18 /* TagName.SegmentList */: {
-                var segmentListObj = { list: [] };
+                const segmentListObj = { list: [] };
                 childrenObj.segmentList = segmentListObj;
-                var childrenParser = generateSegmentListChildrenParser(segmentListObj, linearMemory, parsersStack);
+                const childrenParser = (0, SegmentList_1.generateSegmentListChildrenParser)(segmentListObj, linearMemory, parsersStack);
                 // Re-use SegmentBase attribute parse as we should have the same attributes
-                var attributeParser = generateSegmentBaseAttrParser(segmentListObj, linearMemory);
+                const attributeParser = (0, SegmentBase_1.generateSegmentBaseAttrParser)(segmentListObj, linearMemory);
                 parsersStack.pushParsers(nodeId, childrenParser, attributeParser);
                 break;
             }
             case 16 /* TagName.SegmentTemplate */: {
-                var stObj = {};
+                const stObj = {};
                 childrenObj.segmentTemplate = stObj;
-                parsersStack.pushParsers(nodeId, noop, // SegmentTimeline as treated like an attribute
-                generateSegmentTemplateAttrParser(stObj, linearMemory));
+                parsersStack.pushParsers(nodeId, noop_1.default, // SegmentTimeline as treated like an attribute
+                (0, SegmentTemplate_1.generateSegmentTemplateAttrParser)(stObj, linearMemory));
                 break;
             }
             default:
                 // Allows to make sure we're not mistakenly closing a re-opened
                 // tag.
-                parsersStack.pushParsers(nodeId, noop, noop);
+                parsersStack.pushParsers(nodeId, noop_1.default, noop_1.default);
                 break;
         }
     };
 }
+exports.generateRepresentationChildrenParser = generateRepresentationChildrenParser;
 /**
  * @param {Object} representationAttrs
  * @param {WebAssembly.Memory} linearMemory
  * @returns {Function}
  */
-export function generateRepresentationAttrParser(representationAttrs, linearMemory) {
-    var textDecoder = new TextDecoder();
+function generateRepresentationAttrParser(representationAttrs, linearMemory) {
+    const textDecoder = new TextDecoder();
     return function onRepresentationAttribute(attr, ptr, len) {
-        var dataView = new DataView(linearMemory.buffer);
+        const dataView = new DataView(linearMemory.buffer);
         switch (attr) {
             case 0 /* AttributeName.Id */:
-                representationAttrs.id = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                representationAttrs.id = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 3 /* AttributeName.AudioSamplingRate */:
                 representationAttrs.audioSamplingRate =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                    (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 63 /* AttributeName.Bitrate */:
                 representationAttrs.bitrate = dataView.getFloat64(ptr, true);
                 break;
             case 4 /* AttributeName.Codecs */:
                 representationAttrs.codecs =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                    (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 5 /* AttributeName.CodingDependency */:
                 representationAttrs.codingDependency =
@@ -133,18 +147,18 @@ export function generateRepresentationAttrParser(representationAttrs, linearMemo
                 break;
             case 11 /* AttributeName.MimeType */:
                 representationAttrs.mimeType =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                    (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 2 /* AttributeName.Profiles */:
                 representationAttrs.profiles =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                    (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 65 /* AttributeName.QualityRanking */:
                 representationAttrs.qualityRanking = dataView.getFloat64(ptr, true);
                 break;
             case 12 /* AttributeName.SegmentProfiles */:
                 representationAttrs.segmentProfiles =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                    (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 43 /* AttributeName.AvailabilityTimeOffset */:
                 representationAttrs.availabilityTimeOffset = dataView.getFloat64(ptr, true);
@@ -155,3 +169,4 @@ export function generateRepresentationAttrParser(representationAttrs, linearMemo
         }
     };
 }
+exports.generateRepresentationAttrParser = generateRepresentationAttrParser;

package/dist/_esm5.processed/parsers/manifest/dash/wasm-parser/ts/generators/Scheme.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,23 +14,26 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { parseString } from "../utils";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSchemeAttrParser = void 0;
+const utils_1 = require("../utils");
 /**
  * Generate an "attribute parser" once inside a `BaseURL` node.
  * @param {Object} baseUrlAttrs
  * @param {WebAssembly.Memory} linearMemory
  * @returns {Function}
  */
-export function generateSchemeAttrParser(schemeAttrs, linearMemory) {
-    var textDecoder = new TextDecoder();
+function generateSchemeAttrParser(schemeAttrs, linearMemory) {
+    const textDecoder = new TextDecoder();
     return function onMPDAttribute(attr, ptr, len) {
         switch (attr) {
             case 16 /* AttributeName.SchemeIdUri */:
-                schemeAttrs.schemeIdUri = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                schemeAttrs.schemeIdUri = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 17 /* AttributeName.SchemeValue */:
-                schemeAttrs.value = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                schemeAttrs.value = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
         }
     };
 }
+exports.generateSchemeAttrParser = generateSchemeAttrParser;

package/dist/_esm5.processed/parsers/manifest/dash/wasm-parser/ts/generators/SegmentBase.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,13 +14,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { parseString } from "../utils";
-export function generateSegmentBaseAttrParser(segmentBaseAttrs, linearMemory) {
-    var textDecoder = new TextDecoder();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSegmentBaseAttrParser = void 0;
+const utils_1 = require("../utils");
+function generateSegmentBaseAttrParser(segmentBaseAttrs, linearMemory) {
+    const textDecoder = new TextDecoder();
     return function onSegmentBaseAttribute(attr, ptr, len) {
         switch (attr) {
             case 29 /* AttributeName.InitializationRange */: {
-                var dataView = new DataView(linearMemory.buffer);
+                const dataView = new DataView(linearMemory.buffer);
                 if (segmentBaseAttrs.initialization === undefined) {
                     segmentBaseAttrs.initialization = {};
                 }
@@ -34,10 +37,10 @@ export function generateSegmentBaseAttrParser(segmentBaseAttrs, linearMemory) {
                     segmentBaseAttrs.initialization = {};
                 }
                 segmentBaseAttrs.initialization.media =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                    (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 43 /* AttributeName.AvailabilityTimeOffset */: {
-                var dataView = new DataView(linearMemory.buffer);
+                const dataView = new DataView(linearMemory.buffer);
                 segmentBaseAttrs.availabilityTimeOffset =
                     dataView.getFloat64(ptr, true);
                 break;
@@ -48,19 +51,19 @@ export function generateSegmentBaseAttrParser(segmentBaseAttrs, linearMemory) {
                 break;
             }
             case 24 /* AttributeName.PresentationTimeOffset */: {
-                var dataView = new DataView(linearMemory.buffer);
+                const dataView = new DataView(linearMemory.buffer);
                 segmentBaseAttrs.presentationTimeOffset =
                     dataView.getFloat64(ptr, true);
                 break;
             }
             case 27 /* AttributeName.TimeScale */: {
-                var dataView = new DataView(linearMemory.buffer);
+                const dataView = new DataView(linearMemory.buffer);
                 segmentBaseAttrs.timescale =
                     dataView.getFloat64(ptr, true);
                 break;
             }
             case 31 /* AttributeName.IndexRange */: {
-                var dataView = new DataView(linearMemory.buffer);
+                const dataView = new DataView(linearMemory.buffer);
                 segmentBaseAttrs.indexRange = [
                     dataView.getFloat64(ptr, true),
                     dataView.getFloat64(ptr + 8, true),
@@ -73,21 +76,22 @@ export function generateSegmentBaseAttrParser(segmentBaseAttrs, linearMemory) {
                 break;
             }
             case 1 /* AttributeName.Duration */: {
-                var dataView = new DataView(linearMemory.buffer);
+                const dataView = new DataView(linearMemory.buffer);
                 segmentBaseAttrs.duration =
                     dataView.getFloat64(ptr, true);
                 break;
             }
             case 20 /* AttributeName.StartNumber */: {
-                var dataView = new DataView(linearMemory.buffer);
+                const dataView = new DataView(linearMemory.buffer);
                 segmentBaseAttrs.startNumber = dataView.getFloat64(ptr, true);
                 break;
             }
             case 76 /* AttributeName.EndNumber */: {
-                var dataView = new DataView(linearMemory.buffer);
+                const dataView = new DataView(linearMemory.buffer);
                 segmentBaseAttrs.endNumber = dataView.getFloat64(ptr, true);
                 break;
             }
         }
     };
 }
+exports.generateSegmentBaseAttrParser = generateSegmentBaseAttrParser;