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

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

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

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

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

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

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

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

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

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

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