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

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,16 +14,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import noop from "../../../../../../utils/noop";
-import { parseFloatOrBool, parseString, } from "../utils";
-import { generateBaseUrlAttrParser } from "./BaseURL";
-import { generateContentComponentAttrParser } from "./ContentComponent";
-import { generateContentProtectionAttrParser } from "./ContentProtection";
-import { generateRepresentationAttrParser, generateRepresentationChildrenParser, } from "./Representation";
-import { generateSchemeAttrParser } from "./Scheme";
-import { generateSegmentBaseAttrParser } from "./SegmentBase";
-import { generateSegmentListChildrenParser } from "./SegmentList";
-import { generateSegmentTemplateAttrParser } from "./SegmentTemplate";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAdaptationSetAttrParser = exports.generateAdaptationSetChildrenParser = void 0;
+const noop_1 = require("../../../../../../utils/noop");
+const utils_1 = require("../utils");
+const BaseURL_1 = require("./BaseURL");
+const ContentComponent_1 = require("./ContentComponent");
+const ContentProtection_1 = require("./ContentProtection");
+const Representation_1 = require("./Representation");
+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 `AdaptationSet` node.
  * @param {Object} adaptationSetChildren
@@ -30,151 +33,152 @@ import { generateSegmentTemplateAttrParser } from "./SegmentTemplate";
  * @param {ParsersStack} parsersStack
  * @returns {Function}
  */
-export function generateAdaptationSetChildrenParser(adaptationSetChildren, linearMemory, parsersStack) {
+function generateAdaptationSetChildrenParser(adaptationSetChildren, linearMemory, parsersStack) {
     return function onRootChildren(nodeId) {
         switch (nodeId) {
             case 8 /* TagName.Accessibility */: {
-                var accessibility = {};
+                const accessibility = {};
                 if (adaptationSetChildren.accessibilities === undefined) {
                     adaptationSetChildren.accessibilities = [];
                 }
                 adaptationSetChildren.accessibilities.push(accessibility);
-                var schemeAttrParser = generateSchemeAttrParser(accessibility, linearMemory);
-                parsersStack.pushParsers(nodeId, noop, schemeAttrParser);
+                const schemeAttrParser = (0, Scheme_1.generateSchemeAttrParser)(accessibility, linearMemory);
+                parsersStack.pushParsers(nodeId, noop_1.default, schemeAttrParser);
                 break;
             }
             case 15 /* TagName.BaseURL */: {
-                var baseUrl = { value: "", attributes: {} };
+                const baseUrl = { value: "", attributes: {} };
                 adaptationSetChildren.baseURLs.push(baseUrl);
-                var attributeParser = generateBaseUrlAttrParser(baseUrl, linearMemory);
-                parsersStack.pushParsers(nodeId, noop, attributeParser);
+                const attributeParser = (0, BaseURL_1.generateBaseUrlAttrParser)(baseUrl, linearMemory);
+                parsersStack.pushParsers(nodeId, noop_1.default, attributeParser);
                 break;
             }
             case 9 /* TagName.ContentComponent */: {
-                var contentComponent = {};
+                const contentComponent = {};
                 adaptationSetChildren.contentComponent = contentComponent;
-                parsersStack.pushParsers(nodeId, noop, generateContentComponentAttrParser(contentComponent, linearMemory));
+                parsersStack.pushParsers(nodeId, noop_1.default, (0, ContentComponent_1.generateContentComponentAttrParser)(contentComponent, linearMemory));
                 break;
             }
             case 10 /* TagName.ContentProtection */: {
-                var contentProtection = { children: { cencPssh: [] },
+                const contentProtection = { children: { cencPssh: [] },
                     attributes: {} };
                 if (adaptationSetChildren.contentProtections === undefined) {
                     adaptationSetChildren.contentProtections = [];
                 }
                 adaptationSetChildren.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 11 /* TagName.EssentialProperty */: {
-                var essentialProperty = {};
+                const essentialProperty = {};
                 if (adaptationSetChildren.essentialProperties === undefined) {
                     adaptationSetChildren.essentialProperties = [];
                 }
                 adaptationSetChildren.essentialProperties.push(essentialProperty);
-                var childrenParser = noop; // EssentialProperty have no sub-element
-                var attributeParser = generateSchemeAttrParser(essentialProperty, linearMemory);
+                const childrenParser = noop_1.default; // EssentialProperty have no sub-element
+                const attributeParser = (0, Scheme_1.generateSchemeAttrParser)(essentialProperty, linearMemory);
                 parsersStack.pushParsers(nodeId, childrenParser, attributeParser);
                 break;
             }
             case 19 /* TagName.InbandEventStream */: {
-                var inbandEvent = {};
+                const inbandEvent = {};
                 if (adaptationSetChildren.inbandEventStreams === undefined) {
                     adaptationSetChildren.inbandEventStreams = [];
                 }
                 adaptationSetChildren.inbandEventStreams.push(inbandEvent);
-                var childrenParser = noop; // InbandEventStream have no sub-element
-                var attributeParser = generateSchemeAttrParser(inbandEvent, linearMemory);
+                const childrenParser = noop_1.default; // InbandEventStream have no sub-element
+                const attributeParser = (0, Scheme_1.generateSchemeAttrParser)(inbandEvent, linearMemory);
                 parsersStack.pushParsers(nodeId, childrenParser, attributeParser);
                 break;
             }
             case 7 /* TagName.Representation */: {
-                var representationObj = { children: { baseURLs: [] },
+                const representationObj = { children: { baseURLs: [] },
                     attributes: {} };
                 adaptationSetChildren.representations.push(representationObj);
-                var childrenParser = generateRepresentationChildrenParser(representationObj.children, linearMemory, parsersStack);
-                var attributeParser = generateRepresentationAttrParser(representationObj.attributes, linearMemory);
+                const childrenParser = (0, Representation_1.generateRepresentationChildrenParser)(representationObj.children, linearMemory, parsersStack);
+                const attributeParser = (0, Representation_1.generateRepresentationAttrParser)(representationObj.attributes, linearMemory);
                 parsersStack.pushParsers(nodeId, childrenParser, attributeParser);
                 break;
             }
             case 12 /* TagName.Role */: {
-                var role = {};
+                const role = {};
                 if (adaptationSetChildren.roles === undefined) {
                     adaptationSetChildren.roles = [];
                 }
                 adaptationSetChildren.roles.push(role);
-                var attributeParser = generateSchemeAttrParser(role, linearMemory);
-                parsersStack.pushParsers(nodeId, noop, attributeParser);
+                const attributeParser = (0, Scheme_1.generateSchemeAttrParser)(role, linearMemory);
+                parsersStack.pushParsers(nodeId, noop_1.default, attributeParser);
                 break;
             }
             case 13 /* TagName.SupplementalProperty */: {
-                var supplementalProperty = {};
+                const supplementalProperty = {};
                 if (adaptationSetChildren.supplementalProperties === undefined) {
                     adaptationSetChildren.supplementalProperties = [];
                 }
                 adaptationSetChildren.supplementalProperties.push(supplementalProperty);
-                var attributeParser = generateSchemeAttrParser(supplementalProperty, linearMemory);
-                parsersStack.pushParsers(nodeId, noop, attributeParser);
+                const attributeParser = (0, Scheme_1.generateSchemeAttrParser)(supplementalProperty, linearMemory);
+                parsersStack.pushParsers(nodeId, noop_1.default, attributeParser);
                 break;
             }
             case 17 /* TagName.SegmentBase */: {
-                var segmentBaseObj = {};
+                const segmentBaseObj = {};
                 adaptationSetChildren.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: [] };
                 adaptationSetChildren.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 = {};
                 adaptationSetChildren.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.generateAdaptationSetChildrenParser = generateAdaptationSetChildrenParser;
 /**
  * @param {Object} adaptationAttrs
  * @param {WebAssembly.Memory} linearMemory
  * @returns {Function}
  */
-export function generateAdaptationSetAttrParser(adaptationAttrs, linearMemory) {
-    var textDecoder = new TextDecoder();
+function generateAdaptationSetAttrParser(adaptationAttrs, linearMemory) {
+    const textDecoder = new TextDecoder();
     return function onAdaptationSetAttribute(attr, ptr, len) {
-        var dataView = new DataView(linearMemory.buffer);
+        const dataView = new DataView(linearMemory.buffer);
         switch (attr) {
             case 0 /* AttributeName.Id */:
-                adaptationAttrs.id = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                adaptationAttrs.id = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 48 /* AttributeName.Group */:
                 adaptationAttrs.group = dataView.getFloat64(ptr, true);
                 break;
             case 60 /* AttributeName.Language */:
                 adaptationAttrs.language =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                    (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 61 /* AttributeName.ContentType */:
                 adaptationAttrs.contentType =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                    (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 62 /* AttributeName.Par */:
-                adaptationAttrs.par = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                adaptationAttrs.par = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 53 /* AttributeName.MinBandwidth */:
                 adaptationAttrs.minBitrate = dataView.getFloat64(ptr, true);
@@ -205,34 +209,34 @@ export function generateAdaptationSetAttrParser(adaptationAttrs, linearMemory) {
                 break;
             case 58 /* AttributeName.SegmentAlignment */:
                 adaptationAttrs.segmentAlignment =
-                    parseFloatOrBool(dataView.getFloat64(ptr, true));
+                    (0, utils_1.parseFloatOrBool)(dataView.getFloat64(ptr, true));
                 break;
             case 59 /* AttributeName.SubsegmentAlignment */:
                 adaptationAttrs.subsegmentAlignment =
-                    parseFloatOrBool(dataView.getFloat64(ptr, true));
+                    (0, utils_1.parseFloatOrBool)(dataView.getFloat64(ptr, true));
                 break;
             case 32 /* AttributeName.BitstreamSwitching */:
                 adaptationAttrs.bitstreamSwitching = dataView.getFloat64(ptr, true) !== 0;
                 break;
             case 3 /* AttributeName.AudioSamplingRate */:
                 adaptationAttrs.audioSamplingRate =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                    (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 4 /* AttributeName.Codecs */:
                 adaptationAttrs.codecs =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                    (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 2 /* AttributeName.Profiles */:
                 adaptationAttrs.profiles =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                    (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 12 /* AttributeName.SegmentProfiles */:
                 adaptationAttrs.segmentProfiles =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                    (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 11 /* AttributeName.MimeType */:
                 adaptationAttrs.mimeType =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                    (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 5 /* AttributeName.CodingDependency */:
                 adaptationAttrs.codingDependency = dataView.getFloat64(ptr, true) !== 0;
@@ -259,7 +263,7 @@ export function generateAdaptationSetAttrParser(adaptationAttrs, linearMemory) {
                 adaptationAttrs.availabilityTimeComplete = dataView.getUint8(0) === 0;
                 break;
             case 71 /* AttributeName.Label */:
-                var label = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                const label = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 adaptationAttrs.label = label;
                 break;
             // TODO
@@ -268,3 +272,4 @@ export function generateAdaptationSetAttrParser(adaptationAttrs, linearMemory) {
         }
     };
 }
+exports.generateAdaptationSetAttrParser = generateAdaptationSetAttrParser;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,18 +14,21 @@
  * 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.generateBaseUrlAttrParser = 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 generateBaseUrlAttrParser(baseUrlAttrs, linearMemory) {
-    var textDecoder = new TextDecoder();
+function generateBaseUrlAttrParser(baseUrlAttrs, linearMemory) {
+    const textDecoder = new TextDecoder();
     return function onMPDAttribute(attr, ptr, len) {
         if (attr === 64 /* AttributeName.Text */) {
-            baseUrlAttrs.value = parseString(textDecoder, linearMemory.buffer, ptr, len);
+            baseUrlAttrs.value = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
         }
     };
 }
+exports.generateBaseUrlAttrParser = generateBaseUrlAttrParser;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,29 +14,32 @@
  * 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.generateContentComponentAttrParser = 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 generateContentComponentAttrParser(ccAttrs, linearMemory) {
-    var textDecoder = new TextDecoder();
+function generateContentComponentAttrParser(ccAttrs, linearMemory) {
+    const textDecoder = new TextDecoder();
     return function onMPDAttribute(attr, ptr, len) {
         switch (attr) {
             case 0 /* AttributeName.Id */:
-                ccAttrs.id = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                ccAttrs.id = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 60 /* AttributeName.Language */:
-                ccAttrs.language = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                ccAttrs.language = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 61 /* AttributeName.ContentType */:
-                ccAttrs.contentType = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                ccAttrs.contentType = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 62 /* AttributeName.Par */:
-                ccAttrs.par = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                ccAttrs.par = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
         }
     };
 }
+exports.generateContentComponentAttrParser = generateContentComponentAttrParser;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,37 +14,40 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { base64ToBytes } from "../../../../../../utils/base64";
-import { hexToBytes } from "../../../../../../utils/string_parsing";
-import { parseString } from "../utils";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateContentProtectionAttrParser = void 0;
+const base64_1 = require("../../../../../../utils/base64");
+const string_parsing_1 = require("../../../../../../utils/string_parsing");
+const utils_1 = require("../utils");
 /**
  * @param {Object} cpAttrs
  * @param {WebAssembly.Memory} linearMemory
  * @returns {Function}
  */
-export function generateContentProtectionAttrParser(cp, linearMemory) {
-    var cpAttrs = cp.attributes;
-    var cpChildren = cp.children;
-    var textDecoder = new TextDecoder();
+function generateContentProtectionAttrParser(cp, linearMemory) {
+    const cpAttrs = cp.attributes;
+    const cpChildren = cp.children;
+    const textDecoder = new TextDecoder();
     return function onContentProtectionAttribute(attr, ptr, len) {
         switch (attr) {
             case 16 /* AttributeName.SchemeIdUri */:
-                cpAttrs.schemeIdUri = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                cpAttrs.schemeIdUri = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 13 /* AttributeName.ContentProtectionValue */:
-                cpAttrs.value = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                cpAttrs.value = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 14 /* AttributeName.ContentProtectionKeyId */:
-                var kid = parseString(textDecoder, linearMemory.buffer, ptr, len);
-                cpAttrs.keyId = hexToBytes(kid.replace(/-/g, ""));
+                const kid = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
+                cpAttrs.keyId = (0, string_parsing_1.hexToBytes)(kid.replace(/-/g, ""));
                 break;
             case 15 /* AttributeName.ContentProtectionCencPSSH */:
                 try {
-                    var b64 = parseString(textDecoder, linearMemory.buffer, ptr, len);
-                    cpChildren.cencPssh.push(base64ToBytes(b64));
+                    const b64 = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
+                    cpChildren.cencPssh.push((0, base64_1.base64ToBytes)(b64));
                 }
                 catch (_) { /* TODO log error? register as warning? */ }
                 break;
         }
     };
 }
+exports.generateContentProtectionAttrParser = generateContentProtectionAttrParser;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,8 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import noop from "../../../../../../utils/noop";
-import { parseString } from "../utils";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEventStreamAttrParser = exports.generateEventStreamChildrenParser = void 0;
+const noop_1 = require("../../../../../../utils/noop");
+const utils_1 = require("../utils");
 /**
  * Generate a "children parser" once inside a `EventStream` node.
  * @param {Object} childrenObj
@@ -23,55 +26,56 @@ import { parseString } from "../utils";
  * @param {ArrayBuffer} fullMpd
  * @returns {Function}
  */
-export function generateEventStreamChildrenParser(childrenObj, linearMemory, parsersStack, fullMpd) {
+function generateEventStreamChildrenParser(childrenObj, linearMemory, parsersStack, fullMpd) {
     return function onRootChildren(nodeId) {
         switch (nodeId) {
             case 6 /* TagName.EventStreamElt */: {
-                var event_1 = {};
-                childrenObj.events.push(event_1);
-                var attrParser = generateEventAttrParser(event_1, linearMemory, fullMpd);
-                parsersStack.pushParsers(nodeId, noop, attrParser);
+                const event = {};
+                childrenObj.events.push(event);
+                const attrParser = generateEventAttrParser(event, linearMemory, fullMpd);
+                parsersStack.pushParsers(nodeId, noop_1.default, attrParser);
                 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.generateEventStreamChildrenParser = generateEventStreamChildrenParser;
 /**
  * @param {Object} esAttrs
  * @param {WebAssembly.Memory} linearMemory
  * @returns {Function}
  */
-export function generateEventStreamAttrParser(esAttrs, linearMemory) {
-    var textDecoder = new TextDecoder();
+function generateEventStreamAttrParser(esAttrs, linearMemory) {
+    const textDecoder = new TextDecoder();
     return function onEventStreamAttribute(attr, ptr, len) {
-        var dataView = new DataView(linearMemory.buffer);
+        const dataView = new DataView(linearMemory.buffer);
         switch (attr) {
             case 16 /* AttributeName.SchemeIdUri */:
                 esAttrs.schemeIdUri =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                    (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 17 /* AttributeName.SchemeValue */:
                 esAttrs.value =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                    (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 27 /* AttributeName.TimeScale */:
                 esAttrs.timescale = dataView.getFloat64(ptr, true);
                 break;
             case 70 /* AttributeName.Namespace */:
-                var xmlNs = { key: "", value: "" };
-                var offset = ptr;
-                var keySize = dataView.getUint32(offset);
+                const xmlNs = { key: "", value: "" };
+                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 (esAttrs.namespaces === undefined) {
                     esAttrs.namespaces = [xmlNs];
                 }
@@ -82,6 +86,7 @@ export function generateEventStreamAttrParser(esAttrs, linearMemory) {
         }
     };
 }
+exports.generateEventStreamAttrParser = generateEventStreamAttrParser;
 /**
  * @param {Object} eventAttr
  * @param {WebAssembly.Memory} linearMemory
@@ -89,9 +94,9 @@ export function generateEventStreamAttrParser(esAttrs, linearMemory) {
  * @returns {Function}
  */
 function generateEventAttrParser(eventAttr, linearMemory, fullMpd) {
-    var textDecoder = new TextDecoder();
+    const textDecoder = new TextDecoder();
     return function onEventStreamAttribute(attr, ptr, len) {
-        var dataView = new DataView(linearMemory.buffer);
+        const dataView = new DataView(linearMemory.buffer);
         switch (attr) {
             case 25 /* AttributeName.EventPresentationTime */:
                 eventAttr.presentationTime = dataView.getFloat64(ptr, true);
@@ -100,11 +105,11 @@ function generateEventAttrParser(eventAttr, linearMemory, fullMpd) {
                 eventAttr.duration = dataView.getFloat64(ptr, true);
                 break;
             case 0 /* AttributeName.Id */:
-                eventAttr.id = parseString(textDecoder, linearMemory.buffer, ptr, len);
+                eventAttr.id = (0, utils_1.parseString)(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 69 /* AttributeName.EventStreamEltRange */:
-                var rangeStart = dataView.getFloat64(ptr, true);
-                var rangeEnd = dataView.getFloat64(ptr + 8, true);
+                const rangeStart = dataView.getFloat64(ptr, true);
+                const rangeEnd = dataView.getFloat64(ptr + 8, true);
                 eventAttr.eventStreamData = fullMpd.slice(rangeStart, rangeEnd);
                 break;
         }