rx-player 4.0.0 → 4.1.0-dev.2024031100

package/dist/es2017/parsers/manifest/dash/native-parser/parse_from_document.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IMPDParserArguments } from "../common";
+import type { IDashParserResponse } from "../parsers_types";
+/**
+ * Parse MPD through the JS parser, on a `Document` instance.
+ * @param {Document} document - Original manifest as returned by the server
+ * @param {Object} args - Various parsing options and information.
+ * @returns {Object} - Response returned by the DASH-JS parser.
+ */
+export default function parseFromDocument(document: Document, args: IMPDParserArguments): IDashParserResponse<string>;

package/dist/es2017/parsers/manifest/dash/native-parser/parse_from_document.js

@@ -0,0 +1,108 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { assertUnreachable } from "../../../../utils/assert";
+import isNullOrUndefined from "../../../../utils/is_null_or_undefined";
+import parseMpdIr from "../common";
+import { createMPDIntermediateRepresentation } from "./node_parsers/MPD";
+import { createPeriodIntermediateRepresentation } from "./node_parsers/Period";
+/**
+ * Parse MPD through the JS parser, on a `Document` instance.
+ * @param {Document} document - Original manifest as returned by the server
+ * @param {Object} args - Various parsing options and information.
+ * @returns {Object} - Response returned by the DASH-JS parser.
+ */
+export default function parseFromDocument(document, args) {
+    const root = document.documentElement;
+    if (isNullOrUndefined(root) || root.nodeName !== "MPD") {
+        throw new Error("DASH Parser: document root should be MPD");
+    }
+    const [mpdIR, warnings] = createMPDIntermediateRepresentation(root);
+    const ret = parseMpdIr(mpdIR, args, warnings);
+    return processReturn(ret);
+    /**
+     * Handle `parseMpdIr` return values, asking for resources if they are needed
+     * and pre-processing them before continuing parsing.
+     *
+     * @param {Object} initialRes
+     * @returns {Object}
+     */
+    function processReturn(initialRes) {
+        if (initialRes.type === "done") {
+            return initialRes;
+        }
+        else if (initialRes.type === "needs-clock") {
+            return {
+                type: "needs-resources",
+                value: {
+                    urls: [initialRes.value.url],
+                    format: "string",
+                    continue(loadedClock) {
+                        if (loadedClock.length !== 1) {
+                            throw new Error("DASH parser: wrong number of loaded ressources.");
+                        }
+                        const newRet = initialRes.value.continue(loadedClock[0].responseData);
+                        return processReturn(newRet);
+                    },
+                },
+            };
+        }
+        else if (initialRes.type === "needs-xlinks") {
+            return {
+                type: "needs-resources",
+                value: {
+                    urls: initialRes.value.xlinksUrls,
+                    format: "string",
+                    continue(loadedXlinks) {
+                        const resourceInfos = [];
+                        for (let i = 0; i < loadedXlinks.length; i++) {
+                            const { responseData: xlinkResp, receivedTime, sendingTime, url, } = loadedXlinks[i];
+                            if (!xlinkResp.success) {
+                                throw xlinkResp.error;
+                            }
+                            const wrappedData = "<root>" + xlinkResp.data + "</root>";
+                            const dataAsXML = new DOMParser().parseFromString(wrappedData, "text/xml");
+                            if (isNullOrUndefined(dataAsXML) || dataAsXML.children.length === 0) {
+                                throw new Error("DASH parser: Invalid external ressources");
+                            }
+                            const periods = dataAsXML.children[0].children;
+                            const periodsIR = [];
+                            const periodsIRWarnings = [];
+                            for (let j = 0; j < periods.length; j++) {
+                                if (periods[j].nodeType === Node.ELEMENT_NODE) {
+                                    const [periodIR, periodWarnings] = createPeriodIntermediateRepresentation(periods[j]);
+                                    periodsIRWarnings.push(...periodWarnings);
+                                    periodsIR.push(periodIR);
+                                }
+                            }
+                            resourceInfos.push({
+                                url,
+                                receivedTime,
+                                sendingTime,
+                                parsed: periodsIR,
+                                warnings: periodsIRWarnings,
+                            });
+                        }
+                        const newRet = initialRes.value.continue(resourceInfos);
+                        return processReturn(newRet);
+                    },
+                },
+            };
+        }
+        else {
+            assertUnreachable(initialRes);
+        }
+    }
+}

package/dist/es2017/parsers/manifest/dash/node_parser_types.d.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import type { ITNode } from "../../../utils/xml-parser";
 /**
  * Those are types used when generating the MPD "Intermediate Representation"
  * which is an intermediate step between parsing the MPD (in XML) and generating
@@ -386,10 +387,11 @@ export interface IEventStreamEventIntermediateRepresentation {
     duration?: number;
     /**
      * The `<Event>` element itself.
-     * Can be in two forms:
+     * Can be under any of those forms:
      *   - Either as an Element instance directly
      *   - Either as the Element's UTF-8 textual representation.
+     *   - Either as the Element's string representation.
      */
-    eventStreamData?: Element | ArrayBuffer;
+    eventStreamData?: Element | ArrayBuffer | string;
 }
-export type ITimelineParser = () => HTMLCollection;
+export type ITimelineParser = () => ITNode[] | HTMLCollection;

package/dist/es2017/parsers/manifest/dash/parsers_types.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IParsedManifest } from "../types";
+import type { IParsedManifest } from "../types";
 export { IMPDParserArguments } from "./common";
 /** Response returned by a DASH MPD parser. */
 export type IDashParserResponse<T extends string | ArrayBuffer> = IDashParserNeedsResources<T> | IDashParserResponseDone;

package/dist/es2017/parsers/manifest/dash/wasm-parser/ts/dash-wasm-parser.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IDashParserResponse, IMPDParserArguments } from "../../parsers_types";
+import type { IDashParserResponse, IMPDParserArguments } from "../../parsers_types";
 export default class DashWasmParser {
     /**
      * Current "status" of the DASH-WASM parser.

package/dist/es2017/parsers/manifest/dash/wasm-parser/ts/dash-wasm-parser.js

@@ -89,9 +89,9 @@ export default class DashWasmParser {
             objectUrl = URL.createObjectURL(new Blob([opts.wasmUrl], { type: "application/wasm" }));
             fetchedWasm = fetch(objectUrl);
         }
-        const streamingProm = typeof WebAssembly.instantiateStreaming === "function" ?
-            WebAssembly.instantiateStreaming(fetchedWasm, imports) :
-            Promise.reject("`WebAssembly.instantiateStreaming` API not available");
+        const streamingProm = typeof WebAssembly.instantiateStreaming === "function"
+            ? WebAssembly.instantiateStreaming(fetchedWasm, imports)
+            : Promise.reject("`WebAssembly.instantiateStreaming` API not available");
         this._initProm = streamingProm
             .catch(async (e) => {
             if (objectUrl !== null) {
@@ -115,9 +115,9 @@ export default class DashWasmParser {
             // TODO better types?
             this._linearMemory = this._instance.instance.exports.memory;
             this.status = "initialized";
-        }).catch((err) => {
-            const message = err instanceof Error ? err.toString() :
-                "Unknown error";
+        })
+            .catch((err) => {
+            const message = err instanceof Error ? err.toString() : "Unknown error";
             log.warn("DW: Could not create DASH-WASM parser:", message);
             this.status = "failure";
             throw err;
@@ -225,8 +225,7 @@ export default class DashWasmParser {
      * @returns {boolean}
      */
     isCompatible() {
-        return hasWebassembly &&
-            typeof globalScope.TextDecoder === "function";
+        return hasWebassembly && typeof globalScope.TextDecoder === "function";
     }
     _parseMpd(mpd) {
         var _a;
@@ -269,7 +268,9 @@ export default class DashWasmParser {
         }
         this._isParsing = true;
         this._mpdData = { mpd: xlinkData, cursor: 0 };
-        const rootObj = { periods: [] };
+        const rootObj = {
+            periods: [],
+        };
         const linearMemory = this._linearMemory;
         const xlinkParser = generateXLinkChildrenParser(rootObj, linearMemory, this._parsersStack, xlinkData);
         this._parsersStack.pushParsers(null, xlinkParser, noop);
@@ -310,33 +311,43 @@ export default class DashWasmParser {
                 const newRet = initialRes.value.continue(loadedClock[0].responseData);
                 return this._processParserReturnValue(newRet);
             };
-            return { type: "needs-resources",
-                value: { urls: [initialRes.value.url],
+            return {
+                type: "needs-resources",
+                value: {
+                    urls: [initialRes.value.url],
                     format: "string",
-                    continue: continueParsingMPD } };
+                    continue: continueParsingMPD,
+                },
+            };
         }
         else if (initialRes.type === "needs-xlinks") {
             const continueParsingMPD = (loadedXlinks) => {
                 const resourceInfos = [];
                 for (let i = 0; i < loadedXlinks.length; i++) {
-                    const { responseData: xlinkResp, receivedTime, sendingTime, url } = loadedXlinks[i];
+                    const { responseData: xlinkResp, receivedTime, sendingTime, url, } = loadedXlinks[i];
                     if (!xlinkResp.success) {
                         throw xlinkResp.error;
                     }
                     const [periodsIr, periodsIRWarnings] = this._parseXlink(xlinkResp.data);
-                    resourceInfos.push({ url,
+                    resourceInfos.push({
+                        url,
                         receivedTime,
                         sendingTime,
                         parsed: periodsIr,
-                        warnings: periodsIRWarnings });
+                        warnings: periodsIRWarnings,
+                    });
                 }
                 const newRet = initialRes.value.continue(resourceInfos);
                 return this._processParserReturnValue(newRet);
             };
-            return { type: "needs-resources",
-                value: { urls: initialRes.value.xlinksUrls,
+            return {
+                type: "needs-resources",
+                value: {
+                    urls: initialRes.value.xlinksUrls,
                     format: "arraybuffer",
-                    continue: continueParsingMPD } };
+                    continue: continueParsingMPD,
+                },
+            };
         }
         else {
             assertUnreachable(initialRes);

package/dist/es2017/parsers/manifest/dash/wasm-parser/ts/generators/AdaptationSet.d.ts

@@ -13,8 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IAdaptationSetAttributes, IAdaptationSetChildren } from "../../../node_parser_types";
-import ParsersStack, { IAttributeParser, IChildrenParser } from "../parsers_stack";
+import type { IAdaptationSetAttributes, IAdaptationSetChildren } from "../../../node_parser_types";
+import type { IAttributeParser, IChildrenParser } from "../parsers_stack";
+import type ParsersStack from "../parsers_stack";
 /**
  * Generate a "children parser" once inside a `AdaptationSet` node.
  * @param {Object} adaptationSetChildren

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import noop from "../../../../../../utils/noop";
-import { parseFloatOrBool, parseString, } from "../utils";
+import { parseFloatOrBool, parseString } from "../utils";
 import { generateBaseUrlAttrParser } from "./BaseURL";
 import { generateContentComponentAttrParser } from "./ContentComponent";
 import { generateContentProtectionAttrParser } from "./ContentProtection";
@@ -57,8 +57,10 @@ export function generateAdaptationSetChildrenParser(adaptationSetChildren, linea
                 break;
             }
             case 10 /* TagName.ContentProtection */: {
-                const contentProtection = { children: { cencPssh: [] },
-                    attributes: {} };
+                const contentProtection = {
+                    children: { cencPssh: [] },
+                    attributes: {},
+                };
                 if (adaptationSetChildren.contentProtections === undefined) {
                     adaptationSetChildren.contentProtections = [];
                 }
@@ -90,8 +92,10 @@ export function generateAdaptationSetChildrenParser(adaptationSetChildren, linea
                 break;
             }
             case 7 /* TagName.Representation */: {
-                const representationObj = { children: { baseURLs: [] },
-                    attributes: {} };
+                const representationObj = {
+                    children: { baseURLs: [] },
+                    attributes: {},
+                };
                 adaptationSetChildren.representations.push(representationObj);
                 const childrenParser = generateRepresentationChildrenParser(representationObj.children, linearMemory, parsersStack);
                 const attributeParser = generateRepresentationAttrParser(representationObj.attributes, linearMemory);
@@ -126,7 +130,9 @@ export function generateAdaptationSetChildrenParser(adaptationSetChildren, linea
                 break;
             }
             case 18 /* TagName.SegmentList */: {
-                const segmentListObj = { list: [] };
+                const segmentListObj = {
+                    list: [],
+                };
                 adaptationSetChildren.segmentList = segmentListObj;
                 const childrenParser = generateSegmentListChildrenParser(segmentListObj, linearMemory, parsersStack);
                 // Re-use SegmentBase attribute parse as we should have the same attributes
@@ -166,12 +172,10 @@ export function generateAdaptationSetAttrParser(adaptationAttrs, linearMemory) {
                 adaptationAttrs.group = dataView.getFloat64(ptr, true);
                 break;
             case 60 /* AttributeName.Language */:
-                adaptationAttrs.language =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                adaptationAttrs.language = parseString(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 61 /* AttributeName.ContentType */:
-                adaptationAttrs.contentType =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                adaptationAttrs.contentType = parseString(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 62 /* AttributeName.Par */:
                 adaptationAttrs.par = parseString(textDecoder, linearMemory.buffer, ptr, len);
@@ -204,39 +208,31 @@ export function generateAdaptationSetAttrParser(adaptationAttrs, linearMemory) {
                 adaptationAttrs.selectionPriority = dataView.getFloat64(ptr, true);
                 break;
             case 58 /* AttributeName.SegmentAlignment */:
-                adaptationAttrs.segmentAlignment =
-                    parseFloatOrBool(dataView.getFloat64(ptr, true));
+                adaptationAttrs.segmentAlignment = parseFloatOrBool(dataView.getFloat64(ptr, true));
                 break;
             case 59 /* AttributeName.SubsegmentAlignment */:
-                adaptationAttrs.subsegmentAlignment =
-                    parseFloatOrBool(dataView.getFloat64(ptr, true));
+                adaptationAttrs.subsegmentAlignment = 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);
+                adaptationAttrs.audioSamplingRate = parseString(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 4 /* AttributeName.Codecs */:
-                adaptationAttrs.codecs =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                adaptationAttrs.codecs = parseString(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 77 /* AttributeName.SupplementalCodecs */:
-                adaptationAttrs.supplementalCodecs =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                adaptationAttrs.supplementalCodecs = parseString(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 2 /* AttributeName.Profiles */:
-                adaptationAttrs.profiles =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                adaptationAttrs.profiles = parseString(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 12 /* AttributeName.SegmentProfiles */:
-                adaptationAttrs.segmentProfiles =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                adaptationAttrs.segmentProfiles = parseString(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 11 /* AttributeName.MimeType */:
-                adaptationAttrs.mimeType =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                adaptationAttrs.mimeType = parseString(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 5 /* AttributeName.CodingDependency */:
                 adaptationAttrs.codingDependency = dataView.getFloat64(ptr, true) !== 0;

package/dist/es2017/parsers/manifest/dash/wasm-parser/ts/generators/BaseURL.d.ts

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IBaseUrlIntermediateRepresentation } from "../../../node_parser_types";
-import { IAttributeParser } from "../parsers_stack";
+import type { IBaseUrlIntermediateRepresentation } from "../../../node_parser_types";
+import type { IAttributeParser } from "../parsers_stack";
 /**
  * Generate an "attribute parser" once inside a `BaseURL` node.
  * @param {Object} baseUrlAttrs

package/dist/es2017/parsers/manifest/dash/wasm-parser/ts/generators/ContentComponent.d.ts

@@ -13,11 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IContentComponentAttributes } from "../../../node_parser_types";
-import { IAttributeParser } from "../parsers_stack";
+import type { IContentComponentAttributes } from "../../../node_parser_types";
+import type { IAttributeParser } from "../parsers_stack";
 /**
  * Generate an "attribute parser" once inside a `BaseURL` node.
- * @param {Object} baseUrlAttrs
+ * @param {Object} ccAttrs
  * @param {WebAssembly.Memory} linearMemory
  * @returns {Function}
  */

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

@@ -16,7 +16,7 @@
 import { parseString } from "../utils";
 /**
  * Generate an "attribute parser" once inside a `BaseURL` node.
- * @param {Object} baseUrlAttrs
+ * @param {Object} ccAttrs
  * @param {WebAssembly.Memory} linearMemory
  * @returns {Function}
  */

package/dist/es2017/parsers/manifest/dash/wasm-parser/ts/generators/ContentProtection.d.ts

@@ -13,10 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IContentProtectionIntermediateRepresentation } from "../../../node_parser_types";
-import { IAttributeParser } from "../parsers_stack";
+import type { IContentProtectionIntermediateRepresentation } from "../../../node_parser_types";
+import type { IAttributeParser } from "../parsers_stack";
 /**
- * @param {Object} cpAttrs
+ * @param {Object} cp
  * @param {WebAssembly.Memory} linearMemory
  * @returns {Function}
  */

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

@@ -17,7 +17,7 @@ import { base64ToBytes } from "../../../../../../utils/base64";
 import { hexToBytes } from "../../../../../../utils/string_parsing";
 import { parseString } from "../utils";
 /**
- * @param {Object} cpAttrs
+ * @param {Object} cp
  * @param {WebAssembly.Memory} linearMemory
  * @returns {Function}
  */
@@ -42,7 +42,9 @@ export function generateContentProtectionAttrParser(cp, linearMemory) {
                     const b64 = parseString(textDecoder, linearMemory.buffer, ptr, len);
                     cpChildren.cencPssh.push(base64ToBytes(b64));
                 }
-                catch (_) { /* TODO log error? register as warning? */ }
+                catch (_) {
+                    /* TODO log error? register as warning? */
+                }
                 break;
         }
     };

package/dist/es2017/parsers/manifest/dash/wasm-parser/ts/generators/EventStream.d.ts

@@ -13,8 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IEventStreamAttributes, IEventStreamChildren } from "../../../node_parser_types";
-import ParsersStack, { IAttributeParser, IChildrenParser } from "../parsers_stack";
+import type { IEventStreamAttributes, IEventStreamChildren } from "../../../node_parser_types";
+import type { IAttributeParser, IChildrenParser } from "../parsers_stack";
+import type ParsersStack from "../parsers_stack";
 /**
  * Generate a "children parser" once inside a `EventStream` node.
  * @param {Object} childrenObj

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

@@ -52,12 +52,10 @@ export function generateEventStreamAttrParser(esAttrs, linearMemory) {
         const dataView = new DataView(linearMemory.buffer);
         switch (attr) {
             case 16 /* AttributeName.SchemeIdUri */:
-                esAttrs.schemeIdUri =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                esAttrs.schemeIdUri = parseString(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 17 /* AttributeName.SchemeValue */:
-                esAttrs.value =
-                    parseString(textDecoder, linearMemory.buffer, ptr, len);
+                esAttrs.value = parseString(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 27 /* AttributeName.TimeScale */:
                 esAttrs.timescale = dataView.getFloat64(ptr, true);

package/dist/es2017/parsers/manifest/dash/wasm-parser/ts/generators/MPD.d.ts

@@ -13,8 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IMPDAttributes, IMPDChildren } from "../../../node_parser_types";
-import ParsersStack, { IAttributeParser, IChildrenParser } from "../parsers_stack";
+import type { IMPDAttributes, IMPDChildren } from "../../../node_parser_types";
+import type { IAttributeParser, IChildrenParser } from "../parsers_stack";
+import type ParsersStack from "../parsers_stack";
 /**
  * Generate a "children parser" once inside an `MPD` node.
  * @param {Object} mpdChildren

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

@@ -16,7 +16,7 @@
 import noop from "../../../../../../utils/noop";
 import { parseString } from "../utils";
 import { generateBaseUrlAttrParser } from "./BaseURL";
-import { generatePeriodAttrParser, generatePeriodChildrenParser, } from "./Period";
+import { generatePeriodAttrParser, generatePeriodChildrenParser } from "./Period";
 import { generateSchemeAttrParser } from "./Scheme";
 /**
  * Generate a "children parser" once inside an `MPD` node.
@@ -38,10 +38,10 @@ export function generateMPDChildrenParser(mpdChildren, linearMemory, parsersStac
                 break;
             }
             case 2 /* TagName.Period */: {
-                const period = { children: { adaptations: [],
-                        baseURLs: [],
-                        eventStreams: [] },
-                    attributes: {} };
+                const period = {
+                    children: { adaptations: [], baseURLs: [], eventStreams: [] },
+                    attributes: {},
+                };
                 mpdChildren.periods.push(period);
                 const childrenParser = generatePeriodChildrenParser(period.children, linearMemory, parsersStack, fullMpd);
                 const attributeParser = generatePeriodAttrParser(period.attributes, linearMemory);

package/dist/es2017/parsers/manifest/dash/wasm-parser/ts/generators/Period.d.ts

@@ -13,8 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IPeriodAttributes, IPeriodChildren } from "../../../node_parser_types";
-import ParsersStack, { IAttributeParser, IChildrenParser } from "../parsers_stack";
+import type { IPeriodAttributes, IPeriodChildren } from "../../../node_parser_types";
+import type { IAttributeParser, IChildrenParser } from "../parsers_stack";
+import type ParsersStack from "../parsers_stack";
 /**
  * Generate a "children parser" once inside a `Perod` node.
  * @param {Object} periodChildren

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

@@ -31,9 +31,10 @@ export function generatePeriodChildrenParser(periodChildren, linearMemory, parse
     return function onRootChildren(nodeId) {
         switch (nodeId) {
             case 4 /* TagName.AdaptationSet */: {
-                const adaptationObj = { children: { baseURLs: [],
-                        representations: [] },
-                    attributes: {} };
+                const adaptationObj = {
+                    children: { baseURLs: [], representations: [] },
+                    attributes: {},
+                };
                 periodChildren.adaptations.push(adaptationObj);
                 const childrenParser = generateAdaptationSetChildrenParser(adaptationObj.children, linearMemory, parsersStack);
                 const attributeParser = generateAdaptationSetAttrParser(adaptationObj.attributes, linearMemory);
@@ -49,7 +50,10 @@ export function generatePeriodChildrenParser(periodChildren, linearMemory, parse
                 break;
             }
             case 5 /* TagName.EventStream */: {
-                const eventStream = { children: { events: [] }, attributes: {} };
+                const eventStream = {
+                    children: { events: [] },
+                    attributes: {},
+                };
                 periodChildren.eventStreams.push(eventStream);
                 const childrenParser = generateEventStreamChildrenParser(eventStream.children, linearMemory, parsersStack, fullMpd);
                 const attrParser = generateEventStreamAttrParser(eventStream.attributes, linearMemory);
@@ -100,8 +104,7 @@ export function generatePeriodAttrParser(periodAttrs, linearMemory) {
                 periodAttrs.xlinkActuate = parseString(textDecoder, linearMemory.buffer, ptr, len);
                 break;
             case 43 /* AttributeName.AvailabilityTimeOffset */:
-                periodAttrs.availabilityTimeOffset =
-                    new DataView(linearMemory.buffer).getFloat64(ptr, true);
+                periodAttrs.availabilityTimeOffset = new DataView(linearMemory.buffer).getFloat64(ptr, true);
                 break;
             case 22 /* AttributeName.AvailabilityTimeComplete */:
                 periodAttrs.availabilityTimeComplete =

package/dist/es2017/parsers/manifest/dash/wasm-parser/ts/generators/Representation.d.ts

@@ -13,8 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IRepresentationAttributes, IRepresentationChildren } from "../../../node_parser_types";
-import ParsersStack, { IAttributeParser, IChildrenParser } from "../parsers_stack";
+import type { IRepresentationAttributes, IRepresentationChildren } from "../../../node_parser_types";
+import type { IAttributeParser, IChildrenParser } from "../parsers_stack";
+import type ParsersStack from "../parsers_stack";
 /**
  * Generate a "children parser" once inside a `Representation` node.
  * @param {Object} childrenObj